feat(sdk-coin-apt): addition of test case for apt transaction builder

baltiyal · baltiyal · commit 69cca5bd8889 · 2025-01-05T10:52:12.000+05:30
Ticket: COIN-2258
diff --git a/modules/sdk-coin-apt/src/apt.ts b/modules/sdk-coin-apt/src/apt.ts
@@ -11,9 +11,15 @@ import {
   VerifyAddressOptions,
   VerifyTransactionOptions,
 } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
-import { KeyPair as AptKeyPair } from './lib';
+import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
+import { KeyPair as AptKeyPair, TransactionBuilderFactory, TransferTransaction } from './lib';
 import utils from './lib/utils';
+import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+
+export interface AptParseTransactionOptions extends ParseTransactionOptions {
+  txHex: string;
+}
 
 export class Apt extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -64,7 +70,40 @@ export class Apt extends BaseCoin {
   }
 
   async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
-    throw new Error('Method not implemented.');
+    const coinConfig = coins.get(this.getChain());
+    const { txPrebuild: txPrebuild, txParams: txParams } = params;
+    const transaction = new TransferTransaction(coinConfig);
+    const rawTx = txPrebuild.txHex;
+    if (!rawTx) {
+      throw new Error('missing required tx prebuild property txHex');
+    }
+    transaction.fromRawTransaction(rawTx);
+    const explainedTx = transaction.explainTransaction();
+    if (txParams.recipients !== undefined) {
+      const filteredRecipients = txParams.recipients?.map((recipient) => {
+        return {
+          address: recipient.address, // TODO: check this
+          amount: BigInt(recipient.amount),
+        };
+      });
+      const filteredOutputs = explainedTx.outputs.map((output) => {
+        return {
+          address: output.address,
+          amount: BigInt(output.amount),
+        };
+      });
+      if (!_.isEqual(filteredOutputs, filteredRecipients)) {
+        throw new Error('Tx outputs does not match with expected txParams recipients');
+      }
+      let totalAmount = new BigNumber(0);
+      for (const recipients of txParams.recipients) {
+        totalAmount = totalAmount.plus(recipients.amount);
+      }
+      if (!totalAmount.isEqualTo(explainedTx.outputAmount)) {
+        throw new Error('Tx total amount does not match with expected total amount field');
+      }
+    }
+    return true;
   }
 
   async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
@@ -76,8 +115,26 @@ export class Apt extends BaseCoin {
     return true;
   }
 
-  parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {
-    throw new Error('Method not implemented.');
+  async parseTransaction(params: AptParseTransactionOptions): Promise<ParsedTransaction> {
+    const coinConfig = coins.get(this.getChain());
+    const factory = new TransactionBuilderFactory(coinConfig);
+    const transactionBuilder = factory.from(params.txHex);
+    const rebuiltTransaction = await transactionBuilder.build();
+    const parsedTransaction = rebuiltTransaction.toJson();
+    return {
+      inputs: [
+        {
+          address: parsedTransaction.sender,
+          value: parsedTransaction.recipient.amount,
+        },
+      ],
+      outputs: [
+        {
+          address: parsedTransaction.recipient.address,
+          value: parsedTransaction.recipient.amount,
+        },
+      ],
+    };
   }
 
   generateKeyPair(seed?: Buffer): KeyPair {
diff --git a/modules/sdk-coin-apt/src/lib/transaction/transaction.ts b/modules/sdk-coin-apt/src/lib/transaction/transaction.ts
@@ -155,6 +155,7 @@ export abstract class Transaction extends BaseTransaction {
 
   /** @inheritDoc */
   explainTransaction(): TransactionExplanation {
+    //TODO: explain transaction to take input as params then take build txn and return the explanation
     const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'];
 
     const outputs: TransactionRecipient[] = [this.recipient];
diff --git a/modules/sdk-coin-apt/test/resources/apt.ts b/modules/sdk-coin-apt/test/resources/apt.ts
@@ -0,0 +1,31 @@
+import { Recipient } from '@bitgo/sdk-core';
+
+export const AMOUNT = 100000000;
+
+export const addresses = {
+  validAddresses: [
+    '0xf7405c28a02cf5bab4ea4498240bb3579db45951794eb1c843bef0534c093ad9',
+    '0x1aed808916ab9b1b30b07abb53561afd46847285ce28651221d406173a372449',
+  ],
+  invalidAddresses: [
+    'randomString',
+    '0xc4173a804406a365e69dfb297ddfgsdcvf',
+    '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+  ],
+};
+
+export const sender = {
+  address: '0x1aed808916ab9b1b30b07abb53561afd46847285ce28651221d406173a372449',
+  privateKey: '0x54e1a88eb2b881fe6c222985d0fabc9ba3aca35743dd1d19db18a9a355acbaaa',
+  publicKey: '0xf73836f42257240e43d439552471fc9dbcc3f1af5bd0b4ed83f44b5f66146442',
+};
+
+export const recipients: Recipient[] = [
+  {
+    address: addresses.validAddresses[0],
+    amount: AMOUNT.toString(),
+  },
+];
+
+export const TRANSFER =
+  '0xc8f02d25aa698b3e9fbd8a08e8da4c8ee261832a25a4cde8731b5ec356537d09170000000000000002000000000000000000000000000000000000000000000000000000000000000104636f696e087472616e73666572010700000000000000000000000000000000000000000000000000000000000000010a6170746f735f636f696e094170746f73436f696e000220f7405c28a02cf5bab4ea4498240bb3579db45951794eb1c843bef0534c093ad908e803000000000000400d0300000000006400000000000000207c7667000000000200202121dcd098069ae535697dd019cfd8677ca7aba0adac1d1959cbce6dc54b12594010f340ec153b724c4dc1c9a435d0fafed1775d851c1e8d965925a7879550c69a4677925d9198334a72ae7ce8998226ff0a83743c7ba8a2831136c072bf21c404';
diff --git a/modules/sdk-coin-apt/test/unit/apt.ts b/modules/sdk-coin-apt/test/unit/apt.ts
@@ -2,14 +2,208 @@ import 'should';
 import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
 import { BitGoAPI } from '@bitgo/sdk-api';
 import { Apt, Tapt } from '../../src';
+import * as testData from '../resources/apt';
+import _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import sinon from 'sinon';
+import assert from 'assert';
 
 describe('APT:', function () {
   let bitgo: TestBitGoAPI;
+  let basecoin;
+  let newTxPrebuild;
+  let newTxParams;
+
+  const txPreBuild = {
+    txHex: testData.TRANSFER,
+    txInfo: {},
+  };
+
+  const txParams = {
+    recipients: testData.recipients,
+  };
 
   before(function () {
     bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });
     bitgo.safeRegister('apt', Apt.createInstance);
     bitgo.safeRegister('tapt', Tapt.createInstance);
     bitgo.initializeTestVars();
+    basecoin = bitgo.coin('tapt');
+    newTxPrebuild = () => {
+      return _.cloneDeep(txPreBuild);
+    };
+    newTxParams = () => {
+      return _.cloneDeep(txParams);
+    };
+  });
+
+  it('should return the right info', function () {
+    const apt = bitgo.coin('apt');
+    const tapt = bitgo.coin('tapt');
+
+    apt.getChain().should.equal('apt');
+    apt.getFamily().should.equal('apt');
+    apt.getFullName().should.equal('Aptos');
+    apt.getBaseFactor().should.equal(1e8);
+
+    tapt.getChain().should.equal('tapt');
+    tapt.getFamily().should.equal('apt');
+    tapt.getFullName().should.equal('Testnet Aptos');
+    tapt.getBaseFactor().should.equal(1e8);
+  });
+
+  describe('Verify transaction: ', () => {
+    it('should succeed to verify transaction', async function () {
+      const txPrebuild = newTxPrebuild();
+      const txParams = newTxParams();
+      const verification = {};
+      const isTransactionVerified = await basecoin.verifyTransaction({ txParams, txPrebuild, verification });
+      isTransactionVerified.should.equal(true);
+    });
+
+    it('should succeed to verify transaction when recipients amount are numbers', async function () {
+      const txPrebuild = newTxPrebuild();
+      const txParamsWithNumberAmounts = newTxParams();
+      txParamsWithNumberAmounts.recipients = txParamsWithNumberAmounts.recipients.map(({ address, amount }) => {
+        return { address, amount: Number(amount) };
+      });
+      const verification = {};
+      const isTransactionVerified = await basecoin.verifyTransaction({
+        txParams: txParamsWithNumberAmounts,
+        txPrebuild,
+        verification,
+      });
+      isTransactionVerified.should.equal(true);
+    });
+
+    it('should fail to verify transaction with invalid param', async function () {
+      const txPrebuild = {};
+      const txParams = newTxParams();
+      txParams.recipients = undefined;
+      await basecoin
+        .verifyTransaction({
+          txParams,
+          txPrebuild,
+        })
+        .should.rejectedWith('missing required tx prebuild property txHex');
+    });
+  });
+  describe('Parse Transactions: ', () => {
+    const transferInputsResponse = [
+      {
+        address: testData.recipients[0].address,
+        amount: new BigNumber(testData.AMOUNT),
+      },
+    ];
+
+    const transferOutputsResponse = [
+      {
+        address: testData.recipients[0].address,
+        amount: testData.recipients[0].amount,
+      },
+    ];
+
+    it('should parse a transfer transaction', async function () {
+      const parsedTransaction = await basecoin.parseTransaction({
+        txHex: testData.TRANSFER,
+      });
+
+      parsedTransaction.should.deepEqual({
+        inputs: transferInputsResponse,
+        outputs: transferOutputsResponse,
+      });
+    });
+
+    it('should fail to parse a transfer transaction when explainTransaction response is undefined', async function () {
+      const stub = sinon.stub(Apt.prototype, 'explainTransaction');
+      stub.resolves(undefined);
+      await basecoin.parseTransaction({ txHex: testData.TRANSFER }).should.be.rejectedWith('Invalid transaction');
+      stub.restore();
+    });
+  });
+
+  describe('Address Validation', () => {
+    let keychains;
+    let commonKeychain;
+
+    before(function () {
+      commonKeychain =
+        '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781';
+      keychains = [
+        {
+          id: '6424c353eaf78d000766e95949868468',
+          source: 'user',
+          type: 'tss',
+          commonKeychain:
+            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+          encryptedPrv:
+            '{"iv":"cZd5i7L4RxtwrALW2rK7UA==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"5zgoH1Bd3Fw=","ct":"9vVlnXFRtrM9FVEo+d2chbGHlM9lFZemueBuAs3BIkPo33Fo7jzwwNK/kIWkEyg+NmEBd5IaqAS157nvvvwzzsmMWlQdUz9qbmXNv3pg987cXFR08exS+4uhwP1YNOjJTRvRNcO9ZqHb46d4fmyJ/yC9/susCge7r/EsbaN5C3afv1dzybuq912FwaQElZLYYp5BICudFOMZ9k0UDMfKM/PMDkH7WexoGHr9GKq/bgCH2B39TZZyHKU6Uy47lXep2s6h0DrMwHOrnmiL3DZjOj88Ynvphlzxuo4eOlD2UHia2+nvIaISYs29Pr0DAvREutchvcBpExj1kWWPv7hQYrv8F0NAdatsbWl3w+xKyfiMKo1USlrwyJviypGtQtXOJyw0XPN0rv2+L5lW8BbjpzHfYYN13fJTedlGTFhhkzVtbbPAKE02kx7zCJcjYaiexdSTsrDLScYNT9/Jhdt27KpsooehwVohLfSKz4vbFfRu2MPZw3/+c/hfiJNgtz6esWbnxGrcE8U2IwPYCaK+Ghk4DcqWNIni59RI5B5kAsQOToII40qPN510uTgxBSPO7q7MHgkxdd4CqBq+ojr9j0P7oao8E5Y+CBDJrojDoCh1oCCDW9vo2dXlVcD8SIbw7U/9AfvEbA4xyE/5md1M7CIwLnWs2Ynv0YtaKoqhdS9x6FmHlMDhN/DKHinrwmowtrTT82fOkpO5g9saSmgU7Qy3gLt8t+VwdEyeFeQUKRSyci8qgqXQaZIg4+aXgaSOnlCFMtmB8ekYxEhTY5uzRfrNgS4s1QeqFBpNtUF+Ydi297pbVXnJoXAN+SVWd80GCx+yI2dpVC89k3rOWK9WeyqlnzuLJWp2RIOB9cdW8GFv/fN+QAJpYeVxOE4+nZDsKnsj8nKcg9t4Dlx1G6gLM1/Vq9YxNLbuzuRC0asUYvdMnoMvszmpm++TxndYisgNYscpZSoz7wvcazJNEPfhPVjEkd6tUUuN4GM35H0DmKCUQNT+a6B6hmHlTZvjxiyGAg5bY59hdjvJ+22QduazlEEC6LI3HrA7uK0TpplWzS1tCIFvTMUhj65DEZmNJ2+ZY9bQ4vsMf+DRR3OOG4t+DMlNfjOd3zNv3QoY95BjfWpryFwPzDq7bCP67JDsoj7j2TY5FRSrRkD77H0Ewlux2cWfjRTwcMHcdQxxuV0OP0aNjGDjybFN"}',
+        },
+        {
+          id: '6424c353eaf78d000766e96137d4404b',
+          source: 'backup',
+          type: 'tss',
+          commonKeychain:
+            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+          encryptedPrv:
+            '{"iv":"vi0dPef/Rx7kG/pRySQi6Q==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"9efhQsiEvVs=","ct":"Gw6atvf6gxKzsjtl3xseipO3rAxp1mAz7Yu1ihFsi5/lf2vMZegApgZx+pyILFS9KKLHbNF3U6WgSYdrr2t4vzdLsXkH1WIxfHS+cd2C5N59yADZDnPJBT6pv/IRvaYelP0Ck3nIYQ2hSMm8op+VOWC/SzHeh7slYDqwEHTGan0Wigfvk1yRd7CCJTaEAomnc/4eFi2NY3X3gt/3opy9IAgknnwUFohn96EWpEQ0F6pbzH/Z8VF6gF+DUcrrByAxExUPnHQZiFk3YHU/vVV4FxBU/mVAE8xBsBn5ul5e5SUMPfc7TBuJWv4BByTNg9xDShF/91Yx2nbfUm5d9QmM8lpKgzzQvcK8POAPk87gRCuKnsGh5vNS0UppkHc+ocfzRQlGA6jze7QyyQO0rMj5Ly8kWjwk2vISvKYHYS1NR7VU549UIXo7NXjatunKSc3+IreoRUHIshiaLg6hl+pxCCuc0qQ43V0mdIfCjTN8gkGWLNk8R7tAGPz9jyapQPcPEGHgEz0ATIi6yMNWCsibS2eLiE1uVEJONoM4lk6FPl3Q2CHbW2MeEbqjY8hbaw18mNb2xSBH/Fwpiial+Tvi2imqgnCO4ZpO9bllKftZPcQy0stN+eGBlb5ufyflKkDSiChHYroGjEpmiFicdde48cJszF52uKNnf1q67fA9/S2FAHQab3EXojxH2Gbk+kkV2h/TYKFFZSWC3vi4e8mO+vjMUcR0AdsgPFyEIz0SCGuba3CnTLNdEuZwsauAeHkx2vUTnRgJPVgNeeuXmsVG76Sy2ggJHuals0Hj8U2Xda0qO1RuFfoCWfss9wn6HGRwPPkhSB/8oNguAqmRVGKkd8Zwt3IvrTd9fk0/rFFDJKGz7WyNHkYgUmNiGcItD12v0jx7FZ52EJzl3Av1RyJUQK18+8EYPh3SGiU9dt7VX0aF0uo6JouKhOeldUvMP+AugQz8fUclwTQsbboVg27Yxo0DyATVwThW5a56R6Qf5ZiQJluFuzs5y98rq0S5q046lE6o3vVmJpEdwjeSCJoET5CL4nTgkXyWvhm4eB8u/e66l3o0qbaSx8q9YYmT9EpRcl5TP4ThLBKETYdzVvg4exjQfektMatk5EyUpEIhZPXh5vXpJZesdfO9LJ8zTaHBsBjDPU7cdNgQMbebpataRi8A0el2/IJXl+E+olgAz5zC4i2O1Q=="}',
+        },
+        {
+          id: '6424c353eaf78d000766e9510b125fba',
+          source: 'bitgo',
+          type: 'tss',
+          commonKeychain:
+            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+          verifiedVssProof: true,
+          isBitGo: true,
+        },
+      ];
+    });
+
+    it('should return true when validating a well formatted address', async function () {
+      const address = 'f941ae3cbe5645dccc15da8346b533f7f91f202089a5521653c062b2ff10b304';
+      basecoin.isValidAddress(address).should.equal(true);
+    });
+
+    it('should return true when validating a well formatted address prefixed with 0x', async function () {
+      const address = '0xf941ae3cbe5645dccc15da8346b533f7f91f202089a5521653c062b2ff10b304';
+      basecoin.isValidAddress(address).should.equal(true);
+    });
+
+    it('should return false when validating an old address', async function () {
+      const address = '0x2959bfc3fdb7dc23fed8deba2fafb70f3e606a59';
+      basecoin.isValidAddress(address).should.equal(false);
+    });
+
+    it('should return false when validating an incorrectly formatted', async function () {
+      const address = 'wrongaddress';
+      basecoin.isValidAddress(address).should.equal(false);
+    });
+
+    it('should return true for isWalletAddress with valid address for index 4', async function () {
+      const newAddress = '0x8b3c7807730d75792dd6c49732cf9f014d6984a9c77d386bdb1072a9e537d8d8';
+      const index = 4;
+
+      const params = { commonKeychain, address: newAddress, index, keychains };
+      (await basecoin.isWalletAddress(params)).should.equal(true);
+    });
+
+    it('should throw error for isWalletAddress when keychains is missing', async function () {
+      const address = '0x2959bfc3fdb7dc23fed8deba2fafb70f3e606a59';
+      const index = 0;
+
+      const params = { commonKeychain, address, index };
+      await assert.rejects(async () => basecoin.isWalletAddress(params));
+    });
+
+    it('should throw error for isWalletAddress when new address is invalid', async function () {
+      const wrongAddress = 'badAddress';
+      const index = 0;
+
+      const params = { commonKeychain, address: wrongAddress, index };
+      await assert.rejects(async () => basecoin.isWalletAddress(params), {
+        message: `invalid address: ${wrongAddress}`,
+      });
+    });
   });
 });
diff --git a/modules/sdk-coin-apt/test/unit/keyPair.ts b/modules/sdk-coin-apt/test/unit/keyPair.ts
@@ -0,0 +1,59 @@
+import assert from 'assert';
+import { KeyPair } from '../../src';
+import utils from '../../src/lib/utils';
+import should from 'should';
+import { Eddsa } from '@bitgo/sdk-core';
+import { Ed25519Bip32HdTree, HDTree } from '@bitgo/sdk-lib-mpc';
+
+describe('Apt KeyPair', function () {
+  let rootKeychain;
+  let rootPublicKey;
+  let MPC: Eddsa;
+  let hdTree: HDTree;
+
+  before(async () => {
+    hdTree = await Ed25519Bip32HdTree.initialize();
+    MPC = await Eddsa.initialize(hdTree);
+    const A = MPC.keyShare(1, 2, 3);
+    const B = MPC.keyShare(2, 2, 3);
+    const C = MPC.keyShare(3, 2, 3);
+
+    const A_combine = MPC.keyCombine(A.uShare, [B.yShares[1], C.yShares[1]]);
+
+    const commonKeychain = A_combine.pShare.y + A_combine.pShare.chaincode;
+    rootKeychain = MPC.deriveUnhardened(commonKeychain, 'm/0');
+    rootPublicKey = Buffer.from(rootKeychain, 'hex').slice(0, 32).toString('hex');
+  });
+
+  describe('should create a valid KeyPair', () => {
+    it('from an empty value', async () => {
+      const keyPair = new KeyPair();
+      should.exists(keyPair.getKeys().prv);
+      should.exists(keyPair.getKeys().pub);
+      const address = await utils.getAddressFromPublicKey(keyPair.getKeys().pub);
+      console.log('address:', address);
+      should.exists(address);
+    });
+  });
+
+  describe('Keypair from derived Public Key', () => {
+    it('should create keypair with just derived public key', () => {
+      const keyPair = new KeyPair({ pub: rootPublicKey });
+      keyPair.getKeys().pub.should.equal(rootPublicKey);
+    });
+
+    it('should derived ed25519 public key should be valid', () => {
+      utils.isValidPublicKey(rootPublicKey).should.be.true();
+    });
+  });
+
+  describe('should fail to create a KeyPair', function () {
+    it('from an invalid public key', () => {
+      const source = {
+        pub: '01D63D',
+      };
+
+      assert.throws(() => new KeyPair(source));
+    });
+  });
+});
