@bitgo-beta/sdk-coin-sol 7.6.4-beta.782 → 7.6.4-beta.784

package/dist/cjs/test/unit/solSafeRecovery.d.ts

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

package/dist/cjs/test/unit/solSafeRecovery.d.ts.map

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

package/dist/cjs/test/unit/solSafeRecovery.js

@@ -0,0 +1,202 @@
+"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 });
+const assert_1 = __importDefault(require("assert"));
+const sinon_1 = __importDefault(require("sinon"));
+const nacl = __importStar(require("tweetnacl"));
+const base58 = __importStar(require("bs58"));
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const src_1 = require("../../src");
+const lib_1 = require("../../src/lib");
+const statics_1 = require("@bitgo-beta/statics");
+const testData = __importStar(require("../fixtures/sol"));
+/**
+ * End-to-end Safe SOL recovery: real MPS DKG + VRF roots -> deriveSafeWalletKeys (slot-4 eddsaMpc
+ * child) -> buildSafeRecoverKeyParams -> Sol.recover() with the real MPS 2-of-2 signing path. Only
+ * chain queries are mocked.
+ *
+ * This proves the derived child keychain is accepted as `bitgoKey`, the re-encrypted child shares
+ * decrypt and sign, and the resulting signature verifies under the derived wallet address.
+ */
+describe('Safe SOL recovery end-to-end', function () {
+    const sandbox = sinon_1.default.createSandbox();
+    let bitgo;
+    let basecoin;
+    let roots;
+    before(async function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('tsol', src_1.Tsol.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tsol');
+        const [userDkg, backupDkg, bitgoDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const [vrfUser, vrfBackup] = await sdk_lib_mpc_1.MpsVrfUtils.generateVrfDKGKeyShares();
+        roots = {
+            secp256k1Multisig: { user: 'u', backup: 'b', bitgo: 'g' },
+            ed25519Multisig: { user: 'u', backup: { prv: 'b', chainCode: 'c' }, bitgo: 'g' },
+            ecdsaMpc: {
+                user: { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) },
+                backup: { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) },
+                bitgo: 'g',
+            },
+            eddsaMpc: {
+                user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },
+                backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },
+                bitgo: bitgoDkg.getCommonKeychain(),
+            },
+        };
+    });
+    afterEach(function () {
+        sandbox.restore();
+    });
+    async function deriveChild(account) {
+        const derived = await (0, sdk_core_1.deriveSafeWalletKeys)({ coin: 'tsol', slot: 'eddsaMpc', account, roots });
+        (0, assert_1.default)(derived.slot === 'eddsaMpc');
+        const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const publicKey = mpc.deriveUnhardened(derived.keys.commonKeychain, 'm/0').slice(0, 64);
+        return { derived, publicKey, address: new src_1.KeyPair({ pub: publicKey }).getAddress() };
+    }
+    function stubChain(walletAddress) {
+        const getDataFromNode = sandbox.stub(src_1.Sol.prototype, 'getDataFromNode');
+        getDataFromNode
+            .withArgs({
+            payload: { id: '1', jsonrpc: '2.0', method: 'getLatestBlockhash', params: [{ commitment: 'finalized' }] },
+        })
+            .resolves(testData.SolResponses.getBlockhashResponse);
+        getDataFromNode
+            .withArgs({ payload: { id: '1', jsonrpc: '2.0', method: 'getBalance', params: [walletAddress] } })
+            .resolves(testData.SolResponses.getAccountBalanceResponse);
+        getDataFromNode
+            .withArgs({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getFeeForMessage',
+                params: [sinon_1.default.match.string, { commitment: 'finalized' }],
+            },
+        })
+            .resolves(testData.SolResponses.getFeesForMessageResponse);
+    }
+    it('recovers a Safe SOL wallet offline: derive -> map -> sign, verifiable under the derived address', async function () {
+        const { derived, publicKey, address } = await deriveChild(0);
+        stubChain(address);
+        const keyParams = await (0, sdk_core_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'tsol',
+            slot: 'eddsaMpc',
+            keys: derived.keys,
+            mode: 'signed',
+        });
+        (0, assert_1.default)(keyParams.mode === 'signed');
+        assert_1.default.strictEqual(keyParams.isTss, true);
+        assert_1.default.strictEqual(keyParams.broadcast, false);
+        assert_1.default.strictEqual(keyParams.bitgoKey, derived.keys.commonKeychain);
+        const recovery = await basecoin.recover({
+            ...keyParams,
+            recoveryDestination: testData.keys.destinationPubKey,
+        });
+        (0, assert_1.default)('serializedTx' in recovery);
+        assert_1.default.strictEqual(recovery.scanIndex, 0);
+        // The signature on the recovered tx verifies under the derived child wallet key.
+        const tx = await new lib_1.TransactionBuilderFactory(statics_1.coins.get('tsol')).from(recovery.serializedTx).build();
+        assert_1.default.strictEqual(tx.signature.length, 1);
+        assert_1.default.strictEqual(nacl.sign.detached.verify(new Uint8Array(tx.signablePayload), new Uint8Array(base58.decode(tx.signature[0])), new Uint8Array(Buffer.from(publicKey, 'hex'))), true);
+    });
+    it('returns an unsigned sweep from the derived child address with no key material in the params', async function () {
+        const { derived, address } = await deriveChild(0);
+        stubChain(address);
+        const keyParams = await (0, sdk_core_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'tsol',
+            slot: 'eddsaMpc',
+            keys: derived.keys,
+            mode: 'unsigned',
+        });
+        (0, assert_1.default)(keyParams.mode === 'unsigned');
+        (0, assert_1.default)(!('userKey' in keyParams) && !('backupKey' in keyParams) && !('walletPassphrase' in keyParams));
+        const recovery = await basecoin.recover({
+            ...keyParams,
+            recoveryDestination: testData.keys.destinationPubKey,
+        });
+        (0, assert_1.default)('txRequests' in recovery);
+        const unsignedTx = recovery.txRequests[0].transactions[0].unsignedTx;
+        assert_1.default.strictEqual(unsignedTx.coinSpecific?.commonKeychain, derived.keys.commonKeychain);
+        assert_1.default.strictEqual(unsignedTx.derivationPath, 'm/0');
+        (0, assert_1.default)(unsignedTx.signableHex);
+        const tx = await new lib_1.TransactionBuilderFactory(statics_1.coins.get('tsol')).from(unsignedTx.serializedTx).build();
+        assert_1.default.strictEqual(tx.inputs[0].address, address);
+    });
+    it('fails closed when the signing shares belong to a different account than bitgoKey', async function () {
+        const account0 = await deriveChild(0);
+        const account1 = await deriveChild(1);
+        stubChain(account0.address);
+        const keyParams = await (0, sdk_core_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'tsol',
+            slot: 'eddsaMpc',
+            keys: account1.derived.keys,
+            mode: 'signed',
+        });
+        (0, assert_1.default)(keyParams.mode === 'signed');
+        await assert_1.default.rejects(basecoin.recover({
+            ...keyParams,
+            bitgoKey: account0.derived.keys.commonKeychain,
+            recoveryDestination: testData.keys.destinationPubKey,
+        }), /commonKeyChain from keycard does not match bitgoKey/);
+    });
+    it('fails closed when the wallet passphrase cannot decrypt the re-encrypted child shares', async function () {
+        const { derived, address } = await deriveChild(0);
+        stubChain(address);
+        const keyParams = await (0, sdk_core_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'tsol',
+            slot: 'eddsaMpc',
+            keys: derived.keys,
+            mode: 'signed',
+        });
+        (0, assert_1.default)(keyParams.mode === 'signed');
+        await assert_1.default.rejects(basecoin.recover({
+            ...keyParams,
+            walletPassphrase: 'not-the-ephemeral-passphrase',
+            recoveryDestination: testData.keys.destinationPubKey,
+        }), /Error decrypting user keychain/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"solSafeRecovery.js","sourceRoot":"","sources":["../../../../test/unit/solSafeRecovery.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport Sinon from 'sinon';\nimport * as nacl from 'tweetnacl';\nimport * as base58 from 'bs58';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { MPSUtil, MpsVrfUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport {\n  buildSafeRecoverKeyParams,\n  deriveSafeWalletKeys,\n  EDDSAMethods,\n  type DecryptedSafeRoots,\n} from '@bitgo-beta/sdk-core';\nimport { KeyPair, Tsol, Sol } from '../../src';\nimport { TransactionBuilderFactory } from '../../src/lib';\nimport { coins } from '@bitgo-beta/statics';\nimport * as testData from '../fixtures/sol';\n\n/**\n * End-to-end Safe SOL recovery: real MPS DKG + VRF roots -> deriveSafeWalletKeys (slot-4 eddsaMpc\n * child) -> buildSafeRecoverKeyParams -> Sol.recover() with the real MPS 2-of-2 signing path. Only\n * chain queries are mocked.\n *\n * This proves the derived child keychain is accepted as `bitgoKey`, the re-encrypted child shares\n * decrypt and sign, and the resulting signature verifies under the derived wallet address.\n */\ndescribe('Safe SOL recovery end-to-end', function () {\n  const sandbox = Sinon.createSandbox();\n  let bitgo: TestBitGoAPI;\n  let basecoin: Tsol;\n  let roots: DecryptedSafeRoots;\n\n  before(async function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('tsol', Tsol.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tsol') as Tsol;\n\n    const [userDkg, backupDkg, bitgoDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const [vrfUser, vrfBackup] = await MpsVrfUtils.generateVrfDKGKeyShares();\n    roots = {\n      secp256k1Multisig: { user: 'u', backup: 'b', bitgo: 'g' },\n      ed25519Multisig: { user: 'u', backup: { prv: 'b', chainCode: 'c' }, bitgo: 'g' },\n      ecdsaMpc: {\n        user: { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) },\n        backup: { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) },\n        bitgo: 'g',\n      },\n      eddsaMpc: {\n        user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },\n        backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },\n        bitgo: bitgoDkg.getCommonKeychain(),\n      },\n    };\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  async function deriveChild(account: number) {\n    const derived = await deriveSafeWalletKeys({ coin: 'tsol', slot: 'eddsaMpc', account, roots });\n    assert(derived.slot === 'eddsaMpc');\n    const mpc = await EDDSAMethods.getInitializedMpcInstance();\n    const publicKey = mpc.deriveUnhardened(derived.keys.commonKeychain, 'm/0').slice(0, 64);\n    return { derived, publicKey, address: new KeyPair({ pub: publicKey }).getAddress() };\n  }\n\n  function stubChain(walletAddress: string): void {\n    const getDataFromNode = sandbox.stub(Sol.prototype, 'getDataFromNode' as keyof Sol);\n    getDataFromNode\n      .withArgs({\n        payload: { id: '1', jsonrpc: '2.0', method: 'getLatestBlockhash', params: [{ commitment: 'finalized' }] },\n      })\n      .resolves(testData.SolResponses.getBlockhashResponse);\n    getDataFromNode\n      .withArgs({ payload: { id: '1', jsonrpc: '2.0', method: 'getBalance', params: [walletAddress] } })\n      .resolves(testData.SolResponses.getAccountBalanceResponse);\n    getDataFromNode\n      .withArgs({\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getFeeForMessage',\n          params: [Sinon.match.string, { commitment: 'finalized' }],\n        },\n      })\n      .resolves(testData.SolResponses.getFeesForMessageResponse);\n  }\n\n  it('recovers a Safe SOL wallet offline: derive -> map -> sign, verifiable under the derived address', async function () {\n    const { derived, publicKey, address } = await deriveChild(0);\n    stubChain(address);\n\n    const keyParams = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'tsol',\n      slot: 'eddsaMpc',\n      keys: derived.keys,\n      mode: 'signed',\n    });\n    assert(keyParams.mode === 'signed');\n    assert.strictEqual(keyParams.isTss, true);\n    assert.strictEqual(keyParams.broadcast, false);\n    assert.strictEqual(keyParams.bitgoKey, derived.keys.commonKeychain);\n\n    const recovery = await basecoin.recover({\n      ...keyParams,\n      recoveryDestination: testData.keys.destinationPubKey,\n    });\n\n    assert('serializedTx' in recovery);\n    assert.strictEqual(recovery.scanIndex, 0);\n\n    // The signature on the recovered tx verifies under the derived child wallet key.\n    const tx = await new TransactionBuilderFactory(coins.get('tsol')).from(recovery.serializedTx).build();\n    assert.strictEqual(tx.signature.length, 1);\n    assert.strictEqual(\n      nacl.sign.detached.verify(\n        new Uint8Array(tx.signablePayload),\n        new Uint8Array(base58.decode(tx.signature[0])),\n        new Uint8Array(Buffer.from(publicKey, 'hex'))\n      ),\n      true\n    );\n  });\n\n  it('returns an unsigned sweep from the derived child address with no key material in the params', async function () {\n    const { derived, address } = await deriveChild(0);\n    stubChain(address);\n\n    const keyParams = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'tsol',\n      slot: 'eddsaMpc',\n      keys: derived.keys,\n      mode: 'unsigned',\n    });\n    assert(keyParams.mode === 'unsigned');\n    assert(!('userKey' in keyParams) && !('backupKey' in keyParams) && !('walletPassphrase' in keyParams));\n\n    const recovery = await basecoin.recover({\n      ...keyParams,\n      recoveryDestination: testData.keys.destinationPubKey,\n    });\n    assert('txRequests' in recovery);\n\n    const unsignedTx = recovery.txRequests[0].transactions[0].unsignedTx;\n    assert.strictEqual(unsignedTx.coinSpecific?.commonKeychain, derived.keys.commonKeychain);\n    assert.strictEqual(unsignedTx.derivationPath, 'm/0');\n    assert(unsignedTx.signableHex);\n    const tx = await new TransactionBuilderFactory(coins.get('tsol')).from(unsignedTx.serializedTx).build();\n    assert.strictEqual(tx.inputs[0].address, address);\n  });\n\n  it('fails closed when the signing shares belong to a different account than bitgoKey', async function () {\n    const account0 = await deriveChild(0);\n    const account1 = await deriveChild(1);\n    stubChain(account0.address);\n\n    const keyParams = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'tsol',\n      slot: 'eddsaMpc',\n      keys: account1.derived.keys,\n      mode: 'signed',\n    });\n    assert(keyParams.mode === 'signed');\n\n    await assert.rejects(\n      basecoin.recover({\n        ...keyParams,\n        bitgoKey: account0.derived.keys.commonKeychain,\n        recoveryDestination: testData.keys.destinationPubKey,\n      }),\n      /commonKeyChain from keycard does not match bitgoKey/\n    );\n  });\n\n  it('fails closed when the wallet passphrase cannot decrypt the re-encrypted child shares', async function () {\n    const { derived, address } = await deriveChild(0);\n    stubChain(address);\n\n    const keyParams = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'tsol',\n      slot: 'eddsaMpc',\n      keys: derived.keys,\n      mode: 'signed',\n    });\n    assert(keyParams.mode === 'signed');\n\n    await assert.rejects(\n      basecoin.recover({\n        ...keyParams,\n        walletPassphrase: 'not-the-ephemeral-passphrase',\n        recoveryDestination: testData.keys.destinationPubKey,\n      }),\n      /Error decrypting user keychain/\n    );\n  });\n});\n"]}