fix: allowing plain addresses in rest payloads

fboucquez · fboucquez · commit cc7f8e6df126 · 2021-07-26T07:49:59.000-03:00
diff --git a/src/core/utils/DtoMapping.ts b/src/core/utils/DtoMapping.ts
@@ -45,7 +45,7 @@ export class DtoMapping {
         return new AccountRestrictions(
             accountRestrictions.accountRestrictions.version || 1,
             accountRestrictions['id'],
-            Address.createFromEncoded(accountRestrictions.accountRestrictions.address),
+            DtoMapping.toAddress(accountRestrictions.accountRestrictions.address),
             accountRestrictions.accountRestrictions.restrictions.map((prop) => {
                 const restrictionFlags = prop.restrictionFlags as number;
                 switch (restrictionFlags) {
@@ -55,7 +55,7 @@ export class DtoMapping {
                     case AddressRestrictionFlag.BlockOutgoingAddress:
                         return new AccountRestriction(
                             restrictionFlags,
-                            prop.values.map((value) => Address.createFromEncoded(value as string)),
+                            prop.values.map((value) => DtoMapping.toAddress(value as string)),
                         );
                     case MosaicRestrictionFlag.AllowMosaic:
                     case MosaicRestrictionFlag.BlockMosaic:
@@ -76,6 +76,22 @@ export class DtoMapping {
         );
     }
 
+    /**
+     * This method knows how to convert an address payload sent by Rest to Address.
+     *
+     * Currently rest sends hex encoded addresses, it is desired to use decoded/plain addresses.
+     *
+     * This method handles both format, encoded (deprecated) and decoded/plain/raw addresses.
+     *
+     * Clients using this SDK will be able to process both payloads.
+     *
+     * @param value the address in encoded (6823BB7C3C089D996585466380EDBDC19D4959184893E38C) format or decoded/plain format (SB3KUBHATFCPV7UZQLWAQ2EUR6SIHBSBEOEDDDF3)
+     * @return the Address object.
+     */
+    public static toAddress(value: string): Address {
+        return Address.isValidEncodedAddress(value) ? Address.createFromEncoded(value) : Address.createFromRawAddress(value);
+    }
+
     /**
      * Creates a copy of the first object adding the attributes of the second object.
      * @param object the object to be cloned
diff --git a/src/core/utils/UnresolvedMapping.ts b/src/core/utils/UnresolvedMapping.ts
@@ -21,6 +21,7 @@ import { NamespaceId } from '../../model/namespace/NamespaceId';
 import { NetworkType } from '../../model/network/NetworkType';
 import { Convert } from '../format/Convert';
 import { RawAddress } from '../format/RawAddress';
+import { DtoMapping } from './DtoMapping';
 
 /**
  * @internal
@@ -67,7 +68,7 @@ export class UnresolvedMapping {
         }
 
         // read address from encoded hexadecimal notation
-        return Address.createFromEncoded(address);
+        return DtoMapping.toAddress(address);
     }
 
     /**
diff --git a/src/infrastructure/AccountHttp.ts b/src/infrastructure/AccountHttp.ts
@@ -113,7 +113,7 @@ export class AccountHttp extends Http implements AccountRepository {
         return new AccountInfo(
             dto.account.version || 1,
             dto.id,
-            Address.createFromEncoded(dto.account.address),
+            DtoMapping.toAddress(dto.account.address),
             UInt64.fromNumericString(dto.account.addressHeight),
             dto.account.publicKey,
             UInt64.fromNumericString(dto.account.publicKeyHeight),
diff --git a/src/infrastructure/BlockHttp.ts b/src/infrastructure/BlockHttp.ts
@@ -121,7 +121,7 @@ export class BlockHttp extends Http implements BlockRepository {
             dto.block.proofGamma,
             dto.block.proofScalar,
             dto.block.proofVerificationHash,
-            Address.createFromEncoded(dto.block.beneficiaryAddress),
+            DtoMapping.toAddress(dto.block.beneficiaryAddress),
             dto.meta.transactionsCount,
             dto.meta.statementsCount,
         );
diff --git a/src/infrastructure/HashLockHttp.ts b/src/infrastructure/HashLockHttp.ts
@@ -100,7 +100,7 @@ export class HashLockHttp extends Http implements HashLockRepository {
         return new HashLockInfo(
             dto.lock.version || 1,
             dto.id,
-            Address.createFromEncoded(dto.lock.ownerAddress),
+            DtoMapping.toAddress(dto.lock.ownerAddress),
             new MosaicId(dto.lock.mosaicId),
             UInt64.fromNumericString(dto.lock.amount),
             UInt64.fromNumericString(dto.lock.endHeight),
diff --git a/src/infrastructure/Listener.ts b/src/infrastructure/Listener.ts
@@ -18,6 +18,7 @@ import { Observable, of, Subject } from 'rxjs';
 import { catchError, distinctUntilChanged, filter, map, mergeMap, share, switchMap } from 'rxjs/operators';
 import { BlockInfoDTO } from 'symbol-openapi-typescript-fetch-client';
 import * as WebSocket from 'ws';
+import { DtoMapping } from '../core/utils';
 import { UnresolvedAddress } from '../model';
 import { Address } from '../model/account/Address';
 import { PublicAccount } from '../model/account/PublicAccount';
@@ -578,7 +579,7 @@ export class Listener implements IListener {
             dto.block.proofGamma,
             dto.block.proofScalar,
             dto.block.proofVerificationHash,
-            dto.block.beneficiaryAddress ? Address.createFromEncoded(dto.block.beneficiaryAddress) : undefined,
+            dto.block.beneficiaryAddress ? DtoMapping.toAddress(dto.block.beneficiaryAddress) : undefined,
         );
     }
 
diff --git a/src/infrastructure/MetadataHttp.ts b/src/infrastructure/MetadataHttp.ts
@@ -122,8 +122,8 @@ export class MetadataHttp extends Http implements MetadataRepository {
             new MetadataEntry(
                 metadataEntry.version || 1,
                 metadataEntry.compositeHash,
-                Address.createFromEncoded(metadataEntry.sourceAddress),
-                Address.createFromEncoded(metadataEntry.targetAddress),
+                DtoMapping.toAddress(metadataEntry.sourceAddress),
+                DtoMapping.toAddress(metadataEntry.targetAddress),
                 UInt64.fromHex(metadataEntry.scopedMetadataKey),
                 metadataEntry.metadataType.valueOf(),
                 Convert.decodeHex(metadataEntry.value),
diff --git a/src/infrastructure/MosaicHttp.ts b/src/infrastructure/MosaicHttp.ts
@@ -133,7 +133,7 @@ export class MosaicHttp extends Http implements MosaicRepository {
             new MosaicId(mosaicInfo.mosaic.id),
             UInt64.fromNumericString(mosaicInfo.mosaic.supply),
             UInt64.fromNumericString(mosaicInfo.mosaic.startHeight),
-            Address.createFromEncoded(mosaicInfo.mosaic.ownerAddress),
+            DtoMapping.toAddress(mosaicInfo.mosaic.ownerAddress),
             mosaicInfo.mosaic.revision,
             new MosaicFlags(mosaicInfo.mosaic.flags),
             mosaicInfo.mosaic.divisibility,
diff --git a/src/infrastructure/MultisigHttp.ts b/src/infrastructure/MultisigHttp.ts
@@ -92,11 +92,11 @@ export class MultisigHttp extends Http implements MultisigRepository {
     private toMultisigAccountInfo(dto: MultisigAccountInfoDTO): MultisigAccountInfo {
         return new MultisigAccountInfo(
             dto.multisig.version || 1,
-            Address.createFromEncoded(dto.multisig.accountAddress),
+            DtoMapping.toAddress(dto.multisig.accountAddress),
             dto.multisig.minApproval,
             dto.multisig.minRemoval,
-            dto.multisig.cosignatoryAddresses.map((cosigner) => Address.createFromEncoded(cosigner)),
-            dto.multisig.multisigAddresses.map((multisig) => Address.createFromEncoded(multisig)),
+            dto.multisig.cosignatoryAddresses.map((cosigner) => DtoMapping.toAddress(cosigner)),
+            dto.multisig.multisigAddresses.map((multisig) => DtoMapping.toAddress(multisig)),
         );
     }
 }
diff --git a/src/infrastructure/NamespaceHttp.ts b/src/infrastructure/NamespaceHttp.ts
@@ -82,7 +82,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
             body.accountNames.map(
                 (accountName) =>
                     new AccountNames(
-                        Address.createFromEncoded(accountName.address),
+                        DtoMapping.toAddress(accountName.address),
                         accountName.names.map((name) => {
                             return new NamespaceName(new NamespaceId(name), name);
                         }),
@@ -255,7 +255,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
             dto.namespace.depth,
             NamespaceHttp.extractLevels(dto.namespace),
             NamespaceId.createFromEncoded(dto.namespace.parentId),
-            Address.createFromEncoded(dto.namespace.ownerAddress),
+            DtoMapping.toAddress(dto.namespace.ownerAddress),
             UInt64.fromNumericString(dto.namespace.startHeight),
             UInt64.fromNumericString(dto.namespace.endHeight),
             NamespaceHttp.extractAlias(dto.namespace),
@@ -292,7 +292,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
         if (namespace.alias && namespace.alias.type.valueOf() === AliasType.Mosaic) {
             return new MosaicAlias(new MosaicId(namespace.alias.mosaicId!));
         } else if (namespace.alias && namespace.alias.type.valueOf() === AliasType.Address) {
-            return new AddressAlias(Address.createFromEncoded(namespace.alias.address!));
+            return new AddressAlias(DtoMapping.toAddress(namespace.alias.address!));
         }
         return new EmptyAlias();
     }
diff --git a/src/infrastructure/RestrictionMosaicHttp.ts b/src/infrastructure/RestrictionMosaicHttp.ts
@@ -100,7 +100,7 @@ export class RestrictionMosaicHttp extends Http implements RestrictionMosaicRepo
                 dto.mosaicRestrictionEntry.compositeHash,
                 dto.mosaicRestrictionEntry.entryType.valueOf(),
                 new MosaicId(dto.mosaicRestrictionEntry.mosaicId),
-                Address.createFromEncoded(addressRestrictionDto.mosaicRestrictionEntry.targetAddress),
+                DtoMapping.toAddress(addressRestrictionDto.mosaicRestrictionEntry.targetAddress),
                 addressRestrictionDto.mosaicRestrictionEntry.restrictions.map(RestrictionMosaicHttp.toMosaicAddressRestrictionItem),
             );
         }
diff --git a/src/infrastructure/SecretLockHttp.ts b/src/infrastructure/SecretLockHttp.ts
@@ -92,14 +92,14 @@ export class SecretLockHttp extends Http implements SecretLockRepository {
         return new SecretLockInfo(
             dto.lock.version || 1,
             dto.id,
-            Address.createFromEncoded(dto.lock.ownerAddress),
+            DtoMapping.toAddress(dto.lock.ownerAddress),
             new MosaicId(dto.lock.mosaicId),
             UInt64.fromNumericString(dto.lock.amount),
             UInt64.fromNumericString(dto.lock.endHeight),
             dto.lock.status.valueOf(),
             dto.lock.hashAlgorithm.valueOf(),
             dto.lock.secret,
-            Address.createFromEncoded(dto.lock.recipientAddress),
+            DtoMapping.toAddress(dto.lock.recipientAddress),
             dto.lock.compositeHash,
         );
     }
diff --git a/src/infrastructure/receipt/CreateReceiptFromDTO.ts b/src/infrastructure/receipt/CreateReceiptFromDTO.ts
@@ -15,6 +15,7 @@
  */
 
 import { ResolutionStatementInfoDTO, TransactionStatementInfoDTO } from 'symbol-openapi-typescript-fetch-client';
+import { DtoMapping } from '../../core/utils';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { Address } from '../../model/account/Address';
 import { UnresolvedAddress } from '../../model/account/UnresolvedAddress';
@@ -85,7 +86,7 @@ export const createAddressResolutionStatement = (statementInfoDTO: ResolutionSta
         extractUnresolvedAddress(statementDTO.unresolved),
         statementDTO.resolutionEntries.map((entry) => {
             return new ResolutionEntry(
-                Address.createFromEncoded(entry.resolved),
+                DtoMapping.toAddress(entry.resolved),
                 new ReceiptSource(entry.source.primaryId, entry.source.secondaryId),
             );
         }),
@@ -100,7 +101,7 @@ export const createAddressResolutionStatement = (statementInfoDTO: ResolutionSta
  */
 const createBalanceChangeReceipt = (receiptDTO): Receipt => {
     return new BalanceChangeReceipt(
-        Address.createFromEncoded(receiptDTO.targetAddress),
+        DtoMapping.toAddress(receiptDTO.targetAddress),
         new MosaicId(receiptDTO.mosaicId),
         UInt64.fromNumericString(receiptDTO.amount),
         receiptDTO.version,
@@ -116,8 +117,8 @@ const createBalanceChangeReceipt = (receiptDTO): Receipt => {
  */
 const createBalanceTransferReceipt = (receiptDTO): Receipt => {
     return new BalanceTransferReceipt(
-        Address.createFromEncoded(receiptDTO.senderAddress),
-        Address.createFromEncoded(receiptDTO.recipientAddress),
+        DtoMapping.toAddress(receiptDTO.senderAddress),
+        DtoMapping.toAddress(receiptDTO.recipientAddress),
         new MosaicId(receiptDTO.mosaicId),
         UInt64.fromNumericString(receiptDTO.amount),
         receiptDTO.version,
diff --git a/src/model/transaction/AddressAliasTransaction.ts b/src/model/transaction/AddressAliasTransaction.ts
@@ -23,6 +23,7 @@ import {
     TransactionBuilder,
 } from 'catbuffer-typescript';
 import { Convert } from '../../core/format';
+import { DtoMapping } from '../../core/utils';
 import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { AliasAction } from '../namespace/AliasAction';
@@ -131,7 +132,7 @@ export class AddressAliasTransaction extends Transaction {
                 : Deadline.createFromDTO((builder as AddressAliasTransactionBuilder).getDeadline().timestamp),
             builder.getAliasAction().valueOf(),
             new NamespaceId(builder.getNamespaceId().namespaceId),
-            Address.createFromEncoded(Convert.uint8ToHex(builder.getAddress().address)),
+            DtoMapping.toAddress(Convert.uint8ToHex(builder.getAddress().address)),
             networkType,
             isEmbedded ? new UInt64([0, 0]) : new UInt64((builder as AddressAliasTransactionBuilder).fee.amount),
             signature,
diff --git a/test/core/utils/DtoMapping.spec.ts b/test/core/utils/DtoMapping.spec.ts
@@ -23,6 +23,7 @@ import {
     MerkleTreeLeafDTO,
 } from 'symbol-openapi-typescript-fetch-client';
 import { DtoMapping } from '../../../src/core/utils/DtoMapping';
+import { Address } from '../../../src/model/account';
 import { PublicAccount } from '../../../src/model/account/PublicAccount';
 import { MosaicId } from '../../../src/model/mosaic/MosaicId';
 import { NetworkType } from '../../../src/model/network/NetworkType';
@@ -112,6 +113,35 @@ describe('DtoMapping', () => {
         expect(DtoMapping.toSimpleHex("0x29C6'42F2'F432'8612")).to.be.equal('29C642F2F4328612');
     });
 
+    it('toAddress', () => {
+        expect(DtoMapping.toAddress('7826D27E1D0A26CA4E316F901E23E55C8711DB20DF5C49B5').plain()).to.be.equal(
+            'PATNE7Q5BITMUTRRN6IB4I7FLSDRDWZA35OETNI',
+        );
+
+        expect(DtoMapping.toAddress('7826D27E1D0A26CA4E316F901E23E55C8711DB20DF5C49B5').encoded()).to.be.equal(
+            '7826D27E1D0A26CA4E316F901E23E55C8711DB20DF5C49B5',
+        );
+        expect(DtoMapping.toAddress('TDR6EW2WBHJQDYMNGFX2UBZHMMZC5PGL2YBO3KA').plain()).to.be.equal(
+            'TDR6EW2WBHJQDYMNGFX2UBZHMMZC5PGL2YBO3KA',
+        );
+
+        expect(DtoMapping.toAddress('TDR6-EW2-WBHJQDYMNGFX-2UBZHMMZC5PG-L2YBO3KA').plain()).to.be.equal(
+            'TDR6EW2WBHJQDYMNGFX2UBZHMMZC5PGL2YBO3KA',
+        );
+        // This method should raise! It does not validate the chechsum!
+        expect(Address.createFromEncoded('917E7E29A01014C2F3000000000000000000000000000000').plain()).to.be.equal(
+            'SF7H4KNACAKMF4YAAAAAAAAAAAAAAAAAAAAAAAA',
+        );
+        // This method should raise! It does not validate the chechsum!
+        expect(Address.createFromRawAddress('SF7H4KNACAKMF4YAAAAAAAAAAAAAAAAAAAAAAAA').plain()).to.be.equal(
+            'SF7H4KNACAKMF4YAAAAAAAAAAAAAAAAAAAAAAAA',
+        );
+        expect(Address.isValidEncodedAddress('917E7E29A01014C2F3000000000000000000000000000000')).to.be.equal(false);
+        expect(() => DtoMapping.toAddress('917E7E29A01014C2F3000000000000000000000000000000')).to.throw;
+        expect(() => DtoMapping.toAddress('XDR6-EW2-WBHJQDYMNGFX-2UBZHMMZC5PG-L2YBO3KA')).to.throw;
+        expect(() => DtoMapping.toAddress('917E7E29A01014C2F3000000000000000000000000000')).to.throw;
+    });
+
     it('parse merkle tree', () => {
         const merkleStateInfoDTO = {} as MerkleStateInfoDTO;
         const merkleLeafDTO = {} as MerkleTreeLeafDTO;
diff --git a/test/infrastructure/receipt/CreateReceiptFromDTO.spec.ts b/test/infrastructure/receipt/CreateReceiptFromDTO.spec.ts
@@ -163,7 +163,7 @@ describe('Receipt - CreateStatementFromDTO', () => {
                                     primaryId: 4,
                                     secondaryId: 0,
                                 },
-                                resolved: '917E7E29A01014C2F3000000000000000000000000000000',
+                                resolved: '7826D27E1D0A26CA4E316F901E23E55C8711DB20DF5C49B5',
                             },
                         ],
                     },
@@ -179,7 +179,7 @@ describe('Receipt - CreateStatementFromDTO', () => {
                                     primaryId: 2,
                                     secondaryId: 0,
                                 },
-                                resolved: '9103B60AAF27626883000000000000000000000000000000',
+                                resolved: 'PATNE7Q5BITMUTRRN6IB4I7FLSDRDWZA35OETNI',
                             },
                         ],
                     },
@@ -275,7 +275,7 @@ describe('Receipt - CreateStatementFromDTO', () => {
         deepEqual(unresolvedAddress.toHex(), '83686227AF0AB603');
         expect(statement.addressResolutionStatements[0].resolutionEntries.length).to.be.equal(1);
         expect((statement.addressResolutionStatements[0].resolutionEntries[0].resolved as Address).plain()).to.be.equal(
-            Address.createFromEncoded('917E7E29A01014C2F3000000000000000000000000000000').plain(),
+            'PATNE7Q5BITMUTRRN6IB4I7FLSDRDWZA35OETNI',
         );
 
         deepEqual(statement.mosaicResolutionStatements[0].height, UInt64.fromNumericString('1506'));
@@ -299,7 +299,7 @@ describe('Receipt - CreateStatementFromDTO', () => {
                                     primaryId: 4,
                                     secondaryId: 0,
                                 },
-                                resolved: '917E7E29A01014C2F3000000000000000000000000000000',
+                                resolved: account.address.encoded(),
                             },
                         ],
                     },
@@ -321,7 +321,7 @@ describe('Receipt - CreateStatementFromDTO', () => {
                             primaryId: 4,
                             secondaryId: 0,
                         },
-                        resolved: '917E7E29A01014C2F3000000000000000000000000000000',
+                        resolved: account.address.encoded(),
                     },
                 ],
             },
diff --git a/test/model/receipt/Receipt.spec.ts b/test/model/receipt/Receipt.spec.ts
@@ -84,7 +84,7 @@ describe('Receipt', () => {
                                 primaryId: 4,
                                 secondaryId: 0,
                             },
-                            resolved: '917E7E29A01014C2F3000000000000000000000000000000',
+                            resolved: '7826D27E1D0A26CA4E316F901E23E55C8711DB20DF5C49B5',
                         },
                     ],
                 },
@@ -319,10 +319,7 @@ describe('Receipt', () => {
             (statement.unresolved as Address).plain(),
             Address.createFromEncoded('9103B60AAF27626883000000000000000000000000000000').plain(),
         );
-        deepEqual(
-            (statement.resolutionEntries[0].resolved as Address).plain(),
-            Address.createFromEncoded('917E7E29A01014C2F3000000000000000000000000000000').plain(),
-        );
+        deepEqual((statement.resolutionEntries[0].resolved as Address).plain(), 'PATNE7Q5BITMUTRRN6IB4I7FLSDRDWZA35OETNI');
     });
 
     it('should createComplete a inflation receipt', () => {
@@ -355,7 +352,7 @@ describe('Receipt', () => {
     it('should generate hash for AddressResolutionStatement', () => {
         const receipt = createAddressResolutionStatement(statementDTO.addressResolutionStatements[0]);
         const hash = receipt.generateHash(NetworkType.MAIN_NET);
-        expect(hash).to.be.equal('AA9B667C37C8A19902F3E1098FCEE681318455551CC2FBE9B81E8FA47007CA79');
+        expect(hash).to.be.equal('EBCD71F16C70F7E34E8B9A98A174B759DB8457093CCF3ECAA3D05721E36AAA33');
     });
 
     it('should generate hash for TransactionStatement', () => {

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ import { NamespaceId } from '../../model/namespace/NamespaceId';`
`21`	`21`	`import { NetworkType } from '../../model/network/NetworkType';`
`22`	`22`	`import { Convert } from '../format/Convert';`
`23`	`23`	`import { RawAddress } from '../format/RawAddress';`
	`24`	`+import { DtoMapping } from './DtoMapping';`
`24`	`25`
`25`	`26`	`/**`
`26`	`27`	`* @internal`
`@@ -67,7 +68,7 @@ export class UnresolvedMapping {`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`// read address from encoded hexadecimal notation`
`70`		`- return Address.createFromEncoded(address);`
	`71`	`+ return DtoMapping.toAddress(address);`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ export class RestrictionMosaicHttp extends Http implements RestrictionMosaicRepo`
`100`	`100`	`dto.mosaicRestrictionEntry.compositeHash,`
`101`	`101`	`dto.mosaicRestrictionEntry.entryType.valueOf(),`
`102`	`102`	`new MosaicId(dto.mosaicRestrictionEntry.mosaicId),`
`103`		`- Address.createFromEncoded(addressRestrictionDto.mosaicRestrictionEntry.targetAddress),`
	`103`	`+ DtoMapping.toAddress(addressRestrictionDto.mosaicRestrictionEntry.targetAddress),`
`104`	`104`	`addressRestrictionDto.mosaicRestrictionEntry.restrictions.map(RestrictionMosaicHttp.toMosaicAddressRestrictionItem),`
`105`	`105`	`);`
`106`	`106`	`}`