Merge pull request #6091 from BitGo/WIN-5244

feat(sdk-coin-polyx): add transaction builders

Author: yash-bitgo

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

@@ -31,8 +31,22 @@ export enum MethodNames {
    * @see https://polkadot.js.org/docs/substrate/extrinsics/#transferkeepalivedest-multiaddress-value-compactu128
    */
   TransferKeepAlive = 'transferKeepAlive',
+  /**
+   * Transfer funds with an optional memo attached.
+   * The memo allows adding context or metadata to the transaction, commonly used for recordkeeping or identification.
+   *
+   * @see https://developers.polymesh.network/sdk-docs/enums/Generated/Types/BalancesTx/#transferwithmemo
+   */
+  TransferWithMemo = 'transferWithMemo',
   AddStake = 'addStake',
   RemoveStake = 'removeStake',
+
+  /**
+   * Registers a Decentralized Identifier (DID) along with Customer Due Diligence (CDD) information.
+   *
+   * @see https://developers.polymesh.network/sdk-docs/enums/Generated/Types/IdentityTx/#cddregisterdidwithcdd
+   */
+  RegisterDidWithCDD = 'cddRegisterDidWithCdd',
 }
 
 /**
@@ -75,6 +89,12 @@ export interface TransferAllArgs {
   keepAlive: boolean;
 }
 
+export interface TransferWithMemoArgs extends Args {
+  dest: { id: string };
+  value: string;
+  memo: string;
+}
+
 export interface AddStakeArgs extends Args {
   amountStaked: string;
   hotkey: string;

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

@@ -40,6 +40,12 @@ export const TransferAllTransactionSchema = joi.object({
   to: addressSchema.required(),
 });
 
+export const TransferWithMemoTransactionSchema = joi.object({
+  amount: joi.string().required(),
+  to: addressSchema.required(),
+  memo: joi.string().required(),
+});
+
 export const StakeTransactionSchema = joi.object({
   amountStaked: joi.string().required(),
   hotkey: joi.string().required(),

modules/sdk-coin-polyx/package.json

@@ -41,9 +41,12 @@
   },
   "dependencies": {
     "@bitgo/abstract-substrate": "^1.4.8",
+    "@substrate/txwrapper-core": "7.5.2",
+    "@substrate/txwrapper-polkadot": "7.5.2",
     "@bitgo/sdk-core": "^33.1.0",
     "@bitgo/statics": "^52.1.0",
-    "bignumber.js": "^9.1.2"
+    "bignumber.js": "^9.1.2",
+    "joi": "^17.4.0"
   },
   "devDependencies": {
     "@bitgo/sdk-api": "^1.62.2",

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

@@ -1,6 +1,7 @@
-/**
- * The transaction data returned from the toJson() function of a transaction
- */
-export interface TxData {
-  id: string;
+import { Args } from '@substrate/txwrapper-core';
+
+export interface RegisterDidWithCDDArgs extends Args {
+  targetAccount: string;
+  secondaryKeys: [];
+  expiry: null;
 }

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

@@ -1,9 +1,14 @@
-import * as Utils from './utils';
-import * as Interface from './iface';
+export {
+  Constants,
+  Errors,
+  Interface,
+  KeyPair,
+  SingletonRegistry,
+  Transaction,
+  TransactionBuilder,
+} from '@bitgo/abstract-substrate';
 
-export { KeyPair } from './keyPair';
-export { Transaction } from './transaction';
-export { TransactionBuilder } from './transactionBuilder';
-export { TransferBuilder } from './transferBuilder';
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
-export { Interface, Utils };
+export { TransferBuilder } from './transferBuilder';
+export { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
+export { Utils, default as utils } from './utils';

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

@@ -0,0 +1,79 @@
+import { TransactionBuilder, Interface } 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 { RegisterDidWithCDDTransactionSchema } from './txnSchema';
+
+export class RegisterDidWithCDDBuilder extends TransactionBuilder {
+  protected _to: string;
+
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+  }
+
+  protected get transactionType(): TransactionType {
+    return TransactionType.WalletInitialization;
+  }
+
+  protected buildTransaction(): UnsignedTransaction {
+    const baseTxInfo = this.createBaseTxInfo();
+    return this.RegisterDidWithCDD(
+      {
+        targetAccount: this._to,
+        secondaryKeys: [],
+        expiry: null,
+      },
+      baseTxInfo
+    );
+  }
+
+  /**
+   *
+   * The destination address for transfer transaction.
+   *
+   * @param {string} dest
+   * @returns {TransferBuilder} This transfer builder.
+   */
+  to({ address }: BaseAddress): this {
+    this.validateAddress({ address });
+    this._to = address;
+    return this;
+  }
+
+  /** @inheritdoc */
+  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction?: string): void {
+    if (decodedTxn.method?.name === Interface.MethodNames.RegisterDidWithCDD) {
+      const txMethod = decodedTxn.method.args as RegisterDidWithCDDArgs;
+      const targetAccount = txMethod.targetAccount;
+      const secondaryKeys = txMethod.secondaryKeys;
+      const expiry = txMethod.expiry;
+
+      const validationResult = RegisterDidWithCDDTransactionSchema.validate({ targetAccount, secondaryKeys, expiry });
+      if (validationResult.error) {
+        throw new InvalidTransactionError(`Invalid transaction: ${validationResult.error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Construct a transaction to register a DID with CDD information
+   *
+   * @param {RegisterDidWithCDDArgs} args Arguments to be passed to the cddRegisterDidWithCdd method
+   * @param {Interface.CreateBaseTxInfo} info Base txn info required to construct the DID registration txn
+   * @returns {UnsignedTransaction} an unsigned transaction for DID registration with CDD
+   */
+  private RegisterDidWithCDD(args: RegisterDidWithCDDArgs, info: Interface.CreateBaseTxInfo): UnsignedTransaction {
+    return defineMethod(
+      {
+        method: {
+          args,
+          name: 'cddRegisterDidWithCdd',
+          pallet: 'identity',
+        },
+        ...info.baseTxInfo,
+      },
+      info.options
+    );
+  }
+}

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

@@ -1,20 +1,56 @@
-import { BaseTransactionBuilderFactory } from '@bitgo/sdk-core';
-import { TransactionBuilder } from './transactionBuilder';
+import { BaseTransactionBuilderFactory, NotImplementedError } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { decode } from '@substrate/txwrapper-polkadot';
 import { TransferBuilder } from './transferBuilder';
+import { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
+import utils from './utils';
+import { Interface, SingletonRegistry, TransactionBuilder } from './';
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
-  /** @inheritdoc */
-  from(raw: string): TransactionBuilder {
-    throw new Error('Method not implemented.');
+  protected _material: Interface.Material;
+
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+    this._material = utils.getMaterial(_coinConfig.network.type);
   }
 
-  /** @inheritdoc */
   getTransferBuilder(): TransferBuilder {
-    throw new Error('Method not implemented.');
+    return new TransferBuilder(this._coinConfig).material(this._material);
+  }
+
+  getRegisterDidWithCDDBuilder(): RegisterDidWithCDDBuilder {
+    return new RegisterDidWithCDDBuilder(this._coinConfig).material(this._material);
   }
 
-  /** @inheritdoc */
   getWalletInitializationBuilder(): void {
-    throw new Error('Method not implemented.');
+    throw new NotImplementedError(`walletInitialization for ${this._coinConfig.name} not implemented`);
+  }
+
+  from(rawTxn: string): TransactionBuilder {
+    const builder = this.getBuilder(rawTxn);
+    builder.from(rawTxn);
+    return builder;
+  }
+
+  material(material: Interface.Material): this {
+    this._material = material;
+    return this;
+  }
+
+  private getBuilder(rawTxn: string): TransactionBuilder {
+    const registry = SingletonRegistry.getInstance(this._material);
+    const decodedTxn = decode(rawTxn, {
+      metadataRpc: this._material.metadata,
+      registry: registry,
+    });
+
+    const methodName = decodedTxn.method?.name;
+    if (methodName === Interface.MethodNames.TransferWithMemo) {
+      return this.getTransferBuilder();
+    } else if (methodName === Interface.MethodNames.RegisterDidWithCDD) {
+      return this.getRegisterDidWithCDDBuilder();
+    } else {
+      throw new Error('Transaction cannot be parsed or has an unsupported transaction type');
+    }
   }
 }