Win 4343 fix

modules/abstract-cosmos/src/cosmosCoin.ts

@@ -170,12 +170,14 @@
       senderAddress = this.getAddressFromPublicKey(publicKey);
     } else {
       senderAddress = params.rootAddress as string;
+      publicKey = params.bitgoKey as string;
     }
 
     // Step 3: Instantiate the ECDSA signer and fetch the address details
     const chainId = await this.getChainId();
     // Step 4: Fetch account details such as accountNo, balance and check for sufficient funds once gasAmount has been deducted
     const [accountNumber, sequenceNo] = await this.getAccountDetails(senderAddress);
+    console.log('accountnumber:', accountNumber, 'sequenceNo:', sequenceNo);
     const balance = new BigNumber(await this.getAccountBalance(senderAddress));
     const gasBudget: FeeData = {
       amount: [{ denom: this.getDenomination(), amount: this.getGasAmountDetails().gasAmount }],
@@ -210,23 +212,19 @@
       .gasBudget(gasBudget)
       .sequence(Number(sequenceNo))
       .accountNumber(Number(accountNumber))
-      .chainId(chainId);
-
-    if (publicKey) {
-      txnBuilder.publicKey(publicKey);
-    }
-
+      .chainId(chainId)
+      .publicKey(publicKey);
     const unsignedTransaction = (await txnBuilder.build()) as CosmosTransaction;
-    let serializedTx = unsignedTransaction.toBroadcastFormat();
-    const signableHex = unsignedTransaction.signablePayload.toString('hex');
 
     // Check if unsigned sweep is requested
     if (isUnsignedSweep) {
       return {
-        signableHex: signableHex,
+        signableTransaction: unsignedTransaction,
       };
     }
 
+    let serializedTx = unsignedTransaction.toBroadcastFormat();
+    const signableHex = unsignedTransaction.signablePayload.toString('hex');
     // Step 7: Sign the tx for non-BitGo recovery
     const message = unsignedTransaction.signablePayload;
     const messageHash = (utils.getHashFunction() || createHash('sha256')).update(message).digest();

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

@@ -1,5 +1,6 @@
 import { TransactionExplanation as BaseTransactionExplanation, TransactionType } from '@bitgo/sdk-core';
 import { Coin } from '@cosmjs/stargate';
+import { CosmosTransaction } from './transaction';
 
 /**
  * Defines the protobuf typeUrl for the public key
@@ -39,7 +40,7 @@ export interface RecoveryOptions {
 
 export interface CosmosLikeCoinRecoveryOutput {
   serializedTx?: string;
-  signableHex?: string;
+  signableTransaction?: CosmosTransaction;
 }
 
 export interface DelegateOrUndelegeteMessage {

modules/sdk-coin-atom/test/resources/atom.ts

@@ -494,3 +494,36 @@ export const wrwUserDkls = {
     '7a24333f8383c158b2e5fc9882e5acf0bb2a85a481cf150a5e94b6a',
   walletPassphrase: '#Bondiola1234',
 };
+
+export const TEST_UNSIGNED_SWEEP_TX = {
+  hash: 'B7E846004999A3D9C1F09A253C61E41FC5711C2228E18E8488B2F5FE1FE9F4D3',
+  signature: null, // Unsigned transaction
+  pubKey: 'Ah0Xud1r7fdljxs/dx9Rud1Un55KArr94VMtAMoUXBsO',
+  privateKey: 'cGQSjk/xusPlqScte8OnHMAaW7Zjt1wu7R6W4eYzLUg=',
+  unsignedTxBase64:
+    'CpIBCo8BChwvY29zbW9zLmJhbmsudjFiZXRhMS5Nc2dTZW5kEm8KLWNvc21vczFzbWVma3E5eWF4Z3c5YzlmaHltNnFzcDc0NnE4ODRjemVhY24zMhItY29zbW9zMTZnaG45YzZmNXl1YTA5enF3N3k3OTRtdmMzMGg0eTRtZDdja3VrGg8KBXVhdG9tEgYxMDAwMDASZApOCkYKHy9jb3Ntb3MuY3J5cHRvLnNlY3AyNTZrMS5QdWJLZXkSIwohAh0Xud1r7fdljxs/dx9Rud1Un55KArr94VMtAMoUXBsOEgQKAggBEhIKDAoFdWF0b20SAzcwMBDAmgwaQKZAQv4NnqpEcy6f8XPT8Oc6Nv/Ywp3ifs7x9C2/syBqEKjTQEeXlNxk40fYpyX6YpK6a0GIKDsXU+zp1iLA3Z8=',
+  sender: 'cosmos1smefkq9yaxgw9c9fhym6qsp746q884czeacn32',
+  recipient: 'cosmos16ghn9c6f5yua09zqw7y794mvc30h4y4md7ckuk',
+  chainId: 'theta-testnet-001',
+  accountNumber: 755441,
+  sequence: 3,
+  sendAmount: '50000',
+  feeAmount: '100000',
+  sendMessage: {
+    typeUrl: '/cosmos.bank.v1beta1.MsgSend',
+    value: {
+      amount: [
+        {
+          denom: 'uatom',
+          amount: '50000',
+        },
+      ],
+      toAddress: 'cosmos16ghn9c6f5yua09zqw7y794mvc30h4y4md7ckuk',
+      fromAddress: 'cosmos1smefkq9yaxgw9c9fhym6qsp746q884czeacn32',
+    },
+  },
+  gasBudget: {
+    amount: [{ denom: 'uatom', amount: '100000' }],
+    gasLimit: 200000,
+  },
+};

modules/sdk-coin-atom/test/unit/atom.ts

@@ -18,6 +18,7 @@ import {
   address,
   wrwUser,
   wrwUserDkls,
+  TEST_UNSIGNED_SWEEP_TX,
 } from '../resources/atom';
 import should = require('should');
 
@@ -398,16 +399,24 @@ describe('ATOM', function () {
     const testAccountNumberDkls = '755440';
     const testSequenceNumberDkls = '2';
 
+    const testBalanceunsignedSweep = '150000';
+    const testAccountNumberunsignedSweep = '755441';
+    const testSequenceNumberunsignedSweep = '3';
+
     const testChainId = 'theta-testnet-001';
 
     beforeEach(() => {
       const accountBalance = sandBox.stub(Atom.prototype, 'getAccountBalance' as keyof Atom);
       accountBalance.withArgs(wrwUser.senderAddress).resolves(testBalance);
       accountBalance.withArgs(wrwUserDkls.senderAddress).resolves(testBalanceDkls);
+      accountBalance.withArgs(wrwUser.senderAddress).resolves(testBalanceunsignedSweep);
 
       const accountDetails = sandBox.stub(Atom.prototype, 'getAccountDetails' as keyof Atom);
       accountDetails.withArgs(wrwUser.senderAddress).resolves([testAccountNumber, testSequenceNumber]);
       accountDetails.withArgs(wrwUserDkls.senderAddress).resolves([testAccountNumberDkls, testSequenceNumberDkls]);
+      accountDetails
+        .withArgs(wrwUser.senderAddress)
+        .resolves([testAccountNumberunsignedSweep, testSequenceNumberunsignedSweep]);
 
       const chainId = sandBox.stub(Atom.prototype, 'getChainId' as keyof Atom);
       chainId.withArgs().resolves(testChainId);
@@ -438,6 +447,7 @@ describe('ATOM', function () {
       const atomTxn = new CosmosTransaction(coin, utils);
       atomTxn.enrichTransactionDetailsFromRawTransaction(res.serializedTx);
       const atomTxnJson = atomTxn.toJson();
+      //console.log("atomTxnJson", atomTxnJson);
       const sendMessage = atomTxnJson.sendMessages[0].value as SendMessage;
       const balance = new BigNumber(testBalance);
       const gasAmount = new BigNumber(GAS_AMOUNT);
@@ -470,27 +480,39 @@ describe('ATOM', function () {
     });
 
     it('should recover funds for Unsigned Sweep Transaction', async function () {
-      const res = await basecoin.recover({
-        userKey: wrwUser.userKey,
-        backupKey: wrwUser.backupKey,
-        bitgoKey: wrwUser.bitgoKey,
-        walletPassphrase: wrwUser.walletPassphrase,
-        recoveryDestination: destinationAddress,
-      });
-      res.should.not.be.empty();
-      res.should.hasOwnProperty('serializedTx');
-      sandBox.assert.calledOnce(basecoin.getAccountBalance);
-      sandBox.assert.calledOnce(basecoin.getAccountDetails);
-      sandBox.assert.calledOnce(basecoin.getChainId);
-
-      const unsignedSweepTxnDeserialize = new CosmosTransaction(coin, utils);
-      unsignedSweepTxnDeserialize.enrichTransactionDetailsFromRawTransaction(res.serializedTx);
-      const unsignedSweepTxnJson = unsignedSweepTxnDeserialize.toJson();
-      const sendMessage = unsignedSweepTxnJson.sendMessages[0].value as SendMessage;
-      const balance = new BigNumber(testBalance);
-      const gasAmount = new BigNumber(GAS_AMOUNT);
-      const actualBalance = balance.minus(gasAmount);
-      should.equal(sendMessage.amount[0].amount, actualBalance.toFixed());
+      try {
+        const res = await basecoin.recover({
+          rootAddress: wrwUser.senderAddress,
+          recoveryDestination: destinationAddress,
+        });
+
+        // Assertions
+        res.should.not.be.empty();
+        res.should.have.property('signableTransaction');
+        const signableTransaction = res.signableTransaction;
+        signableTransaction.should.be.an.instanceof(CosmosTransaction);
+
+        sandBox.assert.calledOnce(basecoin.getAccountBalance);
+        sandBox.assert.calledOnce(basecoin.getAccountDetails);
+        sandBox.assert.calledOnce(basecoin.getChainId);
+
+        // Verify the properties of the signableTransaction directly
+        const signableTransactionJson = signableTransaction.toJson();
+        should.equal(signableTransactionJson.sequence, TEST_UNSIGNED_SWEEP_TX.sequence);
+        should.equal(signableTransactionJson.accountNumber, TEST_UNSIGNED_SWEEP_TX.accountNumber);
+        should.equal(signableTransactionJson.chainId, TEST_UNSIGNED_SWEEP_TX.chainId);
+        should.equal(signableTransactionJson.type, 0); // Assuming type is 0 for unsigned transactions
+        should.equal(signableTransactionJson.id, 'UNAVAILABLE'); // Assuming id is 'UNAVAILABLE' for unsigned transactions
+        should.equal(signableTransactionJson.gasBudget.gasLimit, 200000); // Assuming gasLimit is 200000
+        should.equal(signableTransactionJson.publicKey, undefined); // Assuming publicKey is undefined for unsigned transactions
+        should.equal(signableTransactionJson.signature, TEST_UNSIGNED_SWEEP_TX.signature); // Assuming signature is undefined for unsigned transactions
+        should.equal(signableTransactionJson.hash, undefined); // Assuming hash is undefined for unsigned transactions
+        should.equal(signableTransactionJson.memo, undefined);
+        console.log('Test for Unsigned Sweep Transaction completed successfully');
+      } catch (error) {
+        console.error('Error during test for Unsigned Sweep Transaction:', error);
+        throw error; // Re-throw the error to ensure the test fails
+      }
     });
 
     it('should redelegate funds to new validator', async function () {