Merge pull request #6620 from BitGo/polyx-wrw

feat(polyx): add wrw support

Author: akarath

modules/sdk-coin-polyx/package.json

@@ -43,9 +43,11 @@
     "@bitgo/abstract-substrate": "^1.8.9",
     "@bitgo/sdk-core": "^36.0.0",
     "@bitgo/statics": "^57.0.0",
+    "@bitgo/sdk-lib-mpc": "^10.6.0",
     "@polkadot/keyring": "13.3.1",
     "@substrate/txwrapper-core": "7.5.2",
     "@substrate/txwrapper-polkadot": "7.5.2",
+    "@polkadot/api": "14.1.1",
     "bignumber.js": "^9.1.2",
     "joi": "^17.4.0"
   },

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

@@ -1,9 +1,27 @@
-import { AuditDecryptedKeyParams, BaseCoin, BitGoBase } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
-import { SubstrateCoin } from '@bitgo/abstract-substrate';
+import {
+  AuditDecryptedKeyParams,
+  BaseCoin,
+  BitGoBase,
+  EDDSAMethods,
+  EDDSAMethodTypes,
+  MPCRecoveryOptions,
+  MPCSweepTxs,
+  MPCTx,
+  MPCUnsignedTx,
+  RecoveryTxRequest,
+  Environments,
+  MPCSweepRecoveryOptions,
+  MPCTxs,
+} from '@bitgo/sdk-core';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { BaseCoin as StaticsBaseCoin, coins, SubstrateSpecNameType } from '@bitgo/statics';
+import { KeyPair as SubstrateKeyPair, SubstrateCoin, Transaction, Interface } from '@bitgo/abstract-substrate';
 import { BatchStakingBuilder } from './lib/batchStakingBuilder';
 import { BondExtraBuilder } from './lib/bondExtraBuilder';
 import { POLYX_ADDRESS_FORMAT } from './lib/constants';
+import { getDerivationPath } from '@bitgo/sdk-lib-mpc';
+import BigNumber from 'bignumber.js';
+import { TransactionBuilderFactory, TransferBuilder } from './lib';
 
 export class Polyx extends SubstrateCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -17,10 +35,17 @@ export class Polyx extends SubstrateCoin {
     this._staticsCoin = staticsCoin;
   }
 
+  protected static nodeApiInitialized = false;
+  protected static API: ApiPromise;
+
   static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {
     return new Polyx(bitgo, staticsCoin);
   }
 
+  getBuilder(): TransactionBuilderFactory {
+    return new TransactionBuilderFactory(coins.get(this.getChain()));
+  }
+
   /**
    * Factor between the coin's base unit and its smallest subdivison
    */
@@ -58,4 +83,264 @@ export class Polyx extends SubstrateCoin {
   protected getAddressFormat(): number {
     return POLYX_ADDRESS_FORMAT;
   }
+
+  protected async getInitializedNodeAPI(): Promise<ApiPromise> {
+    if (!Polyx.nodeApiInitialized) {
+      const wsProvider = new WsProvider(Environments[this.bitgo.getEnv()].polymeshNodeUrls);
+      Polyx.API = await ApiPromise.create({ provider: wsProvider });
+      Polyx.nodeApiInitialized = true;
+    }
+    return Polyx.API;
+  }
+
+  protected async getAccountInfo(walletAddr: string): Promise<{ nonce: number; freeBalance: number }> {
+    const api = await this.getInitializedNodeAPI();
+    const { nonce, data: balance } = await api.query.system.account(walletAddr);
+
+    return { nonce: nonce.toNumber(), freeBalance: balance.free.toNumber() };
+  }
+
+  protected async getFee(destAddr: string, srcAddr: string, amount: number): Promise<number> {
+    const api = await this.getInitializedNodeAPI();
+    const info = await api.tx.balances.transfer(destAddr, amount).paymentInfo(srcAddr);
+    return info.partialFee.toNumber();
+  }
+
+  protected async getHeaderInfo(): Promise<{ headerNumber: number; headerHash: string }> {
+    const api = await this.getInitializedNodeAPI();
+    const { number, hash } = await api.rpc.chain.getHeader();
+    return { headerNumber: number.toNumber(), headerHash: hash.toString() };
+  }
+
+  protected async getMaterial(): Promise<Interface.Material> {
+    const api = await this.getInitializedNodeAPI();
+    return {
+      genesisHash: api.genesisHash.toString(),
+      chainName: api.runtimeChain.toString(),
+      specName: api.runtimeVersion.specName.toString() as SubstrateSpecNameType,
+      specVersion: api.runtimeVersion.specVersion.toNumber(),
+      txVersion: api.runtimeVersion.transactionVersion.toNumber(),
+      metadata: api.runtimeMetadata.toHex(),
+    };
+  }
+
+  /**
+   * Builds a funds recovery transaction without BitGo
+   * @param {MPCRecoveryOptions} params parameters needed to construct and
+   * (maybe) sign the transaction
+   *
+   * @returns {MPCTx} the serialized transaction hex string and index
+   * of the address being swept
+   */
+  async recover(params: MPCRecoveryOptions): Promise<MPCTx | MPCSweepTxs> {
+    if (!params.bitgoKey) {
+      throw new Error('Missing bitgoKey');
+    }
+
+    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+      throw new Error('Invalid recovery destination address');
+    }
+
+    const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+
+    const MPC = await EDDSAMethods.getInitializedMpcInstance();
+
+    const index = params.index || 0;
+    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+    const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+    const senderAddr = this.getAddressFromPublicKey(accountId);
+
+    const { nonce, freeBalance } = await this.getAccountInfo(senderAddr);
+
+    const destAddr = params.recoveryDestination;
+    const amount = freeBalance;
+    const partialFee = await this.getFee(destAddr, senderAddr, amount);
+    const paddedFee = new BigNumber(partialFee).times(10).toNumber();
+    const amountToSend = new BigNumber(amount).minus(new BigNumber(paddedFee));
+
+    const value = new BigNumber(freeBalance).minus(new BigNumber(partialFee));
+    if (value.isLessThanOrEqualTo(0)) {
+      throw new Error('Did not find address with funds to recover');
+    }
+
+    const { headerNumber, headerHash } = await this.getHeaderInfo();
+    const material = await this.getMaterial();
+    const validityWindow = { firstValid: headerNumber, maxDuration: this.MAX_VALIDITY_DURATION };
+
+    const txBuilder = this.getBuilder().getTransferBuilder().material(material) as TransferBuilder;
+
+    txBuilder
+      .amount(amountToSend.toString())
+      .to({ address: params.recoveryDestination })
+      .sender({ address: senderAddr })
+      .memo('0')
+      .validity(validityWindow)
+      .referenceBlock(headerHash)
+      .sequenceId({ name: 'Nonce', keyword: 'nonce', value: nonce })
+      .fee({ amount: 0, type: 'tip' });
+
+    const unsignedTransaction = (await txBuilder.build()) as Transaction;
+
+    let serializedTx = unsignedTransaction.toBroadcastFormat();
+    if (!isUnsignedSweep) {
+      if (!params.userKey) {
+        throw new Error('missing userKey');
+      }
+      if (!params.backupKey) {
+        throw new Error('missing backupKey');
+      }
+      if (!params.walletPassphrase) {
+        throw new Error('missing wallet passphrase');
+      }
+
+      const userKey = params.userKey.replace(/\s/g, '');
+      const backupKey = params.backupKey.replace(/\s/g, '');
+
+      // Decrypt private keys from KeyCard values
+      let userPrv;
+      try {
+        userPrv = this.bitgo.decrypt({
+          input: userKey,
+          password: params.walletPassphrase,
+        });
+      } catch (e) {
+        throw new Error(`Error decrypting user keychain: ${e.message}`);
+      }
+      const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;
+
+      let backupPrv;
+      try {
+        backupPrv = this.bitgo.decrypt({
+          input: backupKey,
+          password: params.walletPassphrase,
+        });
+      } catch (e) {
+        throw new Error(`Error decrypting backup keychain: ${e.message}`);
+      }
+      const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;
+
+      // add signature
+      const signatureHex = await EDDSAMethods.getTSSSignature(
+        userSigningMaterial,
+        backupSigningMaterial,
+        currPath,
+        unsignedTransaction
+      );
+
+      const substrateKeyPair = new SubstrateKeyPair({ pub: accountId });
+      txBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);
+      const signedTransaction = await txBuilder.build();
+      serializedTx = signedTransaction.toBroadcastFormat();
+    } else {
+      const walletCoin = this.getChain();
+      const inputs = [
+        {
+          address: unsignedTransaction.inputs[0].address,
+          valueString: amountToSend.toString(),
+          value: amountToSend.toNumber(),
+        },
+      ];
+      const outputs = [
+        {
+          address: unsignedTransaction.outputs[0].address,
+          valueString: amountToSend.toString(),
+          coinName: walletCoin,
+        },
+      ];
+      const spendAmount = amountToSend.toString();
+      const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+      const feeInfo = { fee: 0, feeString: '0' };
+      const transaction: MPCTx = {
+        serializedTx: serializedTx,
+        scanIndex: index,
+        coin: walletCoin,
+        signableHex: unsignedTransaction.signablePayload.toString('hex'),
+        derivationPath: currPath,
+        parsedTx: parsedTx,
+        feeInfo: feeInfo,
+        coinSpecific: { ...validityWindow, commonKeychain: bitgoKey },
+      };
+
+      const unsignedTx: MPCUnsignedTx = { unsignedTx: transaction, signatureShares: [] };
+      const transactions: MPCUnsignedTx[] = [unsignedTx];
+      const txRequest: RecoveryTxRequest = {
+        transactions: transactions,
+        walletCoin: walletCoin,
+      };
+      const txRequests: MPCSweepTxs = { txRequests: [txRequest] };
+      return txRequests;
+    }
+
+    const transaction: MPCTx = { serializedTx: serializedTx, scanIndex: index };
+    return transaction;
+  }
+
+  /** inherited doc */
+  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {
+    const req = params.signatureShares;
+    const broadcastableTransactions: MPCTx[] = [];
+    let lastScanIndex = 0;
+
+    for (let i = 0; i < req.length; i++) {
+      const MPC = await EDDSAMethods.getInitializedMpcInstance();
+      const transaction = req[i].txRequest.transactions[0].unsignedTx;
+      if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {
+        throw new Error('Missing signature(s)');
+      }
+      const signature = req[i].ovc[0].eddsaSignature;
+      if (!transaction.signableHex) {
+        throw new Error('Missing signable hex');
+      }
+      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');
+      const result = MPC.verify(messageBuffer, signature);
+      if (!result) {
+        throw new Error('Invalid signature');
+      }
+      const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);
+      if (
+        !transaction.coinSpecific ||
+        !transaction.coinSpecific?.firstValid ||
+        !transaction.coinSpecific?.maxDuration
+      ) {
+        throw new Error('missing validity window');
+      }
+      const validityWindow = {
+        firstValid: transaction.coinSpecific?.firstValid,
+        maxDuration: transaction.coinSpecific?.maxDuration,
+      };
+      const material = await this.getMaterial();
+      if (!transaction.coinSpecific?.commonKeychain) {
+        throw new Error('Missing common keychain');
+      }
+      const commonKeychain = transaction.coinSpecific!.commonKeychain! as string;
+      if (!transaction.derivationPath) {
+        throw new Error('Missing derivation path');
+      }
+      const derivationPath = transaction.derivationPath as string;
+      const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+      const senderAddr = this.getAddressFromPublicKey(accountId);
+
+      const txnBuilder = this.getBuilder()
+        .material(material)
+        .from(transaction.serializedTx as string)
+        .sender({ address: senderAddr })
+        .validity(validityWindow);
+
+      const substrateKeyPair = new SubstrateKeyPair({ pub: accountId });
+      txnBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);
+      const signedTransaction = await txnBuilder.build();
+      const serializedTx = signedTransaction.toBroadcastFormat();
+
+      broadcastableTransactions.push({
+        serializedTx: serializedTx,
+        scanIndex: transaction.scanIndex,
+      });
+
+      if (i === req.length - 1 && transaction.coinSpecific!.lastScanIndex) {
+        lastScanIndex = transaction.coinSpecific!.lastScanIndex as number;
+      }
+    }
+    return { transactions: broadcastableTransactions, lastScanIndex };
+  }
 }

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

@@ -0,0 +1,64 @@
+export const wrwUser = {
+  userKey:
+    '{"iv":"TR25BHPM0F8OrlhC5UEnUA==","v":1,"iter":10000,"ks":256,"ts":64,"mode"\n' +
+    ':"ccm","adata":"","cipher":"aes","salt":"uQfN/R/hYaM=","ct":"IzM4WznffhakZk\n' +
+    'KwsRxTEcQ7PIcr5f6ro2YXbn1mP/dlMaYlmGOE1fJemchVeuFUWLGphJPMaUz3v4lJbklvRGtTP\n' +
+    'F8+JeFSp/ps++wirzlZoAmPOGrOPRg7TkOJXR7xZyBJHeUoV9xu7X1iKGrxhYr70CrzlkrYqlQR\n' +
+    'qU8NiV1YbeY+Ra56m9RfeE2HaXk2s9xNzn8mfdOdjkd1sjXwTzv3WPTBWPD35H8EiDbLuVLLOBg\n' +
+    'tVPNahBimxffWE5B6keQTN3ezKNTwE0z3B4sBTGHb8wbumhRAO42/BV7MNbvCDPe+GfkqljMu13\n' +
+    'u9PAaRb3Y/nK1szIxqN4PpUYP92UYr/QjveuHk37+wxQhljfn81jhkhtGOvnv1EaBhZNJ0PWbrf\n' +
+    'E9Xprx8vLmyy8UiGayUvXka2bEZyPksjBpD7chhKbqCj3q5EhJQLUiydLr9/BV50seM1+AQ9w+R\n' +
+    '8KjybUgwIF/qTLcaCxVHeAKRzs6LMGj43+l1kTkdaGRre+6MAK2aExZK2FJer49v8htKo7Z6vy+\n' +
+    '149DBwTnvCGEDQVXuumKCGX0CCfzbLAMZVKB/Xqdd3e9B99QbVFmPQpeAlJXrOpaoXS90xSSBKs\n' +
+    'dbr1wkRHlYB/NvQZwl2sGfIcPJASfWKLFUSXJM7ql1y89llNNSW7RUBcf9tKK5SqmVyGxWZ+1LJ\n' +
+    'a5ZEh4BRYh5Kx4IleCQNyZI73XVZE8kyHo07TWwlI8jR8DUIsuF1cBmFRKn2XoikQrDYie/o1zS\n' +
+    '1hDMzvF4C9BeacW6iPZ1n9/0OkwgiUIDJGh4vIOei/9U/N2scc8z5+F/yaXXW7COKxqKkx74tqI\n' +
+    'ohPm0CTnH2t2cqjK+C5x3FdwiPT+uIzgSU04EZP4gzngZ11yunj7cvw80x9/BK+GwbM97haJ8Je\n' +
+    'lMDg5++m6fJlb6weW1Rd6IiUfRSXpio7KQbxZ04UG5uPROAY1xbCJbGQi9OjcyXQKQtL81WkHSr\n' +
+    'LGjN/jXCts7OH3xZRaZk66DP6X3LaT0b6qmlem2Uvf+ZIKResF3ivijLYopJWfftamaFDyY+463\n' +
+    'uI/WNFWrc7iQWI4Fy3eUezuqBZhiZdWMxuP7yDwLgWr2h3CUNYoLvocrRuye6cI8fjmDWzeTdun\n' +
+    '5tSM8OL30hY7aH1n/ZDweng0w5k8i7Znm5LpLaAJzkA7CFV0CXI56s3isJ5CjXJFm"}',
+  backupKey:
+    '{"iv":"yoGM9gzwedwMp+D5xfZjuw==","v":1,"iter":10000,"ks":256,"ts":64,"mode"\n' +
+    ':"ccm","adata":"","cipher":"aes","salt":"bLoJpDYNb1o=","ct":"rK3JZ5VyxqsfgV\n' +
+    'JVrR8bddfMe5cy963ntRt3B7l71tvHT8KleNBlzPN6VPrvw1T9KhTHPZ8zDq1pLN39wdrgr4lD4\n' +
+    '7+FwsclqQscsi97YW7pTHhWBGGMCKzItXQfeXYCZqvXu/BeV80VWKwso40vZ13pNWmZRhjy/40U\n' +
+    'Z0J/Tf+2NuFSEuLKznrgD/oLJaAkYS7d1Bt+GUHWkXnDOsLwqbBL8y5TQJkZrp37nDXXRdP1IE1\n' +
+    'MOm2C+GMvboHwm4bpKQRpVURgjyk/7/XWXQ7OUvIFgq324sQbQCHVB/voaRVF+3x7ShRjiGG9sE\n' +
+    'W0+XsbbamrXvGiexAGPDM+2kuPe/rBFhJgf4HJnYFAM9sjzWdOIedhkuOokwqgd5OqreVMO/dYF\n' +
+    'PGI29cnrov8JpIQw5gArtlgUxOdelg/oCaRUryHCABVPTODbFYygf+3IAgng2M+oEvh26gVFOfz\n' +
+    'oPfBoqqXk6/kWpc3zx2byOB+c6Yzhg9sRnF5UobMBl50nklo1kM/24ObmsNCQeVyuZARjQgpbZx\n' +
+    'wn5l51knvxmvQXxvwnfsuifje9GkE4Tt+vYu49o3V8vmRaOxcEMnzj5WOC/MOb6QPT4Jx8/J9CB\n' +
+    'V4nU+MvgZbDJKMx9kuyJ62PihBy8uSE1JrNgWU3aEkuh9aD5HEoAtyy4tBatRTzOMLSsSr3hii7\n' +
+    'pVTBkfEFVzsrHRfIc4FhsnFqSG1yPtxQ68FUeZNM23pCOSJMcbzuP2deEwOCNE5AFIhVZmHg5Yn\n' +
+    'CXgcUwAHh+aD+Jv8LMyHq0U6GKkpghu5bptUJcX6oOwUoKD04NWuE6VvK0ZJhSpxxOLeLI4YrwA\n' +
+    'tNVo9KAehWPHJfbx4XyBKu+3Z/mIfPJ2rxz7Izdci/BhDKiuHRUynUJ7/8Taxkjqa6RBdFD/avm\n' +
+    'Z1a8GyGlxYbnF3OlJUS0Op3lAXBygMyfZqDYbYSfr7ufaIfULAApxXIV0+tyKeF78yAH/k4GIvH\n' +
+    '8GzkFu0MSzhWDddeUuKY4Me36GmPHfkzXw+jGt/I6R2vPZKW5RsfMooV7QKUrINtQTZ/4b8jAsr\n' +
+    'NJyYZX1wmjwQu3UzqpN+4oPh+WOJUX1Weo5B6c/4e1FmchSiPcI9xCR64MddbFaA/ORdN4p4cgL\n' +
+    'B4K3MOqMpoOCMgo/+N9JQr5FTMrcxVSJWRm7QrSGP3go2tywH1UuJOHxhAthdRw=="}',
+  bitgoKey:
+    '74372039ccd6c9b2e1e16e3258ff3307b05527ac5a34e1b603b7b74353599c5eb6de9fc5f0f\n' +
+    '5f677bfa1f41915d9e1a2e794f8d5d9770d219bf5432adf0415e3',
+  walletPassphrase: '#Bondiola1234',
+  walletAddress: '5C8nEaqzwMLC2EFjUFckCfPLeFUVWNp3FErQiN8D5u2ZkWyt',
+};
+
+export const unsignedSweepUser = {
+  userKey:
+    '97d9da8bf544d07f3c7ae8ee06bb12a63f74478d0c461201ab94421a9c81d5b379553f0332d\n' +
+    'aaa85cb8c65e1fe7e6907c62268c00812b08a4e1361178e304ddb',
+  backupKey:
+    '97d9da8bf544d07f3c7ae8ee06bb12a63f74478d0c461201ab94421a9c81d5b379553f0332d\n' +
+    'aaa85cb8c65e1fe7e6907c62268c00812b08a4e1361178e304ddb',
+  bitgoKey:
+    '97d9da8bf544d07f3c7ae8ee06bb12a63f74478d0c461201ab94421a9c81d5b379553f0332d\n' +
+    'aaa85cb8c65e1fe7e6907c62268c00812b08a4e1361178e304ddb',
+  walletPassphrase: '#Bondiola1234',
+  walletAddress: '5DnZQqbxtB3CWkLgfA6wpqdkCd9Bq7AX49RpLPJwW9mzoT7s',
+};
+
+export const testnetBlock = {
+  blockNumber: 12640277,
+  hash: '0x3771101969cc5cf1b37db0bdce589fe9174a1b820341c4d3673ce301352a3d42',
+};