Merge remote-tracking branch 'origin/master' into rel/latest

Author: mohammadalfaiyazbitgo

examples/ts/eth/recover-eth.ts

@@ -0,0 +1,47 @@
+/**
+ * Recover ETH from a multi-sig wallet
+ *
+ * This script demonstrates how to generate an unsigned recovery transaction for a
+ * Multi-Sig ETH wallet.
+ */
+
+import { BitGo } from 'bitgo';
+import { Hteth } from '@bitgo/sdk-coin-eth';
+
+// Set up BitGo object
+const bitgo = new BitGo({ env: 'test' }); // change to 'prod' for mainnet
+bitgo.register('hteth', Hteth.createInstance);
+
+async function recoverEth() {
+  try {
+    // Use the recovery with API key for output
+    const recovery = (await (bitgo.coin('hteth') as Hteth).recover({
+      userKey: 'user-public-key',
+      backupKey: 'backup-public-key',
+      walletContractAddress: 'Address-of-your-multisig-wallet',
+      recoveryDestination: 'Address-To-Recover-Funds-To',
+      isUnsignedSweep: true,
+      apiKey: 'Add Your Etherscan ApiKey here',
+    })) as any;
+
+    // Print the recovery transaction hex
+    console.log('Recovery transaction hex:');
+    console.log(recovery.tx);
+
+    // Print additional information
+    console.log('\nFull recovery object:', JSON.stringify(recovery, null, 2));
+
+    return recovery;
+  } catch (e) {
+    console.error('Error performing recovery:', e);
+    throw e;
+  }
+}
+
+// Execute the recovery function
+recoverEth()
+  .then(() => process.exit(0))
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

examples/ts/trx/fetch-addresses-with-trx-balance-for-consolidation.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2025, BitGo, Inc.  All Rights Reserved.
+ */
+import { BitGoAPI } from '@bitgo/sdk-api';
+import { Trx } from '@bitgo/sdk-coin-trx';
+import * as fs from 'fs';
+import BigNumber from 'bignumber.js';
+require('dotenv').config({ path: '../../.env' });
+
+const bitgo = new BitGoAPI({
+  accessToken: '',
+  env: 'prod',
+});
+
+const coin = 'trx';
+bitgo.register(coin, Trx.createInstance);
+
+const walletId = '';
+
+// This script is used for fetching the amount of TRX that can be consolidated
+// specifically for wallets which use gas tank to fund addresses in case of token deposit (we block 36 trx for each unique token that is present in the address)
+async function main() {
+  const wallet = await bitgo.coin(coin).wallets().get({ id: walletId });
+  let prevId = undefined;
+  let index = 1;
+
+  do {
+    const addresses = await wallet.addresses({ includeBalances: true, prevId });
+    prevId = addresses.nextBatchPrevId;
+
+    for (const { address, balance, needsConsolidation, tokenConsolidationState } of addresses.addresses) {
+      const { tokens, spendableBalanceString } = balance;
+      let tokenCounter = 0;
+      console.log(`Address ${index}: ${address}`);
+      const trxSpendableBalance = new BigNumber(spendableBalanceString || '0');
+      console.log('TRX balance: ', trxSpendableBalance);
+
+      // Process token balances if any
+      for (const key in tokens) {
+        const tokenSpendableBalance = new BigNumber(tokens[key]?.spendableBalanceString || '0');
+        console.log(`Token: ${key}, Token spendable balance: ${tokenSpendableBalance}`);
+        if (tokenSpendableBalance.isGreaterThan(0)) {
+          tokenCounter += 1;
+        }  
+      }
+
+      if (tokenCounter > 0 && trxSpendableBalance.isGreaterThanOrEqualTo(0)) {
+        // This is for enteprises which use gas tank for funding receive addresses with TRX on token deposit
+        // we block 36 TRX for each unique token that needs to be consolidated and arrive at the amout of TRX that can be consolidated
+        const trxBalanceThatCanBeConsolidated = BigNumber.max(trxSpendableBalance.minus(tokenCounter * 36000000), 0);
+        const data = `${address}, No of tokens: ${tokenCounter}, TRX balance: ${trxSpendableBalance}, TRX balance that can be consolidated: ${trxBalanceThatCanBeConsolidated}, V1 flag: ${needsConsolidation}, V2 flag: ${tokenConsolidationState['trx']}\n`;
+        fs.appendFileSync('addresses-with-token-balance-and-trx-to-be-consolidated.txt', data);
+      } else if (tokenCounter == 0 && trxSpendableBalance.isGreaterThanOrEqualTo(0)) {
+        // if address does not have any tokens and has more than 1 TRX, then we need to subtract 1 TRX from it (min TRX thats left in the address)
+        const trxBalanceThatCanBeConsolidated = BigNumber.max(trxSpendableBalance.minus(1000000), 0);
+        const data = `${address}, No of tokens: ${tokenCounter}, TRX balance: ${trxSpendableBalance}, TRX balance that can be consolidated: ${trxBalanceThatCanBeConsolidated}, V1 flag: ${needsConsolidation}, V2 flag: ${tokenConsolidationState['trx']}\n`;
+        fs.appendFileSync('addresses-without-token-balance-and-trx-to-be-consolidated.txt', data);
+      }
+
+      index += 1;
+    }
+  } while (prevId !== undefined);
+}
+
+main().catch((e) => console.error(e));

modules/abstract-cosmos/package.json

@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@bitgo/sdk-core": "^35.9.0",
+    "@bitgo/sdk-api": "^1.65.1",
     "@bitgo/sdk-lib-mpc": "^10.6.0",
     "@bitgo/secp256k1": "^1.4.0",
     "@bitgo/statics": "^55.3.0",
@@ -54,6 +55,7 @@
     "superagent": "^9.0.1"
   },
   "devDependencies": {
+    "@bitgo/sdk-test": "^8.0.97",
     "@types/lodash": "^4.14.183"
   },
   "gitHead": "18e460ddf02de2dbf13c2aa243478188fb539f0c"

modules/abstract-cosmos/src/cosmosToken.ts

@@ -15,9 +15,11 @@ export class CosmosToken extends CosmosCoin {
     return (bitgo: BitGoBase) => new CosmosToken(bitgo, config);
   }
 
-  static createTokenConstructors(): NamedCoinConstructor[] {
+  static createTokenConstructors(
+    tokenConfigs: CosmosTokenConfig[] = [...tokens.bitcoin.cosmos.tokens, ...tokens.testnet.cosmos.tokens]
+  ): NamedCoinConstructor[] {
     const tokensCtors: NamedCoinConstructor[] = [];
-    for (const token of [...tokens.bitcoin.cosmos.tokens, ...tokens.testnet.cosmos.tokens]) {
+    for (const token of tokenConfigs) {
       const tokenConstructor = CosmosToken.createTokenConstructor(token);
       tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
     }
@@ -53,8 +55,8 @@ export class CosmosToken extends CosmosCoin {
   }
 
   getFullName(): string {
-    // Eg - returns "Atom Token", "Osmo Token"
-    return `${this.tokenConfig.coin.charAt(0).toUpperCase()}${this.tokenConfig.coin.slice(1)} Token`;
+    const displayCoin = this.getFamily();
+    return `${displayCoin.charAt(0).toUpperCase() + displayCoin.slice(1)} Token`;
   }
 
   getBaseFactor(): number {

modules/abstract-cosmos/test/unit/cosmosToken.ts

@@ -0,0 +1,49 @@
+import 'should';
+
+import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
+import { BitGoAPI } from '@bitgo/sdk-api';
+import { CosmosToken } from '../../src';
+
+describe('Cosmos Tokens', function () {
+  let bitgo: TestBitGoAPI;
+  let mainnetCosmosToken;
+  let testnetCosmosToken;
+  const testnetTokenName = 'thash:ylds';
+  const mainnetTokenName = 'hash:ylds';
+
+  before(function () {
+    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });
+    CosmosToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+      bitgo.safeRegister(name, coinConstructor);
+    });
+    bitgo.initializeTestVars();
+    mainnetCosmosToken = bitgo.coin(mainnetTokenName);
+    testnetCosmosToken = bitgo.coin(testnetTokenName);
+  });
+
+  it('should return constants for Hash YLDS testnet token', function () {
+    testnetCosmosToken.getChain().should.equal(testnetTokenName);
+    testnetCosmosToken.getBaseChain().should.equal('thash');
+    testnetCosmosToken.getFullName().should.equal('Hash Token');
+    testnetCosmosToken.getBaseFactor().should.equal(1e6);
+    testnetCosmosToken.type.should.equal(testnetTokenName);
+    testnetCosmosToken.name.should.equal('Testnet YLDS Token');
+    testnetCosmosToken.coin.should.equal('thash');
+    testnetCosmosToken.network.should.equal('Testnet');
+    testnetCosmosToken.denom.should.equal('uylds.fcc');
+    testnetCosmosToken.decimalPlaces.should.equal(6);
+  });
+
+  it('should return constants for Hash YLDS mainnet token', function () {
+    mainnetCosmosToken.getChain().should.equal(mainnetTokenName);
+    mainnetCosmosToken.getBaseChain().should.equal('hash');
+    mainnetCosmosToken.getFullName().should.equal('Hash Token');
+    mainnetCosmosToken.getBaseFactor().should.equal(1e6);
+    mainnetCosmosToken.type.should.equal(mainnetTokenName);
+    mainnetCosmosToken.name.should.equal('YLDS Token');
+    mainnetCosmosToken.coin.should.equal('hash');
+    mainnetCosmosToken.network.should.equal('Mainnet');
+    mainnetCosmosToken.denom.should.equal('uylds.fcc');
+    mainnetCosmosToken.decimalPlaces.should.equal(6);
+  });
+});