@bitgo-beta/sdk-coin-cosmos 1.0.1-alpha.8 → 1.0.1-alpha.80

package/dist/test/testUtils/utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility functions for Cosmos SDK test data
+ * This file contains utility functions for test data
+ */
+import { TransactionBuilderFactory } from '../../src/lib/transactionBuilderFactory';
+import { CoinTestData } from './types';
+/**
+ * Get all available test coins
+ * @returns {string[]} Array of coin names that have test data
+ */
+export declare const getAvailableTestCoins: () => string[];
+/**
+ * Load test data for a specific coin
+ *
+ * This utility abstracts away the path resolution logic,
+ * making it easier to load test data from anywhere in the test suite.
+ *
+ * @param {string} coinName - The coin name (e.g., 'cosmos', 'cronos')
+ * @returns {CoinTestData} The test data for the coin
+ * @throws {Error} If the test data for the coin is not found
+ */
+export declare const getTestData: (coinName: string) => CoinTestData;
+/**
+ * Get test data for all available coins
+ *
+ * @returns {Record<string, CoinTestData>} An object mapping coin names to their test data
+ */
+export declare const getAllTestData: () => Record<string, CoinTestData>;
+/**
+ * Get the builder factory for a specific coin
+ * @param {string} coin - The coin name
+ * @returns {TransactionBuilderFactory} The transaction builder factory
+ */
+export declare const getBuilderFactory: (coin: string) => TransactionBuilderFactory;
+/**
+ * Ensures that all required properties are present in the test transaction data
+ * This is useful for TypeScript type checking in test files
+ *
+ * @param {T} tx - The transaction data that might have optional properties
+ * @returns {Required<T>} The same transaction data but with TypeScript treating all properties as non-optional
+ */
+export declare function ensureTransaction<T>(tx: T): Required<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/testUtils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/testUtils/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAO,MAAM,EAa9C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,aAAc,MAAM,KAAG,YAO9C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAO,MAAM,CAAC,MAAM,EAAE,YAAY,CAO5D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,SAAU,MAAM,8BAG7C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAIvD"}

package/dist/test/testUtils/utils.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Utility functions for Cosmos SDK test data
+ * This file contains utility functions for test data
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuilderFactory = exports.getAllTestData = exports.getTestData = exports.getAvailableTestCoins = void 0;
+exports.ensureTransaction = ensureTransaction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const statics_1 = require("@bitgo-beta/statics");
+const transactionBuilderFactory_1 = require("../../src/lib/transactionBuilderFactory");
+/**
+ * Get all available test coins
+ * @returns {string[]} Array of coin names that have test data
+ */
+const getAvailableTestCoins = () => {
+    try {
+        // Get the resources directory path
+        const resourcesDir = path.join(__dirname, '../resources');
+        // Read all files in the resources directory
+        const files = fs.readdirSync(resourcesDir);
+        // Extract coin names by removing the .ts extension
+        return files.map((file) => file.replace('.ts', ''));
+    }
+    catch (error) {
+        // Fallback to hardcoded list if there's an error
+        console.warn('Failed to dynamically discover test coins:', error);
+        return ['cosmos', 'cronos'];
+    }
+};
+exports.getAvailableTestCoins = getAvailableTestCoins;
+/**
+ * Load test data for a specific coin
+ *
+ * This utility abstracts away the path resolution logic,
+ * making it easier to load test data from anywhere in the test suite.
+ *
+ * @param {string} coinName - The coin name (e.g., 'cosmos', 'cronos')
+ * @returns {CoinTestData} The test data for the coin
+ * @throws {Error} If the test data for the coin is not found
+ */
+const getTestData = (coinName) => {
+    try {
+        // Dynamic import of the coin-specific test data
+        return require(`../resources/${coinName}`).default;
+    }
+    catch (e) {
+        throw new Error(`Test data for coin ${coinName} not found: ${e}`);
+    }
+};
+exports.getTestData = getTestData;
+/**
+ * Get test data for all available coins
+ *
+ * @returns {Record<string, CoinTestData>} An object mapping coin names to their test data
+ */
+const getAllTestData = () => {
+    const availableCoins = (0, exports.getAvailableTestCoins)();
+    const result = {};
+    for (const coin of availableCoins) {
+        result[coin] = (0, exports.getTestData)(coin);
+    }
+    return result;
+};
+exports.getAllTestData = getAllTestData;
+/**
+ * Get the builder factory for a specific coin
+ * @param {string} coin - The coin name
+ * @returns {TransactionBuilderFactory} The transaction builder factory
+ */
+const getBuilderFactory = (coin) => {
+    const coinConfig = statics_1.coins.get(coin);
+    return new transactionBuilderFactory_1.TransactionBuilderFactory(coinConfig);
+};
+exports.getBuilderFactory = getBuilderFactory;
+/**
+ * Ensures that all required properties are present in the test transaction data
+ * This is useful for TypeScript type checking in test files
+ *
+ * @param {T} tx - The transaction data that might have optional properties
+ * @returns {Required<T>} The same transaction data but with TypeScript treating all properties as non-optional
+ */
+function ensureTransaction(tx) {
+    // This function doesn't actually modify the data
+    // It just tells TypeScript that all properties are present
+    return tx;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/cosmosSharedCoin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmosSharedCoin.d.ts.map

package/dist/test/unit/cosmosSharedCoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmosSharedCoin.d.ts","sourceRoot":"","sources":["../../../test/unit/cosmosSharedCoin.ts"],"names":[],"mappings":""}

package/dist/test/unit/cosmosSharedCoin.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sinon_1 = __importDefault(require("sinon"));
+const encoding_1 = require("@cosmjs/encoding");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const statics_1 = require("@bitgo-beta/statics");
+const src_1 = require("../../src");
+const testUtils_1 = require("../testUtils");
+describe('Cosmos Shared Coin', function () {
+    const availableCoins = (0, testUtils_1.getAvailableTestCoins)();
+    // TODO: COIN-5039 -  Running tests for each coin in parallel to improve test performance
+    // Loop through each available coin and run tests
+    availableCoins.forEach((coinName) => {
+        describe(`${coinName.toUpperCase()} Cosmos Shared Coin`, function () {
+            let bitgo;
+            let cosmosCoin;
+            let utils;
+            const testData = (0, testUtils_1.getTestData)(coinName);
+            const testTx = testData.testSendTx;
+            const testTxWithMemo = testData.testTxWithMemo;
+            const coin = statics_1.coins.get(testData.testnetCoin);
+            const network = coin.network;
+            before(function () {
+                bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+                bitgo.safeRegister(testData.testnetCoin, src_1.CosmosSharedCoin.createInstance);
+                bitgo.safeRegister(testData.mainnetCoin, src_1.CosmosSharedCoin.createInstance);
+                bitgo.initializeTestVars();
+                cosmosCoin = bitgo.coin(testData.testnetCoin);
+                utils = new src_1.Utils(network);
+            });
+            it('should instantiate the coin', function () {
+                should_1.default.exist(cosmosCoin);
+                cosmosCoin.should.be.an.instanceof(src_1.CosmosSharedCoin);
+            });
+            it('should return the right info', function () {
+                const testCoin = bitgo.coin(testData.testnetCoin);
+                const mainnetCoin = bitgo.coin(testData.mainnetCoin);
+                testCoin.getChain().should.equal(testData.testnetCoin);
+                testCoin.getFamily().should.equal(testData.family);
+                testCoin.getFullName().should.equal(testData.testnetName);
+                testCoin.getBaseFactor().should.equal(Math.pow(10, testData.decimalPlaces));
+                mainnetCoin.getChain().should.equal(testData.mainnetCoin);
+                mainnetCoin.getFamily().should.equal(testData.family);
+                mainnetCoin.getFullName().should.equal(testData.mainnetName);
+                mainnetCoin.getBaseFactor().should.equal(Math.pow(10, testData.decimalPlaces));
+            });
+            it('should throw if instantiated without a staticsCoin', function () {
+                const tempBitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+                (0, should_1.default)(() => src_1.CosmosSharedCoin.createInstance(tempBitgo)).throwError('missing required constructor parameter staticsCoin');
+            });
+            it('should throw if instantiated with invalid network configuration', function () {
+                const tempBitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+                const invalidCoin = Object.assign({}, coin, { network: {} });
+                (0, should_1.default)(() => src_1.CosmosSharedCoin.createInstance(tempBitgo, invalidCoin)).throwError('Invalid network configuration: missing required Cosmos network parameters');
+            });
+            describe('getBaseFactor', function () {
+                it('should return the correct base factor', function () {
+                    const baseFactor = cosmosCoin.getBaseFactor();
+                    should_1.default.equal(baseFactor, Math.pow(10, testData.decimalPlaces));
+                });
+            });
+            describe('getBuilder', function () {
+                it('should return a transaction builder', function () {
+                    const builder = cosmosCoin.getBuilder();
+                    should_1.default.exist(builder);
+                });
+            });
+            describe('getDenomination', function () {
+                it('should return the correct denomination', function () {
+                    should_1.default.equal(cosmosCoin.getDenomination(), network.denom);
+                });
+            });
+            describe('getGasAmountDetails', function () {
+                it('should return the correct gas amount details', function () {
+                    const gasAmountDetails = cosmosCoin.getGasAmountDetails();
+                    should_1.default.deepEqual(gasAmountDetails, {
+                        gasAmount: network.gasAmount,
+                        gasLimit: network.gasLimit,
+                    });
+                });
+            });
+            describe('getNetwork', function () {
+                it('should return the correct network', function () {
+                    const returnedNetwork = cosmosCoin.getNetwork();
+                    should_1.default.deepEqual(returnedNetwork, network);
+                });
+            });
+            describe('getKeyPair', function () {
+                it('should return a key pair', function () {
+                    const keyPair = cosmosCoin.getKeyPair((0, encoding_1.toHex)((0, encoding_1.fromBase64)(testData.pubKey)));
+                    should_1.default.exist(keyPair);
+                });
+            });
+            describe('getAddressFromPublicKey', function () {
+                it('should return the correct address', function () {
+                    const address = cosmosCoin.getAddressFromPublicKey((0, encoding_1.toHex)((0, encoding_1.fromBase64)(testData.pubKey)));
+                    should_1.default.equal(address, testData.senderAddress);
+                });
+            });
+            describe('Address Validation', () => {
+                it('should get address details without memoId', function () {
+                    const addressDetails = cosmosCoin.getAddressDetails(testData.addresses.noMemoIdAddress);
+                    addressDetails.address.should.equal(testData.addresses.noMemoIdAddress);
+                    should_1.default.not.exist(addressDetails.memoId);
+                });
+                it('should get address details with memoId', function () {
+                    const addressDetails = cosmosCoin.getAddressDetails(testData.addresses.validMemoIdAddress);
+                    addressDetails.address.should.equal(testData.addresses.validMemoIdAddress.split('?')[0]);
+                    if (addressDetails.memoId) {
+                        addressDetails.memoId.should.equal('2');
+                    }
+                    else {
+                        should_1.default.fail('Expected memoId to be defined', null);
+                    }
+                });
+                it('should throw on invalid memo id address', () => {
+                    (() => {
+                        cosmosCoin.getAddressDetails(testData.addresses.invalidMemoIdAddress);
+                    }).should.throw();
+                });
+                it('should throw on multiple memo id address', () => {
+                    (() => {
+                        cosmosCoin.getAddressDetails(testData.addresses.multipleMemoIdAddress);
+                    }).should.throw();
+                });
+                it('should validate wallet receive address', async function () {
+                    const receiveAddress = {
+                        address: `${testData.addresses.address1}?memoId=7`,
+                        coinSpecific: {
+                            rootAddress: testData.addresses.address1,
+                            memoID: '7',
+                        },
+                    };
+                    // as VerifyTransactionOptions
+                    const isValid = await cosmosCoin.isWalletAddress(receiveAddress);
+                    isValid.should.equal(true);
+                });
+                it('should validate account addresses correctly', () => {
+                    should_1.default.equal(utils.isValidAddress(testData.addresses.address1), true);
+                    should_1.default.equal(utils.isValidAddress(testData.addresses.address2), true);
+                    should_1.default.equal(utils.isValidAddress('dfjk35y'), false);
+                    should_1.default.equal(utils.isValidAddress(undefined), false);
+                    should_1.default.equal(utils.isValidAddress(''), false);
+                    should_1.default.equal(utils.isValidAddress(testData.addresses.validMemoIdAddress), true);
+                    should_1.default.equal(utils.isValidAddress(testData.addresses.invalidMemoIdAddress), false);
+                    should_1.default.equal(utils.isValidAddress(testData.addresses.multipleMemoIdAddress), false);
+                });
+                it('should validate validator addresses correctly', () => {
+                    should_1.default.equal(utils.isValidValidatorAddress(testData.addresses.validatorAddress1), true);
+                    should_1.default.equal(utils.isValidValidatorAddress(testData.addresses.validatorAddress2), true);
+                    should_1.default.equal(utils.isValidValidatorAddress('dfjk35y'), false);
+                    should_1.default.equal(utils.isValidValidatorAddress(undefined), false);
+                    should_1.default.equal(utils.isValidValidatorAddress(''), false);
+                });
+            });
+            describe('Verify transaction: ', () => {
+                it('should succeed to verify transaction', async function () {
+                    const txPrebuild = {
+                        txHex: testTx.signedTxBase64,
+                        txInfo: {},
+                    };
+                    const txParams = {
+                        recipients: [
+                            {
+                                address: testTx.recipient,
+                                amount: testTx.sendAmount,
+                            },
+                        ],
+                    };
+                    const verification = {};
+                    const isTransactionVerified = await cosmosCoin.verifyTransaction({
+                        txParams,
+                        txPrebuild,
+                        verification,
+                    });
+                    isTransactionVerified.should.equal(true);
+                });
+                it('should succeed to verify sendMany transaction', async function () {
+                    const txPrebuild = {
+                        txHex: testTx.signedTxBase64,
+                        txInfo: {},
+                    };
+                    const txParams = {
+                        recipients: [
+                            {
+                                address: testTx.recipient,
+                                amount: testTx.sendAmount,
+                            },
+                        ],
+                    };
+                    const verification = {};
+                    const isTransactionVerified = await cosmosCoin.verifyTransaction({
+                        txParams,
+                        txPrebuild,
+                        verification,
+                    });
+                    isTransactionVerified.should.equal(true);
+                });
+                it('should fail to verify transaction with invalid param', async function () {
+                    const txPrebuild = {};
+                    const txParams = { recipients: undefined };
+                    await cosmosCoin
+                        .verifyTransaction({ txParams, txPrebuild })
+                        .should.be.rejectedWith('missing required tx prebuild property txHex');
+                });
+            });
+            describe('Explain Transaction: ', () => {
+                it('should explain a transfer transaction', async function () {
+                    const explainedTransaction = await cosmosCoin.explainTransaction({
+                        txHex: testTx.signedTxBase64,
+                    });
+                    explainedTransaction.should.deepEqual({
+                        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'],
+                        id: testTx.hash,
+                        outputs: [
+                            {
+                                address: testTx.recipient,
+                                amount: testTx.sendAmount,
+                            },
+                        ],
+                        outputAmount: testTx.sendAmount,
+                        changeOutputs: [],
+                        changeAmount: '0',
+                        fee: { fee: testTx.feeAmount },
+                        type: 0,
+                    });
+                });
+                it('should explain a transfer transaction with memo', async function () {
+                    const explainedTransaction = await cosmosCoin.explainTransaction({
+                        txHex: testTxWithMemo.signedTxBase64,
+                    });
+                    explainedTransaction.should.deepEqual({
+                        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'],
+                        id: testTxWithMemo.hash,
+                        outputs: [
+                            {
+                                address: testTxWithMemo.recipient,
+                                amount: testTxWithMemo.sendAmount,
+                                memo: testTxWithMemo.memo,
+                            },
+                        ],
+                        outputAmount: testTxWithMemo.sendAmount,
+                        changeOutputs: [],
+                        changeAmount: '0',
+                        fee: { fee: testTxWithMemo.feeAmount },
+                        type: 0,
+                    });
+                });
+                it('should fail to explain transaction with missing params', async function () {
+                    try {
+                        await cosmosCoin.explainTransaction({ txHex: '' });
+                    }
+                    catch (error) {
+                        should_1.default.equal(error.message, 'missing required txHex parameter');
+                    }
+                });
+                it('should fail to explain transaction with invalid params', async function () {
+                    try {
+                        await cosmosCoin.explainTransaction({ txHex: 'randomString' });
+                    }
+                    catch (error) {
+                        should_1.default.equal(error.message.startsWith('Invalid transaction:'), true);
+                    }
+                });
+            });
+            describe('Parse Transactions: ', () => {
+                const transferInputsResponse = {
+                    address: testTx.recipient,
+                    amount: new bignumber_js_1.default(testTx.sendAmount).plus(testTx.feeAmount).toFixed(),
+                };
+                const transferOutputsResponse = {
+                    address: testTx.recipient,
+                    amount: testTx.sendAmount,
+                };
+                it('should parse a transfer transaction', async function () {
+                    const parsedTransaction = await cosmosCoin.parseTransaction({ txHex: testTx.signedTxBase64 });
+                    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_1.default.stub(src_1.CosmosSharedCoin.prototype, 'explainTransaction');
+                    stub.resolves(undefined);
+                    await cosmosCoin
+                        .parseTransaction({ txHex: testTx.signedTxBase64 })
+                        .should.be.rejectedWith('Invalid transaction');
+                    stub.restore();
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cosmosSharedCoin.js","sourceRoot":"","sources":["../../../test/unit/cosmosSharedCoin.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport BigNumber from 'bignumber.js';\nimport sinon from 'sinon';\nimport { fromBase64, toHex } from '@cosmjs/encoding';\nimport { VerifyAddressOptions, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { coins, CosmosNetwork } from '@bitgo-beta/statics';\nimport { CosmosSharedCoin, Utils } from '../../src';\nimport { getAvailableTestCoins, getTestData } from '../testUtils';\n\ndescribe('Cosmos Shared Coin', function () {\n  const availableCoins = getAvailableTestCoins();\n  // TODO: COIN-5039 -  Running tests for each coin in parallel to improve test performance\n  // Loop through each available coin and run tests\n  availableCoins.forEach((coinName) => {\n    describe(`${coinName.toUpperCase()} Cosmos Shared Coin`, function () {\n      let bitgo: TestBitGoAPI;\n      let cosmosCoin: CosmosSharedCoin;\n      let utils: Utils;\n      const testData = getTestData(coinName);\n      const testTx = testData.testSendTx as Required<typeof testData.testSendTx>;\n      const testTxWithMemo = testData.testTxWithMemo as Required<typeof testData.testTxWithMemo>;\n      const coin = coins.get(testData.testnetCoin);\n      const network = coin.network as CosmosNetwork;\n\n      before(function () {\n        bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n        bitgo.safeRegister(testData.testnetCoin, CosmosSharedCoin.createInstance);\n        bitgo.safeRegister(testData.mainnetCoin, CosmosSharedCoin.createInstance);\n        bitgo.initializeTestVars();\n        cosmosCoin = bitgo.coin(testData.testnetCoin) as CosmosSharedCoin;\n        utils = new Utils(network);\n      });\n\n      it('should instantiate the coin', function () {\n        should.exist(cosmosCoin);\n        cosmosCoin.should.be.an.instanceof(CosmosSharedCoin);\n      });\n\n      it('should return the right info', function () {\n        const testCoin = bitgo.coin(testData.testnetCoin);\n        const mainnetCoin = bitgo.coin(testData.mainnetCoin);\n        testCoin.getChain().should.equal(testData.testnetCoin);\n        testCoin.getFamily().should.equal(testData.family);\n        testCoin.getFullName().should.equal(testData.testnetName);\n        testCoin.getBaseFactor().should.equal(Math.pow(10, testData.decimalPlaces));\n\n        mainnetCoin.getChain().should.equal(testData.mainnetCoin);\n        mainnetCoin.getFamily().should.equal(testData.family);\n        mainnetCoin.getFullName().should.equal(testData.mainnetName);\n        mainnetCoin.getBaseFactor().should.equal(Math.pow(10, testData.decimalPlaces));\n      });\n\n      it('should throw if instantiated without a staticsCoin', function () {\n        const tempBitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n        should(() => CosmosSharedCoin.createInstance(tempBitgo)).throwError(\n          'missing required constructor parameter staticsCoin'\n        );\n      });\n\n      it('should throw if instantiated with invalid network configuration', function () {\n        const tempBitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n        const invalidCoin = Object.assign({}, coin, { network: {} });\n        should(() => CosmosSharedCoin.createInstance(tempBitgo, invalidCoin)).throwError(\n          'Invalid network configuration: missing required Cosmos network parameters'\n        );\n      });\n\n      describe('getBaseFactor', function () {\n        it('should return the correct base factor', function () {\n          const baseFactor = cosmosCoin.getBaseFactor();\n          should.equal(baseFactor, Math.pow(10, testData.decimalPlaces));\n        });\n      });\n\n      describe('getBuilder', function () {\n        it('should return a transaction builder', function () {\n          const builder = cosmosCoin.getBuilder();\n          should.exist(builder);\n        });\n      });\n\n      describe('getDenomination', function () {\n        it('should return the correct denomination', function () {\n          should.equal(cosmosCoin.getDenomination(), network.denom);\n        });\n      });\n\n      describe('getGasAmountDetails', function () {\n        it('should return the correct gas amount details', function () {\n          const gasAmountDetails = cosmosCoin.getGasAmountDetails();\n          should.deepEqual(gasAmountDetails, {\n            gasAmount: network.gasAmount,\n            gasLimit: network.gasLimit,\n          });\n        });\n      });\n\n      describe('getNetwork', function () {\n        it('should return the correct network', function () {\n          const returnedNetwork = cosmosCoin.getNetwork();\n          should.deepEqual(returnedNetwork, network);\n        });\n      });\n\n      describe('getKeyPair', function () {\n        it('should return a key pair', function () {\n          const keyPair = cosmosCoin.getKeyPair(toHex(fromBase64(testData.pubKey)));\n          should.exist(keyPair);\n        });\n      });\n\n      describe('getAddressFromPublicKey', function () {\n        it('should return the correct address', function () {\n          const address = cosmosCoin.getAddressFromPublicKey(toHex(fromBase64(testData.pubKey)));\n          should.equal(address, testData.senderAddress);\n        });\n      });\n\n      describe('Address Validation', () => {\n        it('should get address details without memoId', function () {\n          const addressDetails = cosmosCoin.getAddressDetails(testData.addresses.noMemoIdAddress);\n          addressDetails.address.should.equal(testData.addresses.noMemoIdAddress);\n          should.not.exist(addressDetails.memoId);\n        });\n\n        it('should get address details with memoId', function () {\n          const addressDetails = cosmosCoin.getAddressDetails(testData.addresses.validMemoIdAddress);\n          addressDetails.address.should.equal(testData.addresses.validMemoIdAddress.split('?')[0]);\n          if (addressDetails.memoId) {\n            addressDetails.memoId.should.equal('2');\n          } else {\n            should.fail('Expected memoId to be defined', null);\n          }\n        });\n\n        it('should throw on invalid memo id address', () => {\n          (() => {\n            cosmosCoin.getAddressDetails(testData.addresses.invalidMemoIdAddress);\n          }).should.throw();\n        });\n\n        it('should throw on multiple memo id address', () => {\n          (() => {\n            cosmosCoin.getAddressDetails(testData.addresses.multipleMemoIdAddress);\n          }).should.throw();\n        });\n\n        it('should validate wallet receive address', async function () {\n          const receiveAddress = {\n            address: `${testData.addresses.address1}?memoId=7`,\n            coinSpecific: {\n              rootAddress: testData.addresses.address1,\n              memoID: '7',\n            },\n          };\n          // as VerifyTransactionOptions\n          const isValid = await cosmosCoin.isWalletAddress(receiveAddress as VerifyAddressOptions);\n          isValid.should.equal(true);\n        });\n\n        it('should validate account addresses correctly', () => {\n          should.equal(utils.isValidAddress(testData.addresses.address1), true);\n          should.equal(utils.isValidAddress(testData.addresses.address2), true);\n          should.equal(utils.isValidAddress('dfjk35y'), false);\n          should.equal(utils.isValidAddress(undefined as unknown as string), false);\n          should.equal(utils.isValidAddress(''), false);\n          should.equal(utils.isValidAddress(testData.addresses.validMemoIdAddress), true);\n          should.equal(utils.isValidAddress(testData.addresses.invalidMemoIdAddress), false);\n          should.equal(utils.isValidAddress(testData.addresses.multipleMemoIdAddress), false);\n        });\n\n        it('should validate validator addresses correctly', () => {\n          should.equal(utils.isValidValidatorAddress(testData.addresses.validatorAddress1), true);\n          should.equal(utils.isValidValidatorAddress(testData.addresses.validatorAddress2), true);\n          should.equal(utils.isValidValidatorAddress('dfjk35y'), false);\n          should.equal(utils.isValidValidatorAddress(undefined as unknown as string), false);\n          should.equal(utils.isValidValidatorAddress(''), false);\n        });\n      });\n\n      describe('Verify transaction: ', () => {\n        it('should succeed to verify transaction', async function () {\n          const txPrebuild = {\n            txHex: testTx.signedTxBase64,\n            txInfo: {},\n          };\n          const txParams = {\n            recipients: [\n              {\n                address: testTx.recipient,\n                amount: testTx.sendAmount,\n              },\n            ],\n          };\n          const verification = {};\n          const isTransactionVerified = await cosmosCoin.verifyTransaction({\n            txParams,\n            txPrebuild,\n            verification,\n          } as VerifyTransactionOptions);\n          isTransactionVerified.should.equal(true);\n        });\n\n        it('should succeed to verify sendMany transaction', async function () {\n          const txPrebuild = {\n            txHex: testTx.signedTxBase64,\n            txInfo: {},\n          };\n          const txParams = {\n            recipients: [\n              {\n                address: testTx.recipient,\n                amount: testTx.sendAmount,\n              },\n            ],\n          };\n          const verification = {};\n          const isTransactionVerified = await cosmosCoin.verifyTransaction({\n            txParams,\n            txPrebuild,\n            verification,\n          } as VerifyTransactionOptions);\n          isTransactionVerified.should.equal(true);\n        });\n\n        it('should fail to verify transaction with invalid param', async function () {\n          const txPrebuild = {};\n          const txParams = { recipients: undefined };\n          await cosmosCoin\n            .verifyTransaction({ txParams, txPrebuild } as VerifyTransactionOptions)\n            .should.be.rejectedWith('missing required tx prebuild property txHex');\n        });\n      });\n\n      describe('Explain Transaction: ', () => {\n        it('should explain a transfer transaction', async function () {\n          const explainedTransaction = await cosmosCoin.explainTransaction({\n            txHex: testTx.signedTxBase64,\n          });\n          explainedTransaction.should.deepEqual({\n            displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'],\n            id: testTx.hash,\n            outputs: [\n              {\n                address: testTx.recipient,\n                amount: testTx.sendAmount,\n              },\n            ],\n            outputAmount: testTx.sendAmount,\n            changeOutputs: [],\n            changeAmount: '0',\n            fee: { fee: testTx.feeAmount },\n            type: 0,\n          });\n        });\n\n        it('should explain a transfer transaction with memo', async function () {\n          const explainedTransaction = await cosmosCoin.explainTransaction({\n            txHex: testTxWithMemo.signedTxBase64,\n          });\n          explainedTransaction.should.deepEqual({\n            displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'],\n            id: testTxWithMemo.hash,\n            outputs: [\n              {\n                address: testTxWithMemo.recipient,\n                amount: testTxWithMemo.sendAmount,\n                memo: testTxWithMemo.memo,\n              },\n            ],\n            outputAmount: testTxWithMemo.sendAmount,\n            changeOutputs: [],\n            changeAmount: '0',\n            fee: { fee: testTxWithMemo.feeAmount },\n            type: 0,\n          });\n        });\n\n        it('should fail to explain transaction with missing params', async function () {\n          try {\n            await cosmosCoin.explainTransaction({ txHex: '' });\n          } catch (error) {\n            should.equal(error.message, 'missing required txHex parameter');\n          }\n        });\n\n        it('should fail to explain transaction with invalid params', async function () {\n          try {\n            await cosmosCoin.explainTransaction({ txHex: 'randomString' });\n          } catch (error) {\n            should.equal(error.message.startsWith('Invalid transaction:'), true);\n          }\n        });\n      });\n\n      describe('Parse Transactions: ', () => {\n        const transferInputsResponse = {\n          address: testTx.recipient,\n          amount: new BigNumber(testTx.sendAmount).plus(testTx.feeAmount).toFixed(),\n        };\n\n        const transferOutputsResponse = {\n          address: testTx.recipient,\n          amount: testTx.sendAmount,\n        };\n\n        it('should parse a transfer transaction', async function () {\n          const parsedTransaction = await cosmosCoin.parseTransaction({ txHex: testTx.signedTxBase64 });\n\n          parsedTransaction.should.deepEqual({\n            inputs: [transferInputsResponse],\n            outputs: [transferOutputsResponse],\n          });\n        });\n\n        it('should fail to parse a transfer transaction when explainTransaction response is undefined', async function () {\n          const stub = sinon.stub(CosmosSharedCoin.prototype, 'explainTransaction');\n          stub.resolves(undefined);\n          await cosmosCoin\n            .parseTransaction({ txHex: testTx.signedTxBase64 })\n            .should.be.rejectedWith('Invalid transaction');\n          stub.restore();\n        });\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/keyPair.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=keyPair.d.ts.map

package/dist/test/unit/keyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":""}