@bitgo-beta/sdk-core 8.2.1-beta.17 → 8.2.1-beta.1700

package/dist/test/unit/bitgo/wallet/walletsEvmKeyring.js

@@ -0,0 +1,216 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+require("should");
+const wallets_1 = require("../../../../src/bitgo/wallet/wallets");
+describe('Wallets', function () {
+    let wallets;
+    let mockBitGo;
+    let mockBaseCoin;
+    beforeEach(function () {
+        mockBitGo = {
+            post: sinon.stub(),
+            encrypt: sinon.stub(),
+            setRequestTracer: sinon.stub(),
+        };
+        mockBaseCoin = {
+            isEVM: sinon.stub(),
+            supportsTss: sinon.stub().returns(true),
+            getFamily: sinon.stub().returns('eth'),
+            getDefaultMultisigType: sinon.stub(),
+            keychains: sinon.stub(),
+            url: sinon.stub().returns('/test/url'),
+            isValidMofNSetup: sinon.stub(),
+            getConfig: sinon.stub().returns({ features: [] }),
+        };
+        wallets = new wallets_1.Wallets(mockBitGo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('EVM Keyring - generateWallet', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(true);
+            mockBaseCoin.supportsTss.returns(true);
+            mockBaseCoin.getDefaultMultisigType.returns('tss');
+        });
+        it('should create EVM wallet with evmKeyRingReferenceWalletId', async function () {
+            const mockWalletResponse = {
+                id: '597f1f77bcf86cd799439011',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            mockBaseCoin.keychains.returns({
+                get: sinon.stub().resolves({ id: 'keychain-id', pub: 'public-key' }),
+            });
+            const result = await wallets.generateWallet({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+            });
+            result.should.have.property('wallet');
+            result.should.have.property('userKeychain');
+            result.should.have.property('backupKeychain');
+            result.should.have.property('bitgoKeychain');
+        });
+        it('should throw error if evmKeyRingReferenceWalletId provided for non-EVM chain', async function () {
+            mockBaseCoin.isEVM.returns(false);
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should throw error if evmKeyRingReferenceWalletId is not a string', async function () {
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 123,
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('invalid evmKeyRingReferenceWalletId argument, expecting string');
+            }
+        });
+    });
+    describe('EVM Keyring - add method', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(true);
+        });
+        it('should add EVM wallet with evmKeyRingReferenceWalletId without multisig validation', async function () {
+            const mockWalletResponse = {
+                id: 'new-wallet-id',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            const result = await wallets.add({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: 'reference-wallet-id',
+            });
+            result.should.have.property('wallet');
+            mockBitGo.post.should.have.been.calledOnce;
+        });
+        it('should skip multisig validation for EVM wallets with evmKeyRingReferenceWalletId', async function () {
+            const mockWalletResponse = {
+                id: 'new-wallet-id',
+                keys: ['user-key', 'backup-key', 'bitgo-key'],
+            };
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletResponse),
+                }),
+            });
+            // This should not throw error even without keys, m, n parameters
+            const result = await wallets.add({
+                label: 'Test EVM Wallet',
+                evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                // No keys, m, n provided - should be fine for EVM keyring
+            });
+            result.should.have.property('wallet');
+        });
+        it('should throw error for non-EVM chains with evmKeyRingReferenceWalletId', async function () {
+            mockBaseCoin.isEVM.returns(false);
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should still validate multisig for regular wallets', async function () {
+            mockBaseCoin.isEVM.returns(true);
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    type: 'hot',
+                    // No evmKeyRingReferenceWalletId, so should require keys, m, n
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('invalid argument');
+            }
+        });
+    });
+    describe('Non-EVM chains', function () {
+        beforeEach(function () {
+            mockBaseCoin.isEVM.returns(false);
+        });
+        it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in generateWallet', async function () {
+            try {
+                await wallets.generateWallet({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 'reference-wallet-id',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+        it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in add', async function () {
+            try {
+                await wallets.add({
+                    label: 'Test Wallet',
+                    evmKeyRingReferenceWalletId: 'reference-wallet-id',
+                });
+                assert.fail('Should have thrown error');
+            }
+            catch (error) {
+                error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsEvmKeyring.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsEvmKeyring.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\n\ndescribe('Wallets', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n\n  beforeEach(function () {\n    mockBitGo = {\n      post: sinon.stub(),\n      encrypt: sinon.stub(),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub(),\n      supportsTss: sinon.stub().returns(true),\n      getFamily: sinon.stub().returns('eth'),\n      getDefaultMultisigType: sinon.stub(),\n      keychains: sinon.stub(),\n      url: sinon.stub().returns('/test/url'),\n      isValidMofNSetup: sinon.stub(),\n      getConfig: sinon.stub().returns({ features: [] }),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('EVM Keyring - generateWallet', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(true);\n      mockBaseCoin.supportsTss.returns(true);\n      mockBaseCoin.getDefaultMultisigType.returns('tss');\n    });\n\n    it('should create EVM wallet with evmKeyRingReferenceWalletId', async function () {\n      const mockWalletResponse = {\n        id: '597f1f77bcf86cd799439011',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      mockBaseCoin.keychains.returns({\n        get: sinon.stub().resolves({ id: 'keychain-id', pub: 'public-key' }),\n      } as any);\n\n      const result = await wallets.generateWallet({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n      });\n\n      result.should.have.property('wallet');\n      result.should.have.property('userKeychain');\n      result.should.have.property('backupKeychain');\n      result.should.have.property('bitgoKeychain');\n    });\n\n    it('should throw error if evmKeyRingReferenceWalletId provided for non-EVM chain', async function () {\n      mockBaseCoin.isEVM.returns(false);\n\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should throw error if evmKeyRingReferenceWalletId is not a string', async function () {\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 123 as any,\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('invalid evmKeyRingReferenceWalletId argument, expecting string');\n      }\n    });\n  });\n\n  describe('EVM Keyring - add method', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(true);\n    });\n\n    it('should add EVM wallet with evmKeyRingReferenceWalletId without multisig validation', async function () {\n      const mockWalletResponse = {\n        id: 'new-wallet-id',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      const result = await wallets.add({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: 'reference-wallet-id',\n      });\n\n      result.should.have.property('wallet');\n      mockBitGo.post.should.have.been.calledOnce;\n    });\n\n    it('should skip multisig validation for EVM wallets with evmKeyRingReferenceWalletId', async function () {\n      const mockWalletResponse = {\n        id: 'new-wallet-id',\n        keys: ['user-key', 'backup-key', 'bitgo-key'],\n      };\n\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletResponse),\n        }),\n      } as any);\n\n      // This should not throw error even without keys, m, n parameters\n      const result = await wallets.add({\n        label: 'Test EVM Wallet',\n        evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        // No keys, m, n provided - should be fine for EVM keyring\n      });\n\n      result.should.have.property('wallet');\n    });\n\n    it('should throw error for non-EVM chains with evmKeyRingReferenceWalletId', async function () {\n      mockBaseCoin.isEVM.returns(false);\n\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: '507f1f77bcf86cd799439011',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should still validate multisig for regular wallets', async function () {\n      mockBaseCoin.isEVM.returns(true);\n\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          type: 'hot',\n          // No evmKeyRingReferenceWalletId, so should require keys, m, n\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('invalid argument');\n      }\n    });\n  });\n\n  describe('Non-EVM chains', function () {\n    beforeEach(function () {\n      mockBaseCoin.isEVM.returns(false);\n    });\n\n    it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in generateWallet', async function () {\n      try {\n        await wallets.generateWallet({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 'reference-wallet-id',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n\n    it('should not allow evmKeyRingReferenceWalletId for non-EVM chains in add', async function () {\n      try {\n        await wallets.add({\n          label: 'Test Wallet',\n          evmKeyRingReferenceWalletId: 'reference-wallet-id',\n        });\n        assert.fail('Should have thrown error');\n      } catch (error) {\n        error.message.should.equal('evmKeyRingReferenceWalletId is only supported for EVM chains');\n      }\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/wallet/walletsWebauthn.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=walletsWebauthn.d.ts.map

package/dist/test/unit/bitgo/wallet/walletsWebauthn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletsWebauthn.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsWebauthn.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,CAAC"}

package/dist/test/unit/bitgo/wallet/walletsWebauthn.js

@@ -0,0 +1,197 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+require("should");
+const wallets_1 = require("../../../../src/bitgo/wallet/wallets");
+describe('Wallets - WebAuthn wallet creation', function () {
+    let wallets;
+    let mockBitGo;
+    let mockBaseCoin;
+    let mockKeychains;
+    const userPrv = 'xprvSomeUserPrivateKey';
+    const userPub = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+    const backupPub = 'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';
+    const bitgoPub = 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';
+    beforeEach(function () {
+        mockKeychains = {
+            create: sinon.stub().returns({ pub: userPub, prv: userPrv }),
+            add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),
+            createBackup: sinon.stub().resolves({ id: 'backup-key-id', pub: backupPub }),
+            createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),
+        };
+        const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };
+        mockBitGo = {
+            post: sinon.stub().returns({
+                send: sinon.stub().returns({
+                    result: sinon.stub().resolves(mockWalletData),
+                }),
+            }),
+            encrypt: sinon
+                .stub()
+                .callsFake(({ password, input }) => `encrypted:${password}:${input}`),
+            setRequestTracer: sinon.stub(),
+        };
+        mockBaseCoin = {
+            isEVM: sinon.stub().returns(false),
+            supportsTss: sinon.stub().returns(false),
+            getFamily: sinon.stub().returns('btc'),
+            getDefaultMultisigType: sinon.stub().returns('onchain'),
+            keychains: sinon.stub().returns(mockKeychains),
+            url: sinon.stub().returns('/test/url'),
+            isValidMofNSetup: sinon.stub().returns(true),
+            getConfig: sinon.stub().returns({ features: [] }),
+            supplementGenerateWallet: sinon.stub().callsFake((params) => Promise.resolve(params)),
+            signMessage: sinon.stub().resolves(Buffer.from('aabbcc', 'hex')),
+        };
+        wallets = new wallets_1.Wallets(mockBitGo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('generateWallet with webauthnInfo', function () {
+        it('should add webauthnDevices to keychain params when webauthnInfo is provided', async function () {
+            const webauthnInfo = {
+                otpDeviceId: 'device-123',
+                prfSalt: 'salt-abc',
+                passphrase: 'prf-derived-passphrase',
+            };
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: 'wallet-passphrase',
+                webauthnInfo,
+            });
+            assert.strictEqual(mockKeychains.add.calledOnce, true);
+            const addParams = mockKeychains.add.firstCall.args[0];
+            addParams.should.have.property('webauthnDevices');
+            addParams.webauthnDevices.should.have.length(1);
+            addParams.webauthnDevices[0].should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);
+            addParams.webauthnDevices[0].should.have.property('prfSalt', webauthnInfo.prfSalt);
+            addParams.webauthnDevices[0].should.have.property('encryptedPrv');
+        });
+        it('should encrypt user private key with the webauthn passphrase', async function () {
+            const webauthnPassphrase = 'prf-derived-passphrase';
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: 'wallet-passphrase',
+                webauthnInfo: {
+                    otpDeviceId: 'device-123',
+                    prfSalt: 'salt-abc',
+                    passphrase: webauthnPassphrase,
+                },
+            });
+            const addParams = mockKeychains.add.firstCall.args[0];
+            const expectedEncryptedPrv = `encrypted:${webauthnPassphrase}:${userPrv}`;
+            addParams.webauthnDevices[0].should.have.property('encryptedPrv', expectedEncryptedPrv);
+        });
+        it('should also encrypt user private key with wallet passphrase when webauthnInfo is provided', async function () {
+            const walletPassphrase = 'wallet-passphrase';
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: walletPassphrase,
+                webauthnInfo: {
+                    otpDeviceId: 'device-123',
+                    prfSalt: 'salt-abc',
+                    passphrase: 'prf-derived-passphrase',
+                },
+            });
+            const addParams = mockKeychains.add.firstCall.args[0];
+            const expectedEncryptedPrv = `encrypted:${walletPassphrase}:${userPrv}`;
+            addParams.should.have.property('encryptedPrv', expectedEncryptedPrv);
+        });
+        it('should use separate encrypt calls for wallet passphrase and webauthn passphrase', async function () {
+            const walletPassphrase = 'wallet-passphrase';
+            const webauthnPassphrase = 'prf-derived-passphrase';
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: walletPassphrase,
+                webauthnInfo: {
+                    otpDeviceId: 'device-123',
+                    prfSalt: 'salt-abc',
+                    passphrase: webauthnPassphrase,
+                },
+            });
+            const encryptCalls = mockBitGo.encrypt.getCalls();
+            const passwordsUsed = encryptCalls.map((call) => call.args[0].password);
+            passwordsUsed.should.containEql(walletPassphrase);
+            passwordsUsed.should.containEql(webauthnPassphrase);
+        });
+        it('should not add webauthnDevices when webauthnInfo is not provided', async function () {
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: 'wallet-passphrase',
+            });
+            assert.strictEqual(mockKeychains.add.calledOnce, true);
+            const addParams = mockKeychains.add.firstCall.args[0];
+            addParams.should.not.have.property('webauthnDevices');
+        });
+        it('should not add webauthnDevices when userKey is explicitly provided (no prv available)', async function () {
+            // When a user-provided public key is used, there is no private key to encrypt, so webauthnDevices is skipped
+            await wallets.generateWallet({
+                label: 'Test Wallet',
+                userKey: userPub,
+                backupXpub: backupPub,
+                webauthnInfo: {
+                    otpDeviceId: 'device-123',
+                    prfSalt: 'salt-abc',
+                    passphrase: 'prf-derived-passphrase',
+                },
+            });
+            // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnDevices
+            const allAddCalls = mockKeychains.add.getCalls();
+            assert.ok(allAddCalls.length > 0, 'expected keychains().add to be called at least once');
+            for (const call of allAddCalls) {
+                call.args[0].should.not.have.property('webauthnDevices');
+            }
+        });
+        it('should return wallet with keychains when webauthnInfo is provided', async function () {
+            const result = await wallets.generateWallet({
+                label: 'Test Wallet',
+                passphrase: 'wallet-passphrase',
+                webauthnInfo: {
+                    otpDeviceId: 'device-123',
+                    prfSalt: 'salt-abc',
+                    passphrase: 'prf-derived-passphrase',
+                },
+            });
+            result.should.have.property('wallet');
+            result.should.have.property('userKeychain');
+            result.should.have.property('backupKeychain');
+            result.should.have.property('bitgoKeychain');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletsWebauthn.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/walletsWebauthn.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport 'should';\nimport { Wallets } from '../../../../src/bitgo/wallet/wallets';\n\ndescribe('Wallets - WebAuthn wallet creation', function () {\n  let wallets: Wallets;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let mockKeychains: any;\n\n  const userPrv = 'xprvSomeUserPrivateKey';\n  const userPub =\n    'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\n  const backupPub =\n    'xpub661MyMwAqRbcGczjuMoRm6dXaLDEhW1u34gKenbeYqAix21mdUKJyuyu5F1rzYGVxyL6tmgBUAEPrEz92mBXjByMRiJdba9wpnN37RLLAXa';\n  const bitgoPub =\n    'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm';\n\n  beforeEach(function () {\n    mockKeychains = {\n      create: sinon.stub().returns({ pub: userPub, prv: userPrv }),\n      add: sinon.stub().resolves({ id: 'user-key-id', pub: userPub, encryptedPrv: 'encrypted-prv' }),\n      createBackup: sinon.stub().resolves({ id: 'backup-key-id', pub: backupPub }),\n      createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', pub: bitgoPub }),\n    };\n\n    const mockWalletData = { id: 'wallet-id', keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'] };\n\n    mockBitGo = {\n      post: sinon.stub().returns({\n        send: sinon.stub().returns({\n          result: sinon.stub().resolves(mockWalletData),\n        }),\n      }),\n      encrypt: sinon\n        .stub()\n        .callsFake(({ password, input }: { password: string; input: string }) => `encrypted:${password}:${input}`),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      isEVM: sinon.stub().returns(false),\n      supportsTss: sinon.stub().returns(false),\n      getFamily: sinon.stub().returns('btc'),\n      getDefaultMultisigType: sinon.stub().returns('onchain'),\n      keychains: sinon.stub().returns(mockKeychains),\n      url: sinon.stub().returns('/test/url'),\n      isValidMofNSetup: sinon.stub().returns(true),\n      getConfig: sinon.stub().returns({ features: [] }),\n      supplementGenerateWallet: sinon.stub().callsFake((params: any) => Promise.resolve(params)),\n      signMessage: sinon.stub().resolves(Buffer.from('aabbcc', 'hex')),\n    };\n\n    wallets = new Wallets(mockBitGo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('generateWallet with webauthnInfo', function () {\n    it('should add webauthnDevices to keychain params when webauthnInfo is provided', async function () {\n      const webauthnInfo = {\n        otpDeviceId: 'device-123',\n        prfSalt: 'salt-abc',\n        passphrase: 'prf-derived-passphrase',\n      };\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo,\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.have.property('webauthnDevices');\n      addParams.webauthnDevices.should.have.length(1);\n      addParams.webauthnDevices[0].should.have.property('otpDeviceId', webauthnInfo.otpDeviceId);\n      addParams.webauthnDevices[0].should.have.property('prfSalt', webauthnInfo.prfSalt);\n      addParams.webauthnDevices[0].should.have.property('encryptedPrv');\n    });\n\n    it('should encrypt user private key with the webauthn passphrase', async function () {\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${webauthnPassphrase}:${userPrv}`;\n      addParams.webauthnDevices[0].should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should also encrypt user private key with wallet passphrase when webauthnInfo is provided', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      const addParams = mockKeychains.add.firstCall.args[0];\n      const expectedEncryptedPrv = `encrypted:${walletPassphrase}:${userPrv}`;\n      addParams.should.have.property('encryptedPrv', expectedEncryptedPrv);\n    });\n\n    it('should use separate encrypt calls for wallet passphrase and webauthn passphrase', async function () {\n      const walletPassphrase = 'wallet-passphrase';\n      const webauthnPassphrase = 'prf-derived-passphrase';\n\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: walletPassphrase,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: webauthnPassphrase,\n        },\n      });\n\n      const encryptCalls = mockBitGo.encrypt.getCalls();\n      const passwordsUsed = encryptCalls.map((call: sinon.SinonSpyCall) => call.args[0].password);\n      passwordsUsed.should.containEql(walletPassphrase);\n      passwordsUsed.should.containEql(webauthnPassphrase);\n    });\n\n    it('should not add webauthnDevices when webauthnInfo is not provided', async function () {\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n      });\n\n      assert.strictEqual(mockKeychains.add.calledOnce, true);\n      const addParams = mockKeychains.add.firstCall.args[0];\n      addParams.should.not.have.property('webauthnDevices');\n    });\n\n    it('should not add webauthnDevices when userKey is explicitly provided (no prv available)', async function () {\n      // When a user-provided public key is used, there is no private key to encrypt, so webauthnDevices is skipped\n      await wallets.generateWallet({\n        label: 'Test Wallet',\n        userKey: userPub,\n        backupXpub: backupPub,\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      // add is called for both user keychain (pub-only) and backup keychain - neither should have webauthnDevices\n      const allAddCalls = mockKeychains.add.getCalls();\n      assert.ok(allAddCalls.length > 0, 'expected keychains().add to be called at least once');\n      for (const call of allAddCalls) {\n        call.args[0].should.not.have.property('webauthnDevices');\n      }\n    });\n\n    it('should return wallet with keychains when webauthnInfo is provided', async function () {\n      const result = await wallets.generateWallet({\n        label: 'Test Wallet',\n        passphrase: 'wallet-passphrase',\n        webauthnInfo: {\n          otpDeviceId: 'device-123',\n          prfSalt: 'salt-abc',\n          passphrase: 'prf-derived-passphrase',\n        },\n      });\n\n      result.should.have.property('wallet');\n      result.should.have.property('userKeychain');\n      result.should.have.property('backupKeychain');\n      result.should.have.property('bitgoKeychain');\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=lightning.d.ts.map

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

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

package/dist/test/unit/lightning.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const lightning_1 = require("../../src/lightning");
+describe('lightning', () => {
+    describe('isBolt11Invoice', () => {
+        it('should return true for a valid bolt11 invoice', () => {
+            const invoice = 'lnbc500n1p3zv5vkpp5x0thcaz8wep54clc2xt5895azjdzmthyskzzh9yslggy74qtvl6sdpdg3hkuct5d9hkugrxdaezqjn0dphk2fmnypkk2mtsdahkccqzpgxqyz5vqsp5v80q4vq4pwakq2l0hcqgtelgajsymv4ud4jdcrqtnzhvet55qlus9qyyssquqh2wl2m866qs5n72c5vg6wmqx9vzwhs5ypualq4mcu76h2tdkcq3jtjwtggfff7xwtdqxlnwqk8cxpzryjghrmmq3syraswp9vjr7cqry9l96';
+            (0, lightning_1.isBolt11Invoice)(invoice).should.equal(true);
+        });
+        it('should return false for non-string values', () => {
+            (0, lightning_1.isBolt11Invoice)(undefined).should.equal(false);
+            (0, lightning_1.isBolt11Invoice)(null).should.equal(false);
+            (0, lightning_1.isBolt11Invoice)(123).should.equal(false);
+            (0, lightning_1.isBolt11Invoice)({}).should.equal(false);
+        });
+        it('should return false for invalid invoice strings', () => {
+            (0, lightning_1.isBolt11Invoice)('').should.equal(false);
+            (0, lightning_1.isBolt11Invoice)('not-an-invoice').should.equal(false);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=units.d.ts.map

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

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