Merge pull request #6145 from BitGo/WIN-5425-2

fix(sdk-coin-polyx): fix cdd builder

Author: nvrakesh06

modules/abstract-substrate/src/lib/transaction.ts

@@ -21,10 +21,10 @@ import { DEFAULT_SUBSTRATE_PREFIX } from './constants';
 
 export class Transaction extends BaseTransaction {
   protected _substrateTransaction: UnsignedTransaction;
-  private _signedTransaction?: string;
-  private _registry: TypeRegistry;
-  private _chainName: string;
-  private _sender: string;
+  protected _signedTransaction?: string;
+  protected _registry: TypeRegistry;
+  protected _chainName: string;
+  protected _sender: string;
 
   private static FAKE_SIGNATURE = `0x${Buffer.from(new Uint8Array(256).fill(1)).toString('hex')}`;
 
@@ -128,6 +128,7 @@ export class Transaction extends BaseTransaction {
 
   /** @inheritdoc */
   toJson(): TxData {
+    console.log('Transaction toJson called in substrate Transaction class');
     if (!this._substrateTransaction) {
       throw new InvalidTransactionError('Empty transaction');
     }

modules/abstract-substrate/src/lib/transactionBuilder.ts

@@ -27,8 +27,11 @@ import { Transaction } from './transaction';
 import { BaseTransactionSchema, SignedTransactionSchema, SigningPayloadTransactionSchema } from './txnSchema';
 import utils from './utils';
 
-export abstract class TransactionBuilder extends BaseTransactionBuilder {
-  protected _transaction: Transaction;
+export abstract class TransactionBuilder<
+  TMethod = TxMethod,
+  TTransaction extends Transaction = Transaction
+> extends BaseTransactionBuilder {
+  protected _transaction: TTransaction;
   protected _keyPair: KeyPair;
   protected _signature?: string;
   protected _sender: string;
@@ -39,7 +42,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   protected _tip?: number;
   protected _eraPeriod?: number;
   protected _registry: TypeRegistry;
-  protected _method?: TxMethod;
+  protected _method?: TMethod;
   protected _material: Material;
   // signatures that will be used to sign a transaction when building
   // not the same as the _signatures in transaction which is the signature in
@@ -48,7 +51,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
-    this._transaction = new Transaction(_coinConfig);
+    this._transaction = new Transaction(_coinConfig) as TTransaction;
   }
 
   /**
@@ -134,7 +137,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     return this;
   }
 
-  private method(method: TxMethod): this {
+  private method(method: TMethod): this {
     this._method = method;
     return this;
   }
@@ -154,17 +157,17 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritdoc */
-  protected get transaction(): Transaction {
+  protected get transaction(): TTransaction {
     return this._transaction;
   }
 
   /** @inheritdoc */
-  protected set transaction(transaction: Transaction) {
+  protected set transaction(transaction: TTransaction) {
     this._transaction = transaction;
   }
 
   /** @inheritdoc */
-  protected fromImplementation(rawTransaction: string): Transaction {
+  protected fromImplementation(rawTransaction: string): TTransaction {
     const decodedTxn = decode(rawTransaction, {
       metadataRpc: this._material.metadata,
       registry: this._registry,
@@ -186,7 +189,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     if (decodedTxn.tip) {
       this.fee({ amount: `${decodedTxn.tip}`, type: 'tip' });
     }
-    this.method(decodedTxn.method as unknown as TxMethod);
+    this.method(decodedTxn.method as unknown as TMethod);
     return this._transaction;
   }
 
@@ -197,7 +200,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritdoc */
-  protected async buildImplementation(): Promise<Transaction> {
+  protected async buildImplementation(): Promise<TTransaction> {
     this.transaction.setTransaction(this.buildTransaction());
     this.transaction.transactionType(this.transactionType);
     this.transaction.registry(this._registry);
@@ -320,7 +323,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritdoc */
-  validateTransaction(_: Transaction): void {
+  validateTransaction(_: TTransaction): void {
     this.validateBaseFields(
       this._sender,
       this._blockNumber,
@@ -382,7 +385,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritdoc */
-  protected signImplementation({ key }: BaseKey): Transaction {
+  protected signImplementation({ key }: BaseKey): TTransaction {
     this._keyPair = new KeyPair({ prv: key });
     return this._transaction;
   }

modules/sdk-coin-polyx/package.json

@@ -43,6 +43,7 @@
     "@bitgo/abstract-substrate": "^1.4.9",
     "@substrate/txwrapper-core": "7.5.2",
     "@substrate/txwrapper-polkadot": "7.5.2",
+    "@polkadot/keyring": "13.3.1",
     "@bitgo/sdk-core": "^33.2.0",
     "@bitgo/statics": "^52.2.0",
     "bignumber.js": "^9.1.2",

modules/sdk-coin-polyx/src/lib/iface.ts

@@ -1,7 +1,22 @@
 import { Args } from '@substrate/txwrapper-core';
+import { Interface } from '@bitgo/abstract-substrate';
+import { DecodedUnsignedTx } from '@substrate/txwrapper-core/lib/types';
 
 export interface RegisterDidWithCDDArgs extends Args {
   targetAccount: string;
   secondaryKeys: [];
   expiry: null;
 }
+
+export interface TxMethod extends Omit<Interface.TxMethod, 'args'> {
+  args:
+    | Interface.TransferArgs
+    | Interface.TransferAllArgs
+    | Interface.AddStakeArgs
+    | Interface.RemoveStakeArgs
+    | RegisterDidWithCDDArgs;
+}
+
+export interface DecodedTx extends Omit<DecodedUnsignedTx, 'method'> {
+  method: TxMethod;
+}

modules/sdk-coin-polyx/src/lib/registerDidWithCDDBuilder.ts

@@ -1,15 +1,18 @@
-import { TransactionBuilder, Interface } from '@bitgo/abstract-substrate';
+import { TransactionBuilder, Interface, utils } from '@bitgo/abstract-substrate';
 import { DecodedSignedTx, DecodedSigningPayload, defineMethod, UnsignedTransaction } from '@substrate/txwrapper-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransactionType, BaseAddress, InvalidTransactionError } from '@bitgo/sdk-core';
-import { RegisterDidWithCDDArgs } from './iface';
+import { RegisterDidWithCDDArgs, TxMethod } from './iface';
 import { RegisterDidWithCDDTransactionSchema } from './txnSchema';
+import { Transaction } from './transaction';
 
-export class RegisterDidWithCDDBuilder extends TransactionBuilder {
+export class RegisterDidWithCDDBuilder extends TransactionBuilder<TxMethod, Transaction> {
   protected _to: string;
+  protected _method: TxMethod;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
+    this._transaction = new Transaction(_coinConfig);
   }
 
   protected get transactionType(): TransactionType {
@@ -41,6 +44,18 @@ export class RegisterDidWithCDDBuilder extends TransactionBuilder {
     return this;
   }
 
+  /** @inheritdoc */
+  protected fromImplementation(rawTransaction: string): Transaction {
+    const tx = super.fromImplementation(rawTransaction);
+    if (this._method?.name === Interface.MethodNames.RegisterDidWithCDD) {
+      const txMethod = this._method.args as RegisterDidWithCDDArgs;
+      this.to({ address: utils.decodeSubstrateAddress(txMethod.targetAccount, this.getAddressFormat()) });
+    } else {
+      throw new InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected transferWithMemo`);
+    }
+    return tx;
+  }
+
   /** @inheritdoc */
   validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction?: string): void {
     if (decodedTxn.method?.name === Interface.MethodNames.RegisterDidWithCDD) {

modules/sdk-coin-polyx/src/lib/transaction.ts

@@ -0,0 +1,87 @@
+import { Transaction as SubstrateTransaction, Interface, utils, KeyPair } from '@bitgo/abstract-substrate';
+import { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { construct, decode } from '@substrate/txwrapper-polkadot';
+import { decodeAddress } from '@polkadot/keyring';
+import { DecodedTx, RegisterDidWithCDDArgs } from './iface';
+
+export class Transaction extends SubstrateTransaction {
+  /** @inheritdoc */
+  toJson(): Interface.TxData {
+    console.log('Transaction toJson called in polyx Transaction class');
+    if (!this._substrateTransaction) {
+      throw new InvalidTransactionError('Empty transaction');
+    }
+
+    const decodedTx = decode(this._substrateTransaction, {
+      metadataRpc: this._substrateTransaction.metadataRpc,
+      registry: this._registry,
+      isImmortalEra: utils.isZeroHex(this._substrateTransaction.era),
+    }) as unknown as DecodedTx;
+
+    const result: Interface.TxData = {
+      id: construct.txHash(this.toBroadcastFormat()),
+      sender: decodedTx.address,
+      referenceBlock: decodedTx.blockHash,
+      blockNumber: decodedTx.blockNumber,
+      genesisHash: decodedTx.genesisHash,
+      nonce: decodedTx.nonce,
+      specVersion: decodedTx.specVersion,
+      transactionVersion: decodedTx.transactionVersion,
+      eraPeriod: decodedTx.eraPeriod,
+      chainName: this._chainName,
+      tip: decodedTx.tip ? Number(decodedTx.tip) : 0,
+    };
+
+    const txMethod = decodedTx.method.args;
+    if (this.type === TransactionType.WalletInitialization) {
+      const { targetAccount } = txMethod as RegisterDidWithCDDArgs;
+      const keypairDest = new KeyPair({
+        pub: Buffer.from(decodeAddress(targetAccount)).toString('hex'),
+      });
+      result.to = keypairDest.getAddress(this.getAddressFormat());
+    } else {
+      super.toJson();
+    }
+
+    return result;
+  }
+
+  /**
+   * Load the input and output data on this transaction.
+   */
+  loadInputsAndOutputs(): void {
+    super.loadInputsAndOutputs();
+
+    const decodedTx = decode(this._substrateTransaction, {
+      metadataRpc: this._substrateTransaction.metadataRpc,
+      registry: this._registry,
+      isImmortalEra: utils.isZeroHex(this._substrateTransaction.era),
+    }) as unknown as DecodedTx;
+
+    if (this.type === TransactionType.WalletInitialization) {
+      this.decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx);
+    }
+  }
+
+  private decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx: DecodedTx) {
+    const txMethod = decodedTx.method.args as RegisterDidWithCDDArgs;
+    const keypairDest = new KeyPair({
+      pub: Buffer.from(decodeAddress(txMethod.targetAccount)).toString('hex'),
+    });
+    const to = keypairDest.getAddress(this.getAddressFormat());
+    const value = '0';
+    const from = decodedTx.address;
+
+    this._inputs.push({
+      address: from,
+      value,
+      coin: this._coinConfig.name,
+    });
+
+    this._outputs.push({
+      address: to,
+      value,
+      coin: this._coinConfig.name,
+    });
+  }
+}

modules/sdk-coin-polyx/src/lib/transactionBuilderFactory.ts

@@ -5,6 +5,11 @@ import { TransferBuilder } from './transferBuilder';
 import { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
 import utils from './utils';
 import { Interface, SingletonRegistry, TransactionBuilder } from './';
+import { TxMethod } from './iface';
+import { Transaction as BaseTransaction } from '@bitgo/abstract-substrate';
+import { Transaction as PolyxTransaction } from './transaction';
+
+export type SupportedTransaction = BaseTransaction | PolyxTransaction;
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   protected _material: Interface.Material;
@@ -26,7 +31,7 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     throw new NotImplementedError(`walletInitialization for ${this._coinConfig.name} not implemented`);
   }
 
-  from(rawTxn: string): TransactionBuilder {
+  from(rawTxn: string): TransactionBuilder<TxMethod, SupportedTransaction> {
     const builder = this.getBuilder(rawTxn);
     builder.from(rawTxn);
     return builder;
@@ -37,7 +42,7 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return this;
   }
 
-  private getBuilder(rawTxn: string): TransactionBuilder {
+  private getBuilder(rawTxn: string): TransactionBuilder<TxMethod, SupportedTransaction> {
     const registry = SingletonRegistry.getInstance(this._material);
     const decodedTxn = decode(rawTxn, {
       metadataRpc: this._material.metadata,

modules/sdk-coin-polyx/test/resources/index.ts

@@ -5,6 +5,12 @@ export const mockTssSignature =
   'aadae7fa1f53e7a5c900b330ff71bee6782cf3c29a2c6f9599162381cd021ad581c74ded89f49ec79adefed64af8ff16649553523dda9cb4f017cbf15681e50e';
 
 export const accounts = {
+  cddProvider: {
+    secretKey:
+      '360dcfad8fbe6d514e27866ce134fcc458bc450dd2f03600b0a646ec8f5b40245a9f5ba5f51de3a38b1ee7f7e91dc9e844696d7da545d78a14b1635244e34d2a',
+    publicKey: '5a9f5ba5f51de3a38b1ee7f7e91dc9e844696d7da545d78a14b1635244e34d2a',
+    address: '5E7XWJRysj27EzibT4duRxrBQT9Qfa7Z5nAAvJmvd32nhkjH',
+  },
   account1: {
     secretKey:
       'acfa9a91ed11ecc72dc015562fcb28a4b4bbca4b74f7915119578ed4579844c8cd1293d5b2ea6d7c70689079cde9ccc3dd3f4366dff4fa2f3e46ba9ee380df57',
@@ -38,6 +44,12 @@ export const rawTx = {
     unsigned:
       '0x250105010087c8be067be02a321ad8e946a4a50d71c25b9a640d064ec577d4ef9424b90b460300943577013030303030303030303030303030303030303030303030303030303132333435a503900090d76a00070000002ace05e703aa50b48c0ccccfc8b424f7aab9a1e2c424ed12e45d20b1e8ffd0d6e5c5396f3291d2575d138b98d34eac2fc156e5280276f57a30a8e3b8fbc49bfc',
   },
+  cddTransaction: {
+    signed:
+      '0x2d0284005a9f5ba5f51de3a38b1ee7f7e91dc9e844696d7da545d78a14b1635244e34d2a00bb9ce1ddfda6d60e8169d2cab37e57ca1b1d8592f3caacc25b80d23f4c29c1efd096c9afbd86148c12e68570bab4ed3965b3180570293ea4be6f849ba362d80345030400071460b685d82b315b70d7c7604f990a05395eab09d5e75bae5d2c519ca1b01e25e50000',
+    unsigned:
+      '0x90071460b685d82b315b70d7c7604f990a05395eab09d5e75bae5d2c519ca1b01e25e500004503040090d76a00070000002ace05e703aa50b48c0ccccfc8b424f7aab9a1e2c424ed12e45d20b1e8ffd0d6cbd4f0bb74e13c8c4da973b1a15c3df61ae3b82677b024ffa60faf7799d5ed4b',
+  },
 };
 
 export const { txVersion, specVersion, genesisHash, chainName, specName } = Networks.test.polyx;