@bitgo/sdk-core 37.5.0 → 37.6.0

package/dist/src/coins/ofc.d.ts

@@ -22,6 +22,10 @@ export declare class Ofc extends BaseCoin {
     /**
      * Return boolean indicating whether input is valid public key for the coin.
      *
+     * OFC wallets hold keys in two formats: the user key is a BIP-32 base58 xpub,
+     * and the BitGo key (source: 'bitgo') is a base64-encoded SPKI (DER-wrapped)
+     * secp256k1 public key. Both are valid.
+     *
      * @param {String} pub the pub to be checked
      * @returns {Boolean} is it valid?
      */

package/dist/src/coins/ofc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ofc.d.ts","sourceRoot":"","sources":["../../../src/coins/ofc.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,OAAO,EAEP,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,MAAM,EACP,MAAM,KAAK,CAAC;AAEb,qBAAa,GAAI,SAAQ,QAAQ;gBACnB,KAAK,EAAE,SAAS;IAI5B,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ;IAIjD,QAAQ;IAIR;;;;;OAKG;IACH,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAevC,SAAS;IAIT,WAAW;IAIX;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAInD;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQhC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,aAAa,IAAI,MAAM,GAAG,MAAM;IAI1B,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI7E,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI/D,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrE,eAAe,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIjF;;;;OAIG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IACnE;;;;OAIG;IACG,WAAW,CAAC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASzE,kBAAkB;IAClB,iBAAiB,CAAC,MAAM,EAAE,uBAAuB;CAGlD"}
+{"version":3,"file":"ofc.d.ts","sourceRoot":"","sources":["../../../src/coins/ofc.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,OAAO,EAEP,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,MAAM,EACP,MAAM,KAAK,CAAC;AAEb,qBAAa,GAAI,SAAQ,QAAQ;gBACnB,KAAK,EAAE,SAAS;IAI5B,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ;IAIjD,QAAQ;IAIR;;;;;OAKG;IACH,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAevC,SAAS;IAIT,WAAW;IAIX;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAInD;;;;;;;;;OASG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAkBhC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,aAAa,IAAI,MAAM,GAAG,MAAM;IAI1B,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI7E,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI/D,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrE,eAAe,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIjF;;;;OAIG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IACnE;;;;OAIG;IACG,WAAW,CAAC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASzE,kBAAkB;IAClB,iBAAiB,CAAC,MAAM,EAAE,uBAAuB;CAGlD"}

package/dist/src/coins/ofc.js

@@ -52,12 +52,27 @@ class Ofc extends __1.BaseCoin {
     /**
      * Return boolean indicating whether input is valid public key for the coin.
      *
+     * OFC wallets hold keys in two formats: the user key is a BIP-32 base58 xpub,
+     * and the BitGo key (source: 'bitgo') is a base64-encoded SPKI (DER-wrapped)
+     * secp256k1 public key. Both are valid.
+     *
      * @param {String} pub the pub to be checked
      * @returns {Boolean} is it valid?
      */
     isValidPub(pub) {
+        // BIP-32 base58 xpub (user key)
+        try {
+            if (utxo_lib_1.bip32.fromBase58(pub).isNeutered()) {
+                return true;
+            }
+        }
+        catch (e) {
+            // not a BIP-32 key; fall through to the SPKI check
+        }
+        // base64-encoded SPKI DER secp256k1 public key (BitGo key)
         try {
-            return utxo_lib_1.bip32.fromBase58(pub).isNeutered();
+            const key = (0, crypto_1.createPublicKey)({ key: Buffer.from(pub, 'base64'), format: 'der', type: 'spki' });
+            return key.asymmetricKeyType === 'ec' && key.asymmetricKeyDetails?.namedCurve === 'secp256k1';
         }
         catch (e) {
             return false;
@@ -94,4 +109,4 @@ class Ofc extends __1.BaseCoin {
     }
 }
 exports.Ofc = Ofc;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ofc.js","sourceRoot":"","sources":["../../../src/coins/ofc.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { createPublicKey, randomBytes } from 'crypto';\nimport { bip32 } from '@bitgo/utxo-lib';\nimport {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  MethodNotImplementedError,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n  Wallet,\n} from '../';\n\nexport class Ofc extends BaseCoin {\n  constructor(bitgo: BitGoBase) {\n    super(bitgo);\n  }\n\n  static createInstance(bitgo: BitGoBase): BaseCoin {\n    return new Ofc(bitgo);\n  }\n\n  getChain() {\n    return 'ofc';\n  }\n\n  /**\n   * Generate secp256k1 key pair\n   *\n   * @param seed\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256\n      // bit chain code, both of which must be random. 512 bits is therefore the\n      // maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const extendedKey = bip32.fromSeed(seed);\n    const xpub = extendedKey.neutered().toBase58();\n    return {\n      pub: xpub,\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  getFamily() {\n    return 'ofc';\n  }\n\n  getFullName() {\n    return 'Offchain';\n  }\n\n  /**\n   * Return whether the given m of n wallet signers/ key amounts are valid for the coin\n   */\n  isValidMofNSetup({ m, n }: { m: number; n: number }) {\n    return m === 1 && n === 1;\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin.\n   *\n   * OFC wallets hold keys in two formats: the user key is a BIP-32 base58 xpub,\n   * and the BitGo key (source: 'bitgo') is a base64-encoded SPKI (DER-wrapped)\n   * secp256k1 public key. Both are valid.\n   *\n   * @param {String} pub the pub to be checked\n   * @returns {Boolean} is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    // BIP-32 base58 xpub (user key)\n    try {\n      if (bip32.fromBase58(pub).isNeutered()) {\n        return true;\n      }\n    } catch (e) {\n      // not a BIP-32 key; fall through to the SPKI check\n    }\n    // base64-encoded SPKI DER secp256k1 public key (BitGo key)\n    try {\n      const key = createPublicKey({ key: Buffer.from(pub, 'base64'), format: 'der', type: 'spki' });\n      return key.asymmetricKeyType === 'ec' && key.asymmetricKeyDetails?.namedCurve === 'secp256k1';\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    throw new MethodNotImplementedError();\n  }\n\n  getBaseFactor(): number | string {\n    return 0;\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    throw new MethodNotImplementedError();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    return true;\n  }\n\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new MethodNotImplementedError();\n  }\n\n  /**\n   * Signs a message using a trading wallet's BitGo Key\n   * @param wallet - uses the BitGo key of this trading wallet to sign the message remotely in a KMS\n   * @param message\n   */\n  async signMessage(wallet: Wallet, message: string): Promise<Buffer>;\n  /**\n   * Signs a message using the private key\n   * @param key - uses the private key to sign the message\n   * @param message\n   */\n  async signMessage(key: { prv: string }, message: string): Promise<Buffer>;\n  async signMessage(keyOrWallet: { prv: string } | Wallet, message: string): Promise<Buffer> {\n    if (!(keyOrWallet instanceof Wallet)) {\n      return super.signMessage(keyOrWallet, message);\n    }\n    const signatureHexString = await keyOrWallet.toTradingAccount().signPayload({ payload: message });\n    return Buffer.from(signatureHexString, 'hex');\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams) {\n    throw new MethodNotImplementedError();\n  }\n}\n"]}

package/dist/test/unit/bitgo/defi/defiVault.d.ts

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

package/dist/test/unit/bitgo/defi/defiVault.d.ts.map

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

package/dist/test/unit/bitgo/defi/defiVault.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon_1 = __importDefault(require("sinon"));
+const assert_1 = __importDefault(require("assert"));
+require("should");
+const src_1 = require("../../../../src");
+describe('DefiVault', function () {
+    let wallet;
+    let defiVault;
+    let mockBitGo;
+    let mockBaseCoin;
+    // Helper to create a chainable request mock
+    function mockRequest(result) {
+        return {
+            send: sinon_1.default.stub().returnsThis(),
+            query: sinon_1.default.stub().returnsThis(),
+            result: sinon_1.default.stub().resolves(result),
+        };
+    }
+    beforeEach(function () {
+        mockBitGo = {
+            post: sinon_1.default.stub(),
+            get: sinon_1.default.stub(),
+            del: sinon_1.default.stub(),
+            url: sinon_1.default.stub().callsFake((path, version) => `https://bitgo.com/api/v${version}${path}`),
+            microservicesUrl: sinon_1.default.stub().callsFake((path) => `https://bitgo.com${path}`),
+            setRequestTracer: sinon_1.default.stub(),
+        };
+        mockBaseCoin = {
+            getFamily: sinon_1.default.stub().returns('eth'),
+            url: sinon_1.default.stub(),
+            keychains: sinon_1.default.stub(),
+            supportsTss: sinon_1.default.stub().returns(true),
+            getMPCAlgorithm: sinon_1.default.stub(),
+        };
+        const mockWalletData = {
+            id: 'test-wallet-id',
+            coin: 'eth',
+            keys: ['user-key', 'backup-key', 'bitgo-key'],
+        };
+        wallet = new src_1.Wallet(mockBitGo, mockBaseCoin, mockWalletData);
+        defiVault = wallet.defi;
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    describe('depositToVault', function () {
+        it('should call sendMany for approve and deposit on happy path', async function () {
+            const operationId = 'op-uuid-123';
+            // Pre-flight: no active operations
+            const preflightReq = mockRequest({ items: [] });
+            mockBitGo.get.onFirstCall().returns(preflightReq);
+            // Mock sendMany for approve and deposit
+            const sendManyStub = sinon_1.default.stub(wallet, 'sendMany');
+            sendManyStub.onFirstCall().resolves({
+                txRequest: {
+                    txRequestId: 'txreq-approve-1',
+                    intent: { intentType: 'defi-approve', operationId },
+                },
+            });
+            sendManyStub.onSecondCall().resolves({
+                txRequest: {
+                    txRequestId: 'txreq-deposit-1',
+                    intent: { intentType: 'defi-deposit', operationId },
+                },
+            });
+            const result = await defiVault.depositToVault({
+                vaultId: 'vlt-galaxy-usdc',
+                amount: '1000000',
+            });
+            result.operationId.should.equal(operationId);
+            result.txRequestIds.approve.should.equal('txreq-approve-1');
+            result.txRequestIds.deposit.should.equal('txreq-deposit-1');
+            // Verify pre-flight was called with correct query
+            preflightReq.query.calledWith({ vaultId: 'vlt-galaxy-usdc', state: 'active' }).should.be.true();
+            // Verify sendMany was called with correct params for approve
+            sendManyStub.calledTwice.should.be.true();
+            const approveArgs = sendManyStub.firstCall.args[0];
+            approveArgs.type.should.equal('defiApprove');
+            approveArgs.defiParams.vaultId.should.equal('vlt-galaxy-usdc');
+            approveArgs.defiParams.amount.should.equal('1000000');
+            // Verify sendMany was called with correct params for deposit
+            const depositArgs = sendManyStub.secondCall.args[0];
+            depositArgs.type.should.equal('defiDeposit');
+            depositArgs.defiParams.operationId.should.equal(operationId);
+        });
+        it('should reject when an active operation already exists', async function () {
+            const preflightReq = mockRequest({
+                items: [{ operationId: 'existing-op-id', state: 'APPROVE_TX_REQUESTED' }],
+            });
+            mockBitGo.get.returns(preflightReq);
+            await assert_1.default.rejects(() => defiVault.depositToVault({ vaultId: 'vlt-galaxy-usdc', amount: '1000000' }), (err) => {
+                (err instanceof src_1.ActiveOperationExistsError).should.be.true();
+                err.operationId.should.equal('existing-op-id');
+                return true;
+            });
+        });
+        it('should propagate deposit sendMany failure without cleanup', async function () {
+            const operationId = 'op-uuid-456';
+            // Pre-flight: no active operations
+            const preflightReq = mockRequest({ items: [] });
+            mockBitGo.get.returns(preflightReq);
+            // Mock sendMany: approve succeeds, deposit fails
+            const sendManyStub = sinon_1.default.stub(wallet, 'sendMany');
+            sendManyStub.onFirstCall().resolves({
+                txRequest: {
+                    txRequestId: 'txreq-approve-2',
+                    intent: { intentType: 'defi-approve', operationId },
+                },
+            });
+            sendManyStub.onSecondCall().rejects(new Error('deposit creation failed'));
+            await assert_1.default.rejects(() => defiVault.depositToVault({ vaultId: 'vlt-galaxy-usdc', amount: '1000000' }), {
+                message: 'deposit creation failed',
+            });
+            // SDK does not attempt cleanup — reconciler handles orphaned approvals
+            mockBitGo.del.called.should.be.false();
+        });
+        it('should throw if vaultId is missing', async function () {
+            await assert_1.default.rejects(() => defiVault.depositToVault({ vaultId: '', amount: '1000000' }), {
+                message: 'vaultId is required',
+            });
+        });
+        it('should throw if amount is missing', async function () {
+            await assert_1.default.rejects(() => defiVault.depositToVault({ vaultId: 'vlt-1', amount: '' }), {
+                message: 'amount is required',
+            });
+        });
+        it('should pass clientIdempotencyKey and walletPassphrase when provided', async function () {
+            const operationId = 'op-uuid-789';
+            const preflightReq = mockRequest({ items: [] });
+            mockBitGo.get.returns(preflightReq);
+            const sendManyStub = sinon_1.default.stub(wallet, 'sendMany');
+            sendManyStub.onFirstCall().resolves({
+                txRequest: {
+                    txRequestId: 'txreq-approve-3',
+                    intent: { intentType: 'defi-approve', operationId },
+                },
+            });
+            sendManyStub.onSecondCall().resolves({
+                txRequest: {
+                    txRequestId: 'txreq-deposit-3',
+                    intent: { intentType: 'defi-deposit', operationId },
+                },
+            });
+            await defiVault.depositToVault({
+                vaultId: 'vlt-galaxy-usdc',
+                amount: '1000000',
+                clientIdempotencyKey: 'idem-key-123',
+                walletPassphrase: 'test-passphrase',
+            });
+            const approveArgs = sendManyStub.firstCall.args[0];
+            approveArgs.defiParams.clientIdempotencyKey.should.equal('idem-key-123');
+            approveArgs.walletPassphrase.should.equal('test-passphrase');
+            const depositArgs = sendManyStub.secondCall.args[0];
+            depositArgs.defiParams.clientIdempotencyKey.should.equal('idem-key-123');
+            depositArgs.walletPassphrase.should.equal('test-passphrase');
+        });
+    });
+    describe('resumeDeposit', function () {
+        it('should issue the deposit sendMany for a partial operation', async function () {
+            const operation = {
+                operationId: 'op-resume-1',
+                walletId: 'test-wallet-id',
+                vaultId: 'vlt-galaxy-usdc',
+                type: 'DEPOSIT',
+                assetAmount: '1000000',
+                state: 'APPROVE_TX_REQUESTED',
+                txRequestId: 'txreq-approve-existing',
+                associatedTxRequestId: undefined,
+                createdAt: '2026-05-14T07:12:00Z',
+                updatedAt: '2026-05-14T07:12:00Z',
+            };
+            // getOperation call
+            const getOpReq = mockRequest(operation);
+            mockBitGo.get.returns(getOpReq);
+            // deposit sendMany
+            const sendManyStub = sinon_1.default.stub(wallet, 'sendMany');
+            sendManyStub.resolves({
+                txRequest: {
+                    txRequestId: 'txreq-deposit-resume',
+                    intent: { intentType: 'defi-deposit', operationId: 'op-resume-1' },
+                },
+            });
+            const result = await defiVault.resumeDeposit({ operationId: 'op-resume-1' });
+            result.operationId.should.equal('op-resume-1');
+            result.txRequestIds.approve.should.equal('txreq-approve-existing');
+            result.txRequestIds.deposit.should.equal('txreq-deposit-resume');
+            // Verify sendMany was called with correct defiParams
+            const depositArgs = sendManyStub.firstCall.args[0];
+            depositArgs.type.should.equal('defiDeposit');
+            depositArgs.defiParams.vaultId.should.equal('vlt-galaxy-usdc');
+            depositArgs.defiParams.amount.should.equal('1000000');
+            depositArgs.defiParams.operationId.should.equal('op-resume-1');
+        });
+        it('should throw if deposit txRequest already exists', async function () {
+            const operation = {
+                operationId: 'op-already-done',
+                walletId: 'test-wallet-id',
+                vaultId: 'vlt-galaxy-usdc',
+                type: 'DEPOSIT',
+                assetAmount: '1000000',
+                state: 'DEPOSIT_TX_REQUESTED',
+                txRequestId: 'txreq-approve-x',
+                associatedTxRequestId: 'txreq-deposit-x',
+                createdAt: '2026-05-14T07:12:00Z',
+                updatedAt: '2026-05-14T07:12:00Z',
+            };
+            const getOpReq = mockRequest(operation);
+            mockBitGo.get.returns(getOpReq);
+            await assert_1.default.rejects(() => defiVault.resumeDeposit({ operationId: 'op-already-done' }), {
+                message: 'Deposit txRequest already exists for this operation; nothing to resume',
+            });
+        });
+        it('should throw if operationId is missing', async function () {
+            await assert_1.default.rejects(() => defiVault.resumeDeposit({ operationId: '' }), { message: 'operationId is required' });
+        });
+    });
+    describe('getOperation', function () {
+        it('should fetch an operation by ID', async function () {
+            const operation = {
+                operationId: 'op-get-1',
+                walletId: 'test-wallet-id',
+                vaultId: 'vlt-galaxy-usdc',
+                type: 'DEPOSIT',
+                assetAmount: '1000000',
+                state: 'COMPLETED',
+                txRequestId: 'txreq-1',
+                associatedTxRequestId: 'txreq-2',
+                createdAt: '2026-05-14T07:12:00Z',
+                updatedAt: '2026-05-14T07:18:00Z',
+            };
+            const req = mockRequest(operation);
+            mockBitGo.get.returns(req);
+            const result = await defiVault.getOperation({ operationId: 'op-get-1' });
+            result.should.deepEqual(operation);
+        });
+        it('should throw if operationId is missing', async function () {
+            await assert_1.default.rejects(() => defiVault.getOperation({ operationId: '' }), { message: 'operationId is required' });
+        });
+    });
+    describe('listOperations', function () {
+        it('should list operations for a vault', async function () {
+            const listResult = {
+                items: [
+                    {
+                        operationId: 'op-1',
+                        walletId: 'test-wallet-id',
+                        vaultId: 'vlt-galaxy-usdc',
+                        type: 'DEPOSIT',
+                        assetAmount: '1000000',
+                        state: 'COMPLETED',
+                        createdAt: '2026-05-14T07:12:00Z',
+                        updatedAt: '2026-05-14T07:18:00Z',
+                    },
+                ],
+                nextCursor: 'cursor-abc',
+            };
+            const req = mockRequest(listResult);
+            mockBitGo.get.returns(req);
+            const result = await defiVault.listOperations({
+                vaultId: 'vlt-galaxy-usdc',
+                state: 'COMPLETED',
+                limit: 10,
+            });
+            result.items.length.should.equal(1);
+            result.nextCursor.should.equal('cursor-abc');
+            // Verify query params
+            const queryArgs = req.query.firstCall.args[0];
+            queryArgs.vaultId.should.equal('vlt-galaxy-usdc');
+            queryArgs.state.should.equal('COMPLETED');
+            queryArgs.limit.should.equal(10);
+        });
+        it('should throw if vaultId is missing', async function () {
+            await assert_1.default.rejects(() => defiVault.listOperations({ vaultId: '' }), { message: 'vaultId is required' });
+        });
+    });
+    describe('wallet.defi getter', function () {
+        it('should return a DefiVault instance', function () {
+            const defi = wallet.defi;
+            (defi instanceof src_1.DefiVault).should.be.true();
+        });
+        it('should return the same instance on subsequent calls', function () {
+            const defi1 = wallet.defi;
+            const defi2 = wallet.defi;
+            (defi1 === defi2).should.be.true();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defiVault.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/defi/defiVault.ts"],"names":[],"mappings":"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","sourcesContent":["import sinon from 'sinon';\nimport assert from 'assert';\nimport 'should';\nimport { ActiveOperationExistsError, DefiVault, Wallet } from '../../../../src';\n\ndescribe('DefiVault', function () {\n  let wallet: Wallet;\n  let defiVault: DefiVault;\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n\n  // Helper to create a chainable request mock\n  function mockRequest(result: any) {\n    return {\n      send: sinon.stub().returnsThis(),\n      query: sinon.stub().returnsThis(),\n      result: sinon.stub().resolves(result),\n    };\n  }\n\n  beforeEach(function () {\n    mockBitGo = {\n      post: sinon.stub(),\n      get: sinon.stub(),\n      del: sinon.stub(),\n      url: sinon.stub().callsFake((path: string, version: number) => `https://bitgo.com/api/v${version}${path}`),\n      microservicesUrl: sinon.stub().callsFake((path: string) => `https://bitgo.com${path}`),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      getFamily: sinon.stub().returns('eth'),\n      url: sinon.stub(),\n      keychains: sinon.stub(),\n      supportsTss: sinon.stub().returns(true),\n      getMPCAlgorithm: sinon.stub(),\n    };\n\n    const mockWalletData = {\n      id: 'test-wallet-id',\n      coin: 'eth',\n      keys: ['user-key', 'backup-key', 'bitgo-key'],\n    };\n\n    wallet = new Wallet(mockBitGo, mockBaseCoin, mockWalletData);\n    defiVault = wallet.defi;\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('depositToVault', function () {\n    it('should call sendMany for approve and deposit on happy path', async function () {\n      const operationId = 'op-uuid-123';\n\n      // Pre-flight: no active operations\n      const preflightReq = mockRequest({ items: [] });\n      mockBitGo.get.onFirstCall().returns(preflightReq);\n\n      // Mock sendMany for approve and deposit\n      const sendManyStub = sinon.stub(wallet, 'sendMany');\n      sendManyStub.onFirstCall().resolves({\n        txRequest: {\n          txRequestId: 'txreq-approve-1',\n          intent: { intentType: 'defi-approve', operationId },\n        },\n      });\n      sendManyStub.onSecondCall().resolves({\n        txRequest: {\n          txRequestId: 'txreq-deposit-1',\n          intent: { intentType: 'defi-deposit', operationId },\n        },\n      });\n\n      const result = await defiVault.depositToVault({\n        vaultId: 'vlt-galaxy-usdc',\n        amount: '1000000',\n      });\n\n      result.operationId.should.equal(operationId);\n      result.txRequestIds.approve.should.equal('txreq-approve-1');\n      result.txRequestIds.deposit.should.equal('txreq-deposit-1');\n\n      // Verify pre-flight was called with correct query\n      preflightReq.query.calledWith({ vaultId: 'vlt-galaxy-usdc', state: 'active' }).should.be.true();\n\n      // Verify sendMany was called with correct params for approve\n      sendManyStub.calledTwice.should.be.true();\n      const approveArgs: any = sendManyStub.firstCall.args[0];\n      approveArgs.type.should.equal('defiApprove');\n      approveArgs.defiParams.vaultId.should.equal('vlt-galaxy-usdc');\n      approveArgs.defiParams.amount.should.equal('1000000');\n\n      // Verify sendMany was called with correct params for deposit\n      const depositArgs: any = sendManyStub.secondCall.args[0];\n      depositArgs.type.should.equal('defiDeposit');\n      depositArgs.defiParams.operationId.should.equal(operationId);\n    });\n\n    it('should reject when an active operation already exists', async function () {\n      const preflightReq = mockRequest({\n        items: [{ operationId: 'existing-op-id', state: 'APPROVE_TX_REQUESTED' }],\n      });\n      mockBitGo.get.returns(preflightReq);\n\n      await assert.rejects(\n        () => defiVault.depositToVault({ vaultId: 'vlt-galaxy-usdc', amount: '1000000' }),\n        (err: Error) => {\n          (err instanceof ActiveOperationExistsError).should.be.true();\n          (err as ActiveOperationExistsError).operationId.should.equal('existing-op-id');\n          return true;\n        }\n      );\n    });\n\n    it('should propagate deposit sendMany failure without cleanup', async function () {\n      const operationId = 'op-uuid-456';\n\n      // Pre-flight: no active operations\n      const preflightReq = mockRequest({ items: [] });\n      mockBitGo.get.returns(preflightReq);\n\n      // Mock sendMany: approve succeeds, deposit fails\n      const sendManyStub = sinon.stub(wallet, 'sendMany');\n      sendManyStub.onFirstCall().resolves({\n        txRequest: {\n          txRequestId: 'txreq-approve-2',\n          intent: { intentType: 'defi-approve', operationId },\n        },\n      });\n      sendManyStub.onSecondCall().rejects(new Error('deposit creation failed'));\n\n      await assert.rejects(() => defiVault.depositToVault({ vaultId: 'vlt-galaxy-usdc', amount: '1000000' }), {\n        message: 'deposit creation failed',\n      });\n\n      // SDK does not attempt cleanup — reconciler handles orphaned approvals\n      mockBitGo.del.called.should.be.false();\n    });\n\n    it('should throw if vaultId is missing', async function () {\n      await assert.rejects(() => defiVault.depositToVault({ vaultId: '', amount: '1000000' }), {\n        message: 'vaultId is required',\n      });\n    });\n\n    it('should throw if amount is missing', async function () {\n      await assert.rejects(() => defiVault.depositToVault({ vaultId: 'vlt-1', amount: '' }), {\n        message: 'amount is required',\n      });\n    });\n\n    it('should pass clientIdempotencyKey and walletPassphrase when provided', async function () {\n      const operationId = 'op-uuid-789';\n\n      const preflightReq = mockRequest({ items: [] });\n      mockBitGo.get.returns(preflightReq);\n\n      const sendManyStub = sinon.stub(wallet, 'sendMany');\n      sendManyStub.onFirstCall().resolves({\n        txRequest: {\n          txRequestId: 'txreq-approve-3',\n          intent: { intentType: 'defi-approve', operationId },\n        },\n      });\n      sendManyStub.onSecondCall().resolves({\n        txRequest: {\n          txRequestId: 'txreq-deposit-3',\n          intent: { intentType: 'defi-deposit', operationId },\n        },\n      });\n\n      await defiVault.depositToVault({\n        vaultId: 'vlt-galaxy-usdc',\n        amount: '1000000',\n        clientIdempotencyKey: 'idem-key-123',\n        walletPassphrase: 'test-passphrase',\n      });\n\n      const approveArgs: any = sendManyStub.firstCall.args[0];\n      approveArgs.defiParams.clientIdempotencyKey.should.equal('idem-key-123');\n      approveArgs.walletPassphrase.should.equal('test-passphrase');\n\n      const depositArgs: any = sendManyStub.secondCall.args[0];\n      depositArgs.defiParams.clientIdempotencyKey.should.equal('idem-key-123');\n      depositArgs.walletPassphrase.should.equal('test-passphrase');\n    });\n  });\n\n  describe('resumeDeposit', function () {\n    it('should issue the deposit sendMany for a partial operation', async function () {\n      const operation = {\n        operationId: 'op-resume-1',\n        walletId: 'test-wallet-id',\n        vaultId: 'vlt-galaxy-usdc',\n        type: 'DEPOSIT',\n        assetAmount: '1000000',\n        state: 'APPROVE_TX_REQUESTED',\n        txRequestId: 'txreq-approve-existing',\n        associatedTxRequestId: undefined,\n        createdAt: '2026-05-14T07:12:00Z',\n        updatedAt: '2026-05-14T07:12:00Z',\n      };\n\n      // getOperation call\n      const getOpReq = mockRequest(operation);\n      mockBitGo.get.returns(getOpReq);\n\n      // deposit sendMany\n      const sendManyStub = sinon.stub(wallet, 'sendMany');\n      sendManyStub.resolves({\n        txRequest: {\n          txRequestId: 'txreq-deposit-resume',\n          intent: { intentType: 'defi-deposit', operationId: 'op-resume-1' },\n        },\n      });\n\n      const result = await defiVault.resumeDeposit({ operationId: 'op-resume-1' });\n\n      result.operationId.should.equal('op-resume-1');\n      result.txRequestIds.approve.should.equal('txreq-approve-existing');\n      result.txRequestIds.deposit.should.equal('txreq-deposit-resume');\n\n      // Verify sendMany was called with correct defiParams\n      const depositArgs: any = sendManyStub.firstCall.args[0];\n      depositArgs.type.should.equal('defiDeposit');\n      depositArgs.defiParams.vaultId.should.equal('vlt-galaxy-usdc');\n      depositArgs.defiParams.amount.should.equal('1000000');\n      depositArgs.defiParams.operationId.should.equal('op-resume-1');\n    });\n\n    it('should throw if deposit txRequest already exists', async function () {\n      const operation = {\n        operationId: 'op-already-done',\n        walletId: 'test-wallet-id',\n        vaultId: 'vlt-galaxy-usdc',\n        type: 'DEPOSIT',\n        assetAmount: '1000000',\n        state: 'DEPOSIT_TX_REQUESTED',\n        txRequestId: 'txreq-approve-x',\n        associatedTxRequestId: 'txreq-deposit-x',\n        createdAt: '2026-05-14T07:12:00Z',\n        updatedAt: '2026-05-14T07:12:00Z',\n      };\n\n      const getOpReq = mockRequest(operation);\n      mockBitGo.get.returns(getOpReq);\n\n      await assert.rejects(() => defiVault.resumeDeposit({ operationId: 'op-already-done' }), {\n        message: 'Deposit txRequest already exists for this operation; nothing to resume',\n      });\n    });\n\n    it('should throw if operationId is missing', async function () {\n      await assert.rejects(() => defiVault.resumeDeposit({ operationId: '' }), { message: 'operationId is required' });\n    });\n  });\n\n  describe('getOperation', function () {\n    it('should fetch an operation by ID', async function () {\n      const operation = {\n        operationId: 'op-get-1',\n        walletId: 'test-wallet-id',\n        vaultId: 'vlt-galaxy-usdc',\n        type: 'DEPOSIT',\n        assetAmount: '1000000',\n        state: 'COMPLETED',\n        txRequestId: 'txreq-1',\n        associatedTxRequestId: 'txreq-2',\n        createdAt: '2026-05-14T07:12:00Z',\n        updatedAt: '2026-05-14T07:18:00Z',\n      };\n\n      const req = mockRequest(operation);\n      mockBitGo.get.returns(req);\n\n      const result = await defiVault.getOperation({ operationId: 'op-get-1' });\n      result.should.deepEqual(operation);\n    });\n\n    it('should throw if operationId is missing', async function () {\n      await assert.rejects(() => defiVault.getOperation({ operationId: '' }), { message: 'operationId is required' });\n    });\n  });\n\n  describe('listOperations', function () {\n    it('should list operations for a vault', async function () {\n      const listResult = {\n        items: [\n          {\n            operationId: 'op-1',\n            walletId: 'test-wallet-id',\n            vaultId: 'vlt-galaxy-usdc',\n            type: 'DEPOSIT',\n            assetAmount: '1000000',\n            state: 'COMPLETED',\n            createdAt: '2026-05-14T07:12:00Z',\n            updatedAt: '2026-05-14T07:18:00Z',\n          },\n        ],\n        nextCursor: 'cursor-abc',\n      };\n\n      const req = mockRequest(listResult);\n      mockBitGo.get.returns(req);\n\n      const result = await defiVault.listOperations({\n        vaultId: 'vlt-galaxy-usdc',\n        state: 'COMPLETED',\n        limit: 10,\n      });\n\n      result.items.length.should.equal(1);\n      result.nextCursor!.should.equal('cursor-abc');\n\n      // Verify query params\n      const queryArgs = req.query.firstCall.args[0];\n      queryArgs.vaultId.should.equal('vlt-galaxy-usdc');\n      queryArgs.state.should.equal('COMPLETED');\n      queryArgs.limit.should.equal(10);\n    });\n\n    it('should throw if vaultId is missing', async function () {\n      await assert.rejects(() => defiVault.listOperations({ vaultId: '' }), { message: 'vaultId is required' });\n    });\n  });\n\n  describe('wallet.defi getter', function () {\n    it('should return a DefiVault instance', function () {\n      const defi = wallet.defi;\n      (defi instanceof DefiVault).should.be.true();\n    });\n\n    it('should return the same instance on subsequent calls', function () {\n      const defi1 = wallet.defi;\n      const defi2 = wallet.defi;\n      (defi1 === defi2).should.be.true();\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.d.ts

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

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.d.ts.map

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

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.js

@@ -0,0 +1,94 @@
+"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"));
+const ecdsa_1 = require("../../../../../../src/bitgo/utils/tss/ecdsa/ecdsa");
+/**
+ * Regression tests for the ECDSA MPCv1 createKeychains encryptionVersion bug.
+ *
+ * Previously, EcdsaUtils.createKeychains dropped `encryptionVersion` silently —
+ * it was not declared in the params and was never forwarded to createUserKeychain
+ * or createBackupKeychain, causing a version mismatch within a wallet: v2 for
+ * encryptedWalletPassphrase but v1 for the user/backup keychains.
+ */
+describe('EcdsaUtils.createKeychains - encryptionVersion forwarding', function () {
+    let ecdsaUtils;
+    let createUserKeychainStub;
+    let createBackupKeychainStub;
+    const fakeKeychain = { id: 'key-id', pub: 'pub', commonKeychain: 'ckc', type: 'tss' };
+    const fakeGpgKey = { publicKey: 'pub', privateKey: 'prv' };
+    const fakeKeyShare = { userHeldKeyShare: {} };
+    beforeEach(function () {
+        const mockBitgo = { getEnv: sinon.stub().returns('test') };
+        const mockCoin = {};
+        ecdsaUtils = new ecdsa_1.EcdsaUtils(mockBitgo, mockCoin);
+        createUserKeychainStub = sinon.stub(ecdsaUtils, 'createUserKeychain').resolves(fakeKeychain);
+        createBackupKeychainStub = sinon.stub(ecdsaUtils, 'createBackupKeychain').resolves(fakeKeychain);
+        sinon.stub(ecdsaUtils, 'createBitgoKeychain').resolves(fakeKeychain);
+        sinon.stub(ecdsaUtils, 'createBackupKeyShares').resolves(fakeKeyShare);
+        sinon.stub(ecdsaUtils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ mpcv2PublicKey: undefined });
+        sinon.stub(ecdsaUtils, 'getBackupGpgPubKey').resolves(fakeGpgKey);
+        sinon.stub(require('../../../../../../src/bitgo/utils/opengpgUtils'), 'generateGPGKeyPair').resolves(fakeGpgKey);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('forwards encryptionVersion: 2 to createUserKeychain', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });
+        assert.ok(createUserKeychainStub.calledOnce);
+        const userParams = createUserKeychainStub.firstCall.args[0];
+        assert.strictEqual(userParams.encryptionVersion, 2);
+    });
+    it('forwards encryptionVersion: 2 to createBackupKeychain', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });
+        assert.ok(createBackupKeychainStub.calledOnce);
+        const backupParams = createBackupKeychainStub.firstCall.args[0];
+        assert.strictEqual(backupParams.encryptionVersion, 2);
+    });
+    it('forwards encryptionVersion: undefined when not set', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass' });
+        assert.ok(createUserKeychainStub.calledOnce);
+        assert.ok(createBackupKeychainStub.calledOnce);
+        assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, undefined);
+        assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, undefined);
+    });
+    it('forwards encryptionVersion: 1 explicitly', async function () {
+        await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 1 });
+        assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, 1);
+        assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, 1);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaEncryptionVersion.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/ecdsa/ecdsaEncryptionVersion.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { EcdsaUtils } from '../../../../../../src/bitgo/utils/tss/ecdsa/ecdsa';\nimport { BitGoBase, IBaseCoin } from '../../../../../../src';\n\n/**\n * Regression tests for the ECDSA MPCv1 createKeychains encryptionVersion bug.\n *\n * Previously, EcdsaUtils.createKeychains dropped `encryptionVersion` silently —\n * it was not declared in the params and was never forwarded to createUserKeychain\n * or createBackupKeychain, causing a version mismatch within a wallet: v2 for\n * encryptedWalletPassphrase but v1 for the user/backup keychains.\n */\ndescribe('EcdsaUtils.createKeychains - encryptionVersion forwarding', function () {\n  let ecdsaUtils: EcdsaUtils;\n  let createUserKeychainStub: sinon.SinonStub;\n  let createBackupKeychainStub: sinon.SinonStub;\n\n  const fakeKeychain = { id: 'key-id', pub: 'pub', commonKeychain: 'ckc', type: 'tss' as const };\n  const fakeGpgKey = { publicKey: 'pub', privateKey: 'prv' };\n  const fakeKeyShare = { userHeldKeyShare: {} };\n\n  beforeEach(function () {\n    const mockBitgo = { getEnv: sinon.stub().returns('test') } as unknown as BitGoBase;\n    const mockCoin = {} as unknown as IBaseCoin;\n\n    ecdsaUtils = new EcdsaUtils(mockBitgo, mockCoin);\n\n    createUserKeychainStub = sinon.stub(ecdsaUtils, 'createUserKeychain').resolves(fakeKeychain);\n    createBackupKeychainStub = sinon.stub(ecdsaUtils, 'createBackupKeychain').resolves(fakeKeychain);\n    sinon.stub(ecdsaUtils, 'createBitgoKeychain').resolves(fakeKeychain);\n    sinon.stub(ecdsaUtils, 'createBackupKeyShares').resolves(fakeKeyShare as any);\n    sinon.stub(ecdsaUtils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ mpcv2PublicKey: undefined } as any);\n\n    sinon.stub(ecdsaUtils as any, 'getBackupGpgPubKey').resolves(fakeGpgKey);\n    sinon.stub(require('../../../../../../src/bitgo/utils/opengpgUtils'), 'generateGPGKeyPair').resolves(fakeGpgKey);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('forwards encryptionVersion: 2 to createUserKeychain', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });\n\n    assert.ok(createUserKeychainStub.calledOnce);\n    const userParams = createUserKeychainStub.firstCall.args[0];\n    assert.strictEqual(userParams.encryptionVersion, 2);\n  });\n\n  it('forwards encryptionVersion: 2 to createBackupKeychain', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 2 });\n\n    assert.ok(createBackupKeychainStub.calledOnce);\n    const backupParams = createBackupKeychainStub.firstCall.args[0];\n    assert.strictEqual(backupParams.encryptionVersion, 2);\n  });\n\n  it('forwards encryptionVersion: undefined when not set', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass' });\n\n    assert.ok(createUserKeychainStub.calledOnce);\n    assert.ok(createBackupKeychainStub.calledOnce);\n    assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, undefined);\n    assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, undefined);\n  });\n\n  it('forwards encryptionVersion: 1 explicitly', async function () {\n    await ecdsaUtils.createKeychains({ passphrase: 'pass', encryptionVersion: 1 });\n\n    assert.strictEqual(createUserKeychainStub.firstCall.args[0].encryptionVersion, 1);\n    assert.strictEqual(createBackupKeychainStub.firstCall.args[0].encryptionVersion, 1);\n  });\n});\n"]}