@bitgo-beta/sdk-api 1.10.1-beta.150 → 1.10.1-beta.1500

package/dist/test/unit/bitgoAPI.js

@@ -0,0 +1,477 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const bitgoAPI_1 = require("../../src/bitgoAPI");
+const proxy_agent_1 = require("proxy-agent");
+const sinon = __importStar(require("sinon"));
+const nock_1 = __importDefault(require("nock"));
+describe('Constructor', function () {
+    describe('cookiesPropagationEnabled argument', function () {
+        it('cookiesPropagationEnabled is enabled explicitly', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                cookiesPropagationEnabled: true,
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(true);
+        });
+        it('cookiesPropagationEnabled is disabled explicitly', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                cookiesPropagationEnabled: false,
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(false);
+        });
+        it('cookiesPropagationEnabled is disabled by default', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            bitgo.should.have.property('cookiesPropagationEnabled');
+            bitgo.cookiesPropagationEnabled.should.equal(false);
+        });
+    });
+    describe('requestIdPrefix argument', function () {
+        afterEach(function () {
+            nock_1.default.cleanAll();
+        });
+        it('should prepend requestIdPrefix to Request-ID header when set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: 'test-prefix-',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', /^test-prefix-/)
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => '12345',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should not modify Request-ID header when requestIdPrefix is not set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', /^12345$/)
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => '12345',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should correctly format Request-ID with prefix and numeric sequence', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: 'myapp-v1-',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', 'myapp-v1-trace-123')
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => 'trace-123',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+        it('should work with empty string prefix', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                requestIdPrefix: '',
+            });
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/ping')
+                .matchHeader('Request-ID', 'abc-123')
+                .reply(200, { status: 'ok' });
+            await bitgo.ping({
+                reqId: {
+                    toString: () => 'abc-123',
+                    inc: () => {
+                        /* mock */
+                    },
+                },
+            });
+            scope.isDone().should.be.true();
+        });
+    });
+    describe('http proxy agent', function () {
+        it('http proxy agent shall be created when proxy(customProxyagent) is set', function () {
+            const customProxyAgent = new proxy_agent_1.ProxyAgent({
+                getProxyForUrl: () => 'http://localhost:3000',
+            });
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                customProxyAgent,
+            });
+            bitgo.should.have.property('_customProxyAgent', customProxyAgent);
+        });
+        it('bitgo api is still initiated when proxy(customProxyAgent) is not set', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            bitgo.should.have.property('_customProxyAgent', undefined);
+        });
+    });
+    describe('verifyAddress', function () {
+        it('should successfully verify a base58 address', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+            });
+            bitgo.verifyAddress({ address: '2N6paT2TU4N1XpaZjJiApWJXoeyrL3UWpkZ' }).should.be.true();
+        });
+        it('should successfully verify a bech32 address', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+            });
+            bitgo
+                .verifyAddress({ address: 'tb1qguzyk4w6kaqtpsczs5aj0w8r7598jq36egm8e98wqph3rwmex68seslgsg' })
+                .should.be.true();
+        });
+    });
+    describe('url', function () {
+        it('should return the correct URL for version 1', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';
+            const result = bitgo.url(path, 1);
+            result.should.equal(expectedUrl);
+        });
+        it('should return the correct URL for version 2', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v2/test-path';
+            const result = bitgo.url(path, 2);
+            result.should.equal(expectedUrl);
+        });
+        it('should return the correct URL for version 3', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v3/test-path';
+            const result = bitgo.url(path, 3);
+            result.should.equal(expectedUrl);
+        });
+        it('should default to version 1 if no version is provided', function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+                customRootURI: 'https://test.bitgo.com',
+            });
+            const path = '/test-path';
+            const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';
+            const result = bitgo.url(path);
+            result.should.equal(expectedUrl);
+        });
+    });
+    describe('decryptKeys', function () {
+        let bitgo;
+        beforeEach(function () {
+            bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'test',
+            });
+        });
+        afterEach(function () {
+            sinon.restore();
+        });
+        it('should throw if no params are provided', function () {
+            try {
+                // @ts-expect-error - intentionally calling with no params for test
+                bitgo.decryptKeys();
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.containEql('Missing parameter');
+            }
+        });
+        it('should throw if walletIdEncryptedKeyPairs is missing', function () {
+            try {
+                // @ts-expect-error - intentionally missing required param
+                bitgo.decryptKeys({ password: 'password123' });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.containEql('Missing parameter: walletIdEncryptedKeyPairs');
+            }
+        });
+        it('should throw if password is missing', function () {
+            try {
+                // @ts-expect-error - intentionally missing required param
+                bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [] });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.containEql('Missing parameter: password');
+            }
+        });
+        it('should throw if walletIdEncryptedKeyPairs is not an array', function () {
+            try {
+                // @ts-expect-error - intentionally providing wrong type
+                bitgo.decryptKeys({ walletIdEncryptedKeyPairs: 'not an array', password: 'password123' });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.equal('walletIdEncryptedKeyPairs must be an array');
+            }
+        });
+        it('should return empty array for empty walletIdEncryptedKeyPairs', function () {
+            const result = bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [], password: 'password123' });
+            result.should.be.an.Array();
+            result.should.be.empty();
+        });
+        it('should throw if any walletId is missing or not a string', function () {
+            try {
+                bitgo.decryptKeys({
+                    walletIdEncryptedKeyPairs: [
+                        // @ts-expect-error - intentionally missing walletId
+                        {
+                            encryptedPrv: 'encrypted-data',
+                        },
+                    ],
+                    password: 'password123',
+                });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.equal('each key pair must have a string walletId');
+            }
+            try {
+                bitgo.decryptKeys({
+                    walletIdEncryptedKeyPairs: [
+                        {
+                            // @ts-expect-error - intentionally providing wrong type
+                            walletId: 123,
+                            encryptedPrv: 'encrypted-data',
+                        },
+                    ],
+                    password: 'password123',
+                });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.equal('each key pair must have a string walletId');
+            }
+        });
+        it('should throw if any encryptedPrv is missing or not a string', function () {
+            try {
+                bitgo.decryptKeys({
+                    walletIdEncryptedKeyPairs: [
+                        // @ts-expect-error - intentionally missing encryptedPrv
+                        {
+                            walletId: 'wallet-id-1',
+                        },
+                    ],
+                    password: 'password123',
+                });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.equal('each key pair must have a string encryptedPrv');
+            }
+            try {
+                bitgo.decryptKeys({
+                    walletIdEncryptedKeyPairs: [
+                        {
+                            walletId: 'wallet-id-1',
+                            // @ts-expect-error - intentionally providing wrong type
+                            encryptedPrv: 123,
+                        },
+                    ],
+                    password: 'password123',
+                });
+                throw new Error('Expected error but got none');
+            }
+            catch (e) {
+                e.message.should.equal('each key pair must have a string encryptedPrv');
+            }
+        });
+        it('should return walletIds of keys that failed to decrypt', function () {
+            // Create a stub for the decrypt method
+            const decryptStub = sinon.stub(bitgo, 'decrypt');
+            // Make it succeed for first wallet and fail for second wallet
+            decryptStub.onFirstCall().returns('decrypted-key-1');
+            decryptStub.onSecondCall().throws(new Error('decryption failed'));
+            const result = bitgo.decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },
+                    { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },
+                ],
+                password: 'password123',
+            });
+            result.should.be.an.Array();
+            result.should.have.length(1);
+            result[0].should.equal('wallet-id-2');
+        });
+        it('should correctly process multiple wallet keys', function () {
+            // Create a spy on the decrypt method
+            const decryptStub = sinon.stub(bitgo, 'decrypt');
+            // Configure the stub to throw for specific wallets
+            decryptStub
+                .withArgs({ input: 'encrypted-data-2', password: 'password123' })
+                .throws(new Error('decryption failed'));
+            decryptStub
+                .withArgs({ input: 'encrypted-data-4', password: 'password123' })
+                .throws(new Error('decryption failed'));
+            decryptStub.returns('success'); // Default return for other calls
+            const result = bitgo.decryptKeys({
+                walletIdEncryptedKeyPairs: [
+                    { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },
+                    { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },
+                    { walletId: 'wallet-id-3', encryptedPrv: 'encrypted-data-3' },
+                    { walletId: 'wallet-id-4', encryptedPrv: 'encrypted-data-4' },
+                ],
+                password: 'password123',
+            });
+            // Should be called once for each wallet
+            decryptStub.callCount.should.equal(4);
+            // Should include only the failed wallet IDs
+            result.should.be.an.Array();
+            result.should.have.length(2);
+            result.should.containDeep(['wallet-id-2', 'wallet-id-4']);
+        });
+    });
+    describe('constants parameter', function () {
+        it('should allow passing constants via options and expose via fetchConstants', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+                clientConstants: { maxFeeRate: '123123123123123' },
+            });
+            const constants = await bitgo.fetchConstants();
+            constants.should.have.property('maxFeeRate', '123123123123123');
+        });
+        it('should refresh constants when cache has expired', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with an expired cache
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = { maxFeeRate: 'old-value' };
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = new Date(Date.now() - 1000); // Expired 1 second ago
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, {
+                constants: { maxFeeRate: 'new-value', newConstant: 'added' },
+            });
+            const constants = await bitgo.fetchConstants();
+            // Should return the new constants from the server
+            constants.should.have.property('maxFeeRate', 'new-value');
+            constants.should.have.property('newConstant', 'added');
+            scope.isDone().should.be.true();
+            nock_1.default.cleanAll();
+        });
+        it('should use cached constants when cache is still valid', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with a future expiry
+            const cachedConstants = { maxFeeRate: 'cached-value', anotherSetting: 'cached-setting' };
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = cachedConstants;
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = new Date(Date.now() + 5 * 60 * 1000); // Valid for 5 more minutes
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, { constants: { shouldNotBeUsed: true } });
+            const constants = await bitgo.fetchConstants();
+            // Should return the cached constants
+            constants.should.deepEqual(cachedConstants);
+            // Verify that no HTTP request was made (since cache was valid)
+            scope.isDone().should.be.false();
+            nock_1.default.cleanAll();
+        });
+        it('should use cached constants when no cache expiry is set', async function () {
+            const bitgo = new bitgoAPI_1.BitGoAPI({
+                env: 'custom',
+                customRootURI: 'https://app.example.local',
+            });
+            // Set up cached constants with no expiry
+            const cachedConstants = { maxFeeRate: 'no-expiry-value' };
+            bitgoAPI_1.BitGoAPI._constants = bitgoAPI_1.BitGoAPI._constants || {};
+            bitgoAPI_1.BitGoAPI._constantsExpire = bitgoAPI_1.BitGoAPI._constantsExpire || {};
+            bitgoAPI_1.BitGoAPI._constants['custom'] = cachedConstants;
+            bitgoAPI_1.BitGoAPI._constantsExpire['custom'] = undefined;
+            const scope = (0, nock_1.default)('https://app.example.local')
+                .get('/api/v1/client/constants')
+                .reply(200, { constants: { shouldNotBeUsed: true } });
+            const constants = await bitgo.fetchConstants();
+            // Should return the cached constants
+            constants.should.deepEqual(cachedConstants);
+            // Verify that no HTTP request was made (since no expiry means cache is always valid)
+            scope.isDone().should.be.false();
+            nock_1.default.cleanAll();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bitgoAPI.js","sourceRoot":"","sources":["../../../test/unit/bitgoAPI.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { BitGoAPI } from '../../src/bitgoAPI';\nimport { ProxyAgent } from 'proxy-agent';\nimport * as sinon from 'sinon';\nimport nock from 'nock';\n\ndescribe('Constructor', function () {\n  describe('cookiesPropagationEnabled argument', function () {\n    it('cookiesPropagationEnabled is enabled explicitly', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        cookiesPropagationEnabled: true,\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(true);\n    });\n\n    it('cookiesPropagationEnabled is disabled explicitly', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        cookiesPropagationEnabled: false,\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(false);\n    });\n\n    it('cookiesPropagationEnabled is disabled by default', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      bitgo.should.have.property('cookiesPropagationEnabled');\n      bitgo.cookiesPropagationEnabled.should.equal(false);\n    });\n  });\n\n  describe('requestIdPrefix argument', function () {\n    afterEach(function () {\n      nock.cleanAll();\n    });\n\n    it('should prepend requestIdPrefix to Request-ID header when set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: 'test-prefix-',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', /^test-prefix-/)\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => '12345',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should not modify Request-ID header when requestIdPrefix is not set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', /^12345$/)\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => '12345',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should correctly format Request-ID with prefix and numeric sequence', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: 'myapp-v1-',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', 'myapp-v1-trace-123')\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => 'trace-123',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n\n    it('should work with empty string prefix', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        requestIdPrefix: '',\n      });\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/ping')\n        .matchHeader('Request-ID', 'abc-123')\n        .reply(200, { status: 'ok' });\n\n      await bitgo.ping({\n        reqId: {\n          toString: () => 'abc-123',\n          inc: () => {\n            /* mock */\n          },\n        } as any,\n      });\n\n      scope.isDone().should.be.true();\n    });\n  });\n  describe('http proxy agent', function () {\n    it('http proxy agent shall be created when proxy(customProxyagent) is set', function () {\n      const customProxyAgent = new ProxyAgent({\n        getProxyForUrl: () => 'http://localhost:3000',\n      });\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        customProxyAgent,\n      });\n\n      bitgo.should.have.property('_customProxyAgent', customProxyAgent);\n    });\n\n    it('bitgo api is still initiated when proxy(customProxyAgent) is not set', function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      bitgo.should.have.property('_customProxyAgent', undefined);\n    });\n  });\n\n  describe('verifyAddress', function () {\n    it('should successfully verify a base58 address', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n      });\n\n      bitgo.verifyAddress({ address: '2N6paT2TU4N1XpaZjJiApWJXoeyrL3UWpkZ' }).should.be.true();\n    });\n\n    it('should successfully verify a bech32 address', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n      });\n\n      bitgo\n        .verifyAddress({ address: 'tb1qguzyk4w6kaqtpsczs5aj0w8r7598jq36egm8e98wqph3rwmex68seslgsg' })\n        .should.be.true();\n    });\n  });\n\n  describe('url', function () {\n    it('should return the correct URL for version 1', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';\n      const result = bitgo.url(path, 1);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should return the correct URL for version 2', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v2/test-path';\n      const result = bitgo.url(path, 2);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should return the correct URL for version 3', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v3/test-path';\n      const result = bitgo.url(path, 3);\n      result.should.equal(expectedUrl);\n    });\n\n    it('should default to version 1 if no version is provided', function () {\n      const bitgo = new BitGoAPI({\n        env: 'test',\n        customRootURI: 'https://test.bitgo.com',\n      });\n      const path = '/test-path';\n      const expectedUrl = 'https://test.bitgo.com/api/v1/test-path';\n      const result = bitgo.url(path);\n      result.should.equal(expectedUrl);\n    });\n  });\n\n  describe('decryptKeys', function () {\n    let bitgo: BitGoAPI;\n\n    beforeEach(function () {\n      bitgo = new BitGoAPI({\n        env: 'test',\n      });\n    });\n\n    afterEach(function () {\n      sinon.restore();\n    });\n\n    it('should throw if no params are provided', function () {\n      try {\n        // @ts-expect-error - intentionally calling with no params for test\n        bitgo.decryptKeys();\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.containEql('Missing parameter');\n      }\n    });\n\n    it('should throw if walletIdEncryptedKeyPairs is missing', function () {\n      try {\n        // @ts-expect-error - intentionally missing required param\n        bitgo.decryptKeys({ password: 'password123' });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.containEql('Missing parameter: walletIdEncryptedKeyPairs');\n      }\n    });\n\n    it('should throw if password is missing', function () {\n      try {\n        // @ts-expect-error - intentionally missing required param\n        bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [] });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.containEql('Missing parameter: password');\n      }\n    });\n\n    it('should throw if walletIdEncryptedKeyPairs is not an array', function () {\n      try {\n        // @ts-expect-error - intentionally providing wrong type\n        bitgo.decryptKeys({ walletIdEncryptedKeyPairs: 'not an array', password: 'password123' });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.equal('walletIdEncryptedKeyPairs must be an array');\n      }\n    });\n\n    it('should return empty array for empty walletIdEncryptedKeyPairs', function () {\n      const result = bitgo.decryptKeys({ walletIdEncryptedKeyPairs: [], password: 'password123' });\n      result.should.be.an.Array();\n      result.should.be.empty();\n    });\n\n    it('should throw if any walletId is missing or not a string', function () {\n      try {\n        bitgo.decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally missing walletId\n            {\n              encryptedPrv: 'encrypted-data',\n            },\n          ],\n          password: 'password123',\n        });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.equal('each key pair must have a string walletId');\n      }\n\n      try {\n        bitgo.decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            {\n              // @ts-expect-error - intentionally providing wrong type\n              walletId: 123,\n              encryptedPrv: 'encrypted-data',\n            },\n          ],\n          password: 'password123',\n        });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.equal('each key pair must have a string walletId');\n      }\n    });\n\n    it('should throw if any encryptedPrv is missing or not a string', function () {\n      try {\n        bitgo.decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            // @ts-expect-error - intentionally missing encryptedPrv\n            {\n              walletId: 'wallet-id-1',\n            },\n          ],\n          password: 'password123',\n        });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.equal('each key pair must have a string encryptedPrv');\n      }\n\n      try {\n        bitgo.decryptKeys({\n          walletIdEncryptedKeyPairs: [\n            {\n              walletId: 'wallet-id-1',\n              // @ts-expect-error - intentionally providing wrong type\n              encryptedPrv: 123,\n            },\n          ],\n          password: 'password123',\n        });\n        throw new Error('Expected error but got none');\n      } catch (e) {\n        e.message.should.equal('each key pair must have a string encryptedPrv');\n      }\n    });\n\n    it('should return walletIds of keys that failed to decrypt', function () {\n      // Create a stub for the decrypt method\n      const decryptStub = sinon.stub(bitgo, 'decrypt');\n\n      // Make it succeed for first wallet and fail for second wallet\n      decryptStub.onFirstCall().returns('decrypted-key-1');\n      decryptStub.onSecondCall().throws(new Error('decryption failed'));\n\n      const result = bitgo.decryptKeys({\n        walletIdEncryptedKeyPairs: [\n          { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },\n          { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },\n        ],\n        password: 'password123',\n      });\n\n      result.should.be.an.Array();\n      result.should.have.length(1);\n      result[0].should.equal('wallet-id-2');\n    });\n\n    it('should correctly process multiple wallet keys', function () {\n      // Create a spy on the decrypt method\n      const decryptStub = sinon.stub(bitgo, 'decrypt');\n\n      // Configure the stub to throw for specific wallets\n      decryptStub\n        .withArgs({ input: 'encrypted-data-2', password: 'password123' })\n        .throws(new Error('decryption failed'));\n      decryptStub\n        .withArgs({ input: 'encrypted-data-4', password: 'password123' })\n        .throws(new Error('decryption failed'));\n      decryptStub.returns('success'); // Default return for other calls\n\n      const result = bitgo.decryptKeys({\n        walletIdEncryptedKeyPairs: [\n          { walletId: 'wallet-id-1', encryptedPrv: 'encrypted-data-1' },\n          { walletId: 'wallet-id-2', encryptedPrv: 'encrypted-data-2' },\n          { walletId: 'wallet-id-3', encryptedPrv: 'encrypted-data-3' },\n          { walletId: 'wallet-id-4', encryptedPrv: 'encrypted-data-4' },\n        ],\n        password: 'password123',\n      });\n\n      // Should be called once for each wallet\n      decryptStub.callCount.should.equal(4);\n\n      // Should include only the failed wallet IDs\n      result.should.be.an.Array();\n      result.should.have.length(2);\n      result.should.containDeep(['wallet-id-2', 'wallet-id-4']);\n    });\n  });\n\n  describe('constants parameter', function () {\n    it('should allow passing constants via options and expose via fetchConstants', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n        clientConstants: { maxFeeRate: '123123123123123' },\n      });\n\n      const constants = await bitgo.fetchConstants();\n      constants.should.have.property('maxFeeRate', '123123123123123');\n    });\n\n    it('should refresh constants when cache has expired', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with an expired cache\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = { maxFeeRate: 'old-value' };\n      (BitGoAPI as any)._constantsExpire['custom'] = new Date(Date.now() - 1000); // Expired 1 second ago\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, {\n          constants: { maxFeeRate: 'new-value', newConstant: 'added' },\n        });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the new constants from the server\n      constants.should.have.property('maxFeeRate', 'new-value');\n      constants.should.have.property('newConstant', 'added');\n\n      scope.isDone().should.be.true();\n\n      nock.cleanAll();\n    });\n\n    it('should use cached constants when cache is still valid', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with a future expiry\n      const cachedConstants = { maxFeeRate: 'cached-value', anotherSetting: 'cached-setting' };\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = cachedConstants;\n      (BitGoAPI as any)._constantsExpire['custom'] = new Date(Date.now() + 5 * 60 * 1000); // Valid for 5 more minutes\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, { constants: { shouldNotBeUsed: true } });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the cached constants\n      constants.should.deepEqual(cachedConstants);\n\n      // Verify that no HTTP request was made (since cache was valid)\n      scope.isDone().should.be.false();\n\n      nock.cleanAll();\n    });\n\n    it('should use cached constants when no cache expiry is set', async function () {\n      const bitgo = new BitGoAPI({\n        env: 'custom',\n        customRootURI: 'https://app.example.local',\n      });\n\n      // Set up cached constants with no expiry\n      const cachedConstants = { maxFeeRate: 'no-expiry-value' };\n      (BitGoAPI as any)._constants = (BitGoAPI as any)._constants || {};\n      (BitGoAPI as any)._constantsExpire = (BitGoAPI as any)._constantsExpire || {};\n      (BitGoAPI as any)._constants['custom'] = cachedConstants;\n      (BitGoAPI as any)._constantsExpire['custom'] = undefined;\n\n      const scope = nock('https://app.example.local')\n        .get('/api/v1/client/constants')\n        .reply(200, { constants: { shouldNotBeUsed: true } });\n\n      const constants = await bitgo.fetchConstants();\n\n      // Should return the cached constants\n      constants.should.deepEqual(cachedConstants);\n\n      // Verify that no HTTP request was made (since no expiry means cache is always valid)\n      scope.isDone().should.be.false();\n\n      nock.cleanAll();\n    });\n  });\n});\n"]}

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

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

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

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

package/dist/test/unit/encrypt.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const src_1 = require("../../src");
+describe('encryption methods tests', () => {
+    describe('encrypt', () => {
+        it('encrypts the plaintext with the given password', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const ciphertext = (0, src_1.encrypt)(password, plaintext);
+            (0, assert_1.default)(ciphertext !== plaintext, 'ciphertext should not be equal to plaintext');
+        });
+        it('returns a different ciphertext for the same plaintext and password', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const ciphertext1 = (0, src_1.encrypt)(password, plaintext);
+            const ciphertext2 = (0, src_1.encrypt)(password, plaintext);
+            (0, assert_1.default)(ciphertext1 !== ciphertext2, 'ciphertexts should not be equal');
+        });
+        it('throws an error if the salt length is not 8 bytes', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const options = { salt: (0, crypto_1.randomBytes)(4) };
+            assert_1.default.throws(() => (0, src_1.encrypt)(password, plaintext, options), new Error(`salt must be 8 bytes`));
+        });
+        it('throws an error if the iv length is not 16 bytes', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const options = { iv: (0, crypto_1.randomBytes)(4) };
+            assert_1.default.throws(() => (0, src_1.encrypt)(password, plaintext, options), new Error(`iv must be 16 bytes`));
+        });
+    });
+    describe('decrypt', () => {
+        it('decrypts the ciphertext with the given password', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const ciphertext = (0, src_1.encrypt)(password, plaintext);
+            const decrypted = (0, src_1.decrypt)(password, ciphertext);
+            (0, assert_1.default)(decrypted === plaintext, 'decrypted should be equal to plaintext');
+        });
+        it('throws an error if the password is wrong', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const ciphertext = (0, src_1.encrypt)(password, plaintext);
+            const wrongPassword = 'wrongPassword';
+            assert_1.default.throws(() => (0, src_1.decrypt)(wrongPassword, ciphertext), 'sjcl exception: cc: invalid aes key');
+        });
+        it('decrypts the ciphertext with the given password and adata', () => {
+            const password = 'myPassword';
+            const plaintext = 'Hello, World!';
+            const adata = 'additional data';
+            const ciphertext = (0, src_1.encrypt)(password, plaintext, { adata });
+            const decrypted = (0, src_1.decrypt)(password, ciphertext);
+            (0, assert_1.default)(decrypted === plaintext, 'decrypted should be equal to plaintext');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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