@bitgo-beta/sdk-core 8.2.1-beta.213 → 8.2.1-beta.2131

package/dist/test/unit/bitgo/recovery/initiate.js

@@ -0,0 +1,159 @@
+"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 });
+require("should");
+const sinon = __importStar(require("sinon"));
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const initiate_1 = require("../../../../src/bitgo/recovery/initiate");
+// A deterministic xprv used across all tests.
+const TEST_XPRV = 'xprv9s21ZrQH143K2fJ91S4BRsupcYrE6mmY96fcX5HkhoTrrwmwjd16Cn87cWinJjByrfpojjx7ezsJLx7TAKLT8m8hM5Kax9YcoxnBeJZ3t2k';
+const TEST_XPUB = 'xpub661MyMwAqRbcF9Nc7TbBo1rZAagiWEVPWKbDKThNG8zqjk76HAKLkaSbTn6dK2dQPfuD7xjicxCZVWvj67fP5nQ9W7QURmoMVAX8m6jZsGp';
+/**
+ * Encrypt plaintext with SJCL (legacy v1 envelope, matching `encryptionVersion: 1`).
+ */
+function sjclEncrypt(password, input) {
+    return sjcl.encrypt(password, input);
+}
+function makeMockBitGo(decryptImpl) {
+    return {
+        decrypt: sinon.stub().callsFake(async (params) => decryptImpl(params)),
+        encrypt: sinon.stub(),
+    };
+}
+describe('validateKey', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('returns a BIP32 node directly when key starts with xprv (bypasses decrypt)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: TEST_XPRV,
+            source: 'user',
+            passphrase: 'secret',
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        });
+        node.toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(0);
+    });
+    it('calls decrypt and returns BIP32 node when key is encrypted (not xprv)', async () => {
+        const passphrase = 'hunter2';
+        const encryptedKey = sjclEncrypt(passphrase, TEST_XPRV);
+        const bitgo = makeMockBitGo(({ password, input }) => {
+            if (input === encryptedKey && password === passphrase)
+                return TEST_XPRV;
+            throw new Error('unexpected decrypt call');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: encryptedKey,
+            source: 'user',
+            passphrase,
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        });
+        node.toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(1);
+    });
+    it('rejects with friendly message when decrypt fails (wrong passphrase)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('sjcl: ccm: tag does not match');
+        });
+        await (0, initiate_1.validateKey)(bitgo, {
+            key: 'notAnXprv',
+            source: 'user',
+            passphrase: 'wrong',
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        }).should.be.rejectedWith('Failed to decrypt user key with passcode - try again!');
+    });
+    it('skips decrypt for unsigned sweep (isUnsignedSweep = true)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: TEST_XPUB,
+            source: 'user',
+            passphrase: 'secret',
+            isUnsignedSweep: true,
+            isKrsRecovery: false,
+        });
+        node.neutered().toBase58().should.equal(TEST_XPUB);
+        bitgo.decrypt.callCount.should.equal(0);
+    });
+});
+describe('getBip32Keys', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('returns [userKey, backupKey] when both are provided as xprv', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' }, { requireBitGoXpub: false });
+        keys.should.have.length(2);
+        keys[0].toBase58().should.equal(TEST_XPRV);
+        keys[1].toBase58().should.equal(TEST_XPRV);
+    });
+    it('returns three keys when requireBitGoXpub is true and bitgoKey is valid', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, bitgoKey: TEST_XPUB, recoveryDestination: 'addr' }, { requireBitGoXpub: true });
+        keys.should.have.length(3);
+        keys[2].neutered().toBase58().should.equal(TEST_XPUB);
+    });
+    it('calls decrypt for encrypted user key', async () => {
+        const passphrase = 'pass1';
+        const encryptedUserKey = sjclEncrypt(passphrase, TEST_XPRV);
+        const bitgo = makeMockBitGo(({ password, input }) => {
+            if (input === encryptedUserKey && password === passphrase)
+                return TEST_XPRV;
+            throw new Error('unexpected decrypt call');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: encryptedUserKey, backupKey: TEST_XPRV, walletPassphrase: passphrase, recoveryDestination: 'addr' }, { requireBitGoXpub: false });
+        keys.should.have.length(2);
+        keys[0].toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(1);
+    });
+    it('rejects when requireBitGoXpub is true but bitgoKey is missing', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' }, { requireBitGoXpub: true }).should.be.rejectedWith('BitGo xpub required but not provided');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initiate.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/recovery/initiate.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport * as sinon from 'sinon';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport { validateKey, getBip32Keys } from '../../../../src/bitgo/recovery/initiate';\nimport { BitGoBase } from '../../../../src/bitgo/bitgoBase';\n\n// A deterministic xprv used across all tests.\nconst TEST_XPRV =\n  'xprv9s21ZrQH143K2fJ91S4BRsupcYrE6mmY96fcX5HkhoTrrwmwjd16Cn87cWinJjByrfpojjx7ezsJLx7TAKLT8m8hM5Kax9YcoxnBeJZ3t2k';\nconst TEST_XPUB =\n  'xpub661MyMwAqRbcF9Nc7TbBo1rZAagiWEVPWKbDKThNG8zqjk76HAKLkaSbTn6dK2dQPfuD7xjicxCZVWvj67fP5nQ9W7QURmoMVAX8m6jZsGp';\n\n/**\n * Encrypt plaintext with SJCL (legacy v1 envelope, matching `encryptionVersion: 1`).\n */\nfunction sjclEncrypt(password: string, input: string): string {\n  return sjcl.encrypt(password, input) as unknown as string;\n}\n\nfunction makeMockBitGo(decryptImpl: (params: { password?: string; input: string }) => string): BitGoBase {\n  return {\n    decrypt: sinon.stub().callsFake(async (params: { password?: string; input: string }) => decryptImpl(params)),\n    encrypt: sinon.stub(),\n  } as unknown as BitGoBase;\n}\n\ndescribe('validateKey', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('returns a BIP32 node directly when key starts with xprv (bypasses decrypt)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const node = await validateKey(bitgo, {\n      key: TEST_XPRV,\n      source: 'user',\n      passphrase: 'secret',\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    });\n    node.toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(0);\n  });\n\n  it('calls decrypt and returns BIP32 node when key is encrypted (not xprv)', async () => {\n    const passphrase = 'hunter2';\n    const encryptedKey = sjclEncrypt(passphrase, TEST_XPRV);\n    const bitgo = makeMockBitGo(({ password, input }) => {\n      if (input === encryptedKey && password === passphrase) return TEST_XPRV;\n      throw new Error('unexpected decrypt call');\n    });\n    const node = await validateKey(bitgo, {\n      key: encryptedKey,\n      source: 'user',\n      passphrase,\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    });\n    node.toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(1);\n  });\n\n  it('rejects with friendly message when decrypt fails (wrong passphrase)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('sjcl: ccm: tag does not match');\n    });\n    await validateKey(bitgo, {\n      key: 'notAnXprv',\n      source: 'user',\n      passphrase: 'wrong',\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    }).should.be.rejectedWith('Failed to decrypt user key with passcode - try again!');\n  });\n\n  it('skips decrypt for unsigned sweep (isUnsignedSweep = true)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const node = await validateKey(bitgo, {\n      key: TEST_XPUB,\n      source: 'user',\n      passphrase: 'secret',\n      isUnsignedSweep: true,\n      isKrsRecovery: false,\n    });\n    node.neutered().toBase58().should.equal(TEST_XPUB);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(0);\n  });\n});\n\ndescribe('getBip32Keys', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('returns [userKey, backupKey] when both are provided as xprv', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' },\n      { requireBitGoXpub: false }\n    );\n    keys.should.have.length(2);\n    keys[0].toBase58().should.equal(TEST_XPRV);\n    keys[1].toBase58().should.equal(TEST_XPRV);\n  });\n\n  it('returns three keys when requireBitGoXpub is true and bitgoKey is valid', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, bitgoKey: TEST_XPUB, recoveryDestination: 'addr' },\n      { requireBitGoXpub: true }\n    );\n    keys.should.have.length(3);\n    keys[2].neutered().toBase58().should.equal(TEST_XPUB);\n  });\n\n  it('calls decrypt for encrypted user key', async () => {\n    const passphrase = 'pass1';\n    const encryptedUserKey = sjclEncrypt(passphrase, TEST_XPRV);\n    const bitgo = makeMockBitGo(({ password, input }) => {\n      if (input === encryptedUserKey && password === passphrase) return TEST_XPRV;\n      throw new Error('unexpected decrypt call');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: encryptedUserKey, backupKey: TEST_XPRV, walletPassphrase: passphrase, recoveryDestination: 'addr' },\n      { requireBitGoXpub: false }\n    );\n    keys.should.have.length(2);\n    keys[0].toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(1);\n  });\n\n  it('rejects when requireBitGoXpub is true but bitgoKey is missing', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' },\n      { requireBitGoXpub: true }\n    ).should.be.rejectedWith('BitGo xpub required but not provided');\n  });\n});\n"]}

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.d.ts

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

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.d.ts.map

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

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.js

@@ -0,0 +1,257 @@
+"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 });
+require("should");
+const crypto_1 = require("crypto");
+const nacl = __importStar(require("tweetnacl"));
+const src_1 = require("../../../../src");
+// Cross-repo fixture: byte-identical to wallet-platform
+// test/unit/base/safes/fixtures/derivableEd25519Pub.json. Four independent implementations of this
+// format will otherwise drift, and the failure mode is unrecoverable wallets.
+const fixture = __importStar(require("./fixtures/derivableEd25519Pub.json"));
+const PUBLIC_KEY = Buffer.alloc(32);
+const CHAIN_CODE = Buffer.alloc(32, 0xab);
+const ROOT_PUB = (0, src_1.encodeDerivableEd25519Pub)(PUBLIC_KEY, CHAIN_CODE);
+const ROOT_KEYCHAIN = Buffer.concat([PUBLIC_KEY, CHAIN_CODE]).toString('hex');
+const STRKEY_PUBLIC = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';
+const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';
+describe('derivableEd25519Pub', function () {
+    describe('base32 root format', function () {
+        it('encodes 32-byte public key plus 32-byte chain code', function () {
+            src_1.DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(32);
+            src_1.DERIVABLE_ED25519_PUB_LENGTH.should.equal(103);
+            ROOT_PUB.should.match(/^[A-Z2-7]{103}$/);
+            (0, src_1.decodeDerivableEd25519Pub)(ROOT_PUB).pub.equals(PUBLIC_KEY).should.equal(true);
+            (0, src_1.decodeDerivableEd25519Pub)(ROOT_PUB).chainCode.equals(CHAIN_CODE).should.equal(true);
+        });
+        it('matches the constants pinned in the shared fixture', function () {
+            src_1.DERIVABLE_ED25519_PUB_LENGTH.should.equal(fixture.rootPubBase32Length);
+            src_1.DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(fixture.chainCodeBytes);
+        });
+        it('generates raw chain code for root composition', function () {
+            (0, src_1.generateEd25519ChainCode)().length.should.equal(32);
+        });
+    });
+    describe('fixture vectors', function () {
+        for (const vector of fixture.valid) {
+            it(`round-trips ${vector.name}`, function () {
+                const composite = (0, src_1.encodeDerivableEd25519Pub)(Buffer.from(vector.pub, 'hex'), Buffer.from(vector.chainCode, 'hex'));
+                composite.should.equal(vector.composite);
+                const decoded = (0, src_1.decodeDerivableEd25519Pub)(vector.composite);
+                decoded.pub.toString('hex').should.equal(vector.pub);
+                decoded.chainCode.toString('hex').should.equal(vector.chainCode);
+                (0, src_1.isDerivableEd25519Pub)(vector.composite).should.equal(true);
+            });
+        }
+        for (const vector of fixture.invalidComposite) {
+            it(`rejects ${vector.name}`, function () {
+                (0, src_1.isDerivableEd25519Pub)(vector.composite).should.equal(false);
+                (() => (0, src_1.decodeDerivableEd25519Pub)(vector.composite)).should.throw(/Invalid derivable ed25519 pub/);
+            });
+        }
+    });
+    describe('raw public soft derivation', function () {
+        it('derives a deterministic public key and discards the child chain code', async function () {
+            const eddsa = await src_1.Eddsa.initialize(await src_1.Ed25519BIP32.initialize());
+            const derived = eddsa.deriveUnhardened(ROOT_KEYCHAIN, 'm/7');
+            derived.length.should.equal(128);
+            derived.slice(0, 64).should.match(/^[0-9a-f]{64}$/);
+            derived.slice(64).should.match(/^[0-9a-f]{64}$/);
+            (await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 7)).toString('hex').should.equal(derived.slice(0, 64));
+        });
+        // The golden vectors below pin the unhardened derivation output shared cross-repo with
+        // wallet-platform: a divergent implementation derives co-signer keys nobody else can
+        // reproduce, permanently bricking the wallets minted with it.
+        for (const vector of fixture.softDerivation) {
+            it(`derives the pinned golden child: ${vector.name}`, async function () {
+                // The pub/chainCode fields must encode to the composite actually derived from.
+                (0, src_1.encodeDerivableEd25519Pub)(Buffer.from(vector.pub, 'hex'), Buffer.from(vector.chainCode, 'hex')).should.equal(vector.composite);
+                const child = await (0, src_1.softDeriveChildPubEd25519)(vector.composite, vector.index);
+                child.toString('hex').should.equal(vector.childPub);
+            });
+        }
+        it('rejects a hardened or out-of-range index', async function () {
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, -1).should.be.rejectedWith(/non-hardened/);
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 0x80000000).should.be.rejectedWith(/non-hardened/);
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 1.5).should.be.rejectedWith(/non-hardened/);
+        });
+        it('rejects a malformed root', async function () {
+            await (0, src_1.softDeriveChildPubEd25519)(fixture.invalidComposite[1].composite, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);
+            await (0, src_1.softDeriveChildPubEd25519)(STRKEY_PUBLIC, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);
+        });
+    });
+    describe('multi-segment soft derivation', function () {
+        const seed = (0, src_1.decodeEd25519StrKeySecretSeed)(STRKEY_SEED);
+        const rootPub = Buffer.from(nacl.sign.keyPair.fromSeed(seed).publicKey);
+        const rootChainCode = Buffer.alloc(32, 0xab);
+        const composite = (0, src_1.encodeDerivableEd25519Pub)(rootPub, rootChainCode);
+        const chainCodeStr = (0, src_1.encodeEd25519ChainCode)(rootChainCode);
+        it('private derive public half matches public derive at m/0 and m/44/283/2/0', async function () {
+            for (const path of ['m/0', 'm/44/283/2/0']) {
+                const pub = await (0, src_1.softDeriveChildPubEd25519AtPath)(composite, path);
+                const prv = await (0, src_1.softDeriveChildPrvEd25519AtPath)({ seedStrKey: STRKEY_SEED, chainCode: chainCodeStr, path });
+                prv.pub.equals(pub).should.equal(true);
+                // Recompute the public point directly from kL to prove the private scalar maps to pub.
+                (0, src_1.bigIntToBufferLE)(src_1.Eddsa.curve.basePointMult((0, src_1.bigIntFromBufferLE)(prv.kL)), 32)
+                    .equals(prv.pub)
+                    .should.equal(true);
+            }
+        });
+        it('rejects hardened and out-of-range paths', async function () {
+            await (0, src_1.softDeriveChildPubEd25519AtPath)(composite, "m/0'").should.be.rejectedWith(/Invalid soft derivation path/);
+            await (0, src_1.softDeriveChildPrvEd25519AtPath)({
+                seedStrKey: STRKEY_SEED,
+                chainCode: chainCodeStr,
+                path: "m/0'",
+            }).should.be.rejectedWith(/Invalid soft derivation path/);
+            await (0, src_1.softDeriveChildPubEd25519AtPath)(composite, 'm/2147483648').should.be.rejectedWith(/out of range/);
+        });
+    });
+    describe('Stellar user-key codecs', function () {
+        it('keeps Stellar encoding separate from the neutral root format', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)(STRKEY_PUBLIC).should.equal(true);
+            (0, src_1.encodeEd25519StrKeyPublicKey)((0, src_1.decodeEd25519StrKeyPublicKey)(STRKEY_PUBLIC)).should.equal(STRKEY_PUBLIC);
+            (0, src_1.decodeEd25519StrKeySecretSeed)(STRKEY_SEED).length.should.equal(32);
+            (0, src_1.isDerivableEd25519Pub)(STRKEY_PUBLIC).should.equal(false);
+            (0, src_1.isChecksumValidStrKeyEd25519Pub)(STRKEY_PUBLIC).should.equal(true);
+        });
+        it('rejects a public key with a corrupted checksum', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYA').should.equal(false);
+        });
+        it('rejects a secret seed where a public key is required', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH').should.equal(false);
+            (() => (0, src_1.decodeEd25519StrKeyPublicKey)('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH')).should.throw(/StrKey public key/);
+        });
+        it('rejects a non-base32 character, the empty string, and lowercase', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKY1').should.equal(false);
+            (0, src_1.isValidEd25519StrKeyPublicKey)('').should.equal(false);
+            (0, src_1.isValidEd25519StrKeyPublicKey)(STRKEY_PUBLIC.toLowerCase()).should.equal(false);
+        });
+    });
+    describe('extended-key signing', function () {
+        const seed = (0, src_1.decodeEd25519StrKeySecretSeed)(STRKEY_SEED);
+        const message = Buffer.from('extended-key signature');
+        const rootChainCode = Buffer.alloc(32, 0xab);
+        const chainCodeStr = (0, src_1.encodeEd25519ChainCode)(rootChainCode);
+        it('matches the seed-based signer for a seed-backed key', async function () {
+            const h = (0, crypto_1.createHash)('sha512').update(seed).digest();
+            const kL = (0, src_1.bigIntToBufferLE)((0, src_1.clamp)((0, src_1.bigIntFromBufferLE)(h.subarray(0, 32))), 32);
+            const kR = h.subarray(32);
+            const sig = await (0, src_1.signEd25519Extended)(message, kL, kR);
+            const expected = Buffer.from(nacl.sign.detached(message, nacl.sign.keyPair.fromSeed(seed).secretKey));
+            sig.equals(expected).should.equal(true);
+        });
+        it('signs a soft-derived key with no seed and verifies against its pub', async function () {
+            const prv = await (0, src_1.softDeriveChildPrvEd25519AtPath)({
+                seedStrKey: STRKEY_SEED,
+                chainCode: chainCodeStr,
+                path: 'm/0',
+            });
+            const sig = await (0, src_1.signEd25519Extended)(message, prv.kL, prv.kR);
+            nacl.sign.detached.verify(message, sig, prv.pub).should.equal(true);
+            // The soft-derived scalar has no seed: treating kL as a seed yields a different pub.
+            Buffer.from(nacl.sign.keyPair.fromSeed(prv.kL).publicKey).equals(prv.pub).should.equal(false);
+        });
+        it('rejects kL/kR that are not 32 bytes', async function () {
+            await (0, src_1.signEd25519Extended)(message, Buffer.alloc(31), Buffer.alloc(32)).should.be.rejectedWith(/kL length/);
+            await (0, src_1.signEd25519Extended)(message, Buffer.alloc(32), Buffer.alloc(33)).should.be.rejectedWith(/kR length/);
+        });
+    });
+    describe('ExternalEd25519Signer', function () {
+        const message = Buffer.from('external-signer message');
+        const keyPair = nacl.sign.keyPair.fromSeed(Buffer.alloc(32, 0x42));
+        const publicKey = Buffer.from(keyPair.publicKey).toString('hex');
+        const otherKeyPair = nacl.sign.keyPair.fromSeed(Buffer.alloc(32, 0x77));
+        const validSigner = {
+            publicKey,
+            sign: async (m) => ({
+                signature: Buffer.from(nacl.sign.detached(m, keyPair.secretKey)).toString('hex'),
+            }),
+        };
+        it('rejects a malformed public key', function () {
+            (() => (0, src_1.assertValidExternalEd25519Signer)({
+                publicKey: 'not-hex',
+                sign: async () => ({ signature: 'a'.repeat(128) }),
+            })).should.throw(/expected 32 bytes/);
+        });
+        it('rejects a public key with trailing garbage after 64 hex chars', function () {
+            // Buffer.from(pub, 'hex') truncates at the first bad pair, so a length-only check would
+            // accept this; the strict regex must not.
+            (() => (0, src_1.assertValidExternalEd25519Signer)({
+                publicKey: 'f1'.repeat(32) + 'zz',
+                sign: async () => ({ signature: 'a'.repeat(128) }),
+            })).should.throw(/expected 32 bytes/);
+        });
+        it('rejects a signer without a sign function', function () {
+            (() => (0, src_1.assertValidExternalEd25519Signer)({
+                publicKey,
+                sign: undefined,
+            })).should.throw(/sign must be a function/);
+        });
+        it('rejects a non-64-byte signature', async function () {
+            await (0, src_1.signWithExternalEd25519Signer)({ publicKey, sign: async () => ({ signature: 'ab' }) }, message).should.be.rejectedWith(/expected 64 bytes/);
+        });
+        it('rejects when sign resolves to a non-object', async function () {
+            await (0, src_1.signWithExternalEd25519Signer)({ publicKey, sign: async () => null }, message).should.be.rejectedWith(/sign must resolve to \{ signature: string \}/);
+        });
+        it('rejects a well-formed signature from the wrong key', async function () {
+            await (0, src_1.signWithExternalEd25519Signer)({
+                publicKey,
+                sign: async (m) => ({
+                    signature: Buffer.from(nacl.sign.detached(m, otherKeyPair.secretKey)).toString('hex'),
+                }),
+            }, message).should.be.rejectedWith(/does not verify against its public key/);
+        });
+        it('signs and returns a verified 64-byte signature', async function () {
+            const signature = await (0, src_1.signWithExternalEd25519Signer)(validSigner, message);
+            signature.should.match(/^[0-9a-f]{128}$/);
+            nacl.sign.detached.verify(message, Buffer.from(signature, 'hex'), keyPair.publicKey).should.equal(true);
+        });
+        it('rejects a signer that mutates its message argument, leaving the original message intact', async function () {
+            const originalMessage = Uint8Array.from(message);
+            const mutatingSigner = {
+                publicKey,
+                sign: async (m) => {
+                    m.fill(0x00);
+                    return { signature: Buffer.from(nacl.sign.detached(m, keyPair.secretKey)).toString('hex') };
+                },
+            };
+            await (0, src_1.signWithExternalEd25519Signer)(mutatingSigner, originalMessage).should.be.rejectedWith(/does not verify against its public key/);
+            // The authoritative message must be unchanged: the signer only ever saw a defensive copy.
+            Buffer.from(originalMessage).equals(Buffer.from(message)).should.equal(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"derivableEd25519Pub.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/derivableEd25519Pub.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { createHash } from 'crypto';\nimport * as nacl from 'tweetnacl';\nimport {\n  DERIVABLE_ED25519_CHAIN_CODE_BYTES,\n  DERIVABLE_ED25519_PUB_LENGTH,\n  Ed25519BIP32,\n  Eddsa,\n  bigIntFromBufferLE,\n  bigIntToBufferLE,\n  clamp,\n  decodeDerivableEd25519Pub,\n  decodeEd25519StrKeyPublicKey,\n  decodeEd25519StrKeySecretSeed,\n  encodeDerivableEd25519Pub,\n  encodeEd25519ChainCode,\n  encodeEd25519StrKeyPublicKey,\n  generateEd25519ChainCode,\n  assertValidExternalEd25519Signer,\n  signWithExternalEd25519Signer,\n  isChecksumValidStrKeyEd25519Pub,\n  isDerivableEd25519Pub,\n  isValidEd25519StrKeyPublicKey,\n  signEd25519Extended,\n  softDeriveChildPubEd25519,\n  softDeriveChildPubEd25519AtPath,\n  softDeriveChildPrvEd25519AtPath,\n  type ExternalEd25519Signer,\n} from '../../../../src';\n\n// Cross-repo fixture: byte-identical to wallet-platform\n// test/unit/base/safes/fixtures/derivableEd25519Pub.json. Four independent implementations of this\n// format will otherwise drift, and the failure mode is unrecoverable wallets.\nimport * as fixture from './fixtures/derivableEd25519Pub.json';\n\nconst PUBLIC_KEY = Buffer.alloc(32);\nconst CHAIN_CODE = Buffer.alloc(32, 0xab);\nconst ROOT_PUB = encodeDerivableEd25519Pub(PUBLIC_KEY, CHAIN_CODE);\nconst ROOT_KEYCHAIN = Buffer.concat([PUBLIC_KEY, CHAIN_CODE]).toString('hex');\nconst STRKEY_PUBLIC = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';\nconst STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';\n\ndescribe('derivableEd25519Pub', function () {\n  describe('base32 root format', function () {\n    it('encodes 32-byte public key plus 32-byte chain code', function () {\n      DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(32);\n      DERIVABLE_ED25519_PUB_LENGTH.should.equal(103);\n      ROOT_PUB.should.match(/^[A-Z2-7]{103}$/);\n      decodeDerivableEd25519Pub(ROOT_PUB).pub.equals(PUBLIC_KEY).should.equal(true);\n      decodeDerivableEd25519Pub(ROOT_PUB).chainCode.equals(CHAIN_CODE).should.equal(true);\n    });\n\n    it('matches the constants pinned in the shared fixture', function () {\n      DERIVABLE_ED25519_PUB_LENGTH.should.equal(fixture.rootPubBase32Length);\n      DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(fixture.chainCodeBytes);\n    });\n\n    it('generates raw chain code for root composition', function () {\n      generateEd25519ChainCode().length.should.equal(32);\n    });\n  });\n\n  describe('fixture vectors', function () {\n    for (const vector of fixture.valid) {\n      it(`round-trips ${vector.name}`, function () {\n        const composite = encodeDerivableEd25519Pub(\n          Buffer.from(vector.pub, 'hex'),\n          Buffer.from(vector.chainCode, 'hex')\n        );\n        composite.should.equal(vector.composite);\n        const decoded = decodeDerivableEd25519Pub(vector.composite);\n        decoded.pub.toString('hex').should.equal(vector.pub);\n        decoded.chainCode.toString('hex').should.equal(vector.chainCode);\n        isDerivableEd25519Pub(vector.composite).should.equal(true);\n      });\n    }\n\n    for (const vector of fixture.invalidComposite) {\n      it(`rejects ${vector.name}`, function () {\n        isDerivableEd25519Pub(vector.composite).should.equal(false);\n        (() => decodeDerivableEd25519Pub(vector.composite)).should.throw(/Invalid derivable ed25519 pub/);\n      });\n    }\n  });\n\n  describe('raw public soft derivation', function () {\n    it('derives a deterministic public key and discards the child chain code', async function () {\n      const eddsa = await Eddsa.initialize(await Ed25519BIP32.initialize());\n      const derived = eddsa.deriveUnhardened(ROOT_KEYCHAIN, 'm/7');\n      derived.length.should.equal(128);\n      derived.slice(0, 64).should.match(/^[0-9a-f]{64}$/);\n      derived.slice(64).should.match(/^[0-9a-f]{64}$/);\n      (await softDeriveChildPubEd25519(ROOT_PUB, 7)).toString('hex').should.equal(derived.slice(0, 64));\n    });\n\n    // The golden vectors below pin the unhardened derivation output shared cross-repo with\n    // wallet-platform: a divergent implementation derives co-signer keys nobody else can\n    // reproduce, permanently bricking the wallets minted with it.\n    for (const vector of fixture.softDerivation) {\n      it(`derives the pinned golden child: ${vector.name}`, async function () {\n        // The pub/chainCode fields must encode to the composite actually derived from.\n        encodeDerivableEd25519Pub(Buffer.from(vector.pub, 'hex'), Buffer.from(vector.chainCode, 'hex')).should.equal(\n          vector.composite\n        );\n        const child = await softDeriveChildPubEd25519(vector.composite, vector.index);\n        child.toString('hex').should.equal(vector.childPub);\n      });\n    }\n\n    it('rejects a hardened or out-of-range index', async function () {\n      await softDeriveChildPubEd25519(ROOT_PUB, -1).should.be.rejectedWith(/non-hardened/);\n      await softDeriveChildPubEd25519(ROOT_PUB, 0x80000000).should.be.rejectedWith(/non-hardened/);\n      await softDeriveChildPubEd25519(ROOT_PUB, 1.5).should.be.rejectedWith(/non-hardened/);\n    });\n\n    it('rejects a malformed root', async function () {\n      await softDeriveChildPubEd25519(fixture.invalidComposite[1].composite, 0).should.be.rejectedWith(\n        /Invalid derivable ed25519 pub/\n      );\n      await softDeriveChildPubEd25519(STRKEY_PUBLIC, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);\n    });\n  });\n\n  describe('multi-segment soft derivation', function () {\n    const seed = decodeEd25519StrKeySecretSeed(STRKEY_SEED);\n    const rootPub = Buffer.from(nacl.sign.keyPair.fromSeed(seed).publicKey);\n    const rootChainCode = Buffer.alloc(32, 0xab);\n    const composite = encodeDerivableEd25519Pub(rootPub, rootChainCode);\n    const chainCodeStr = encodeEd25519ChainCode(rootChainCode);\n\n    it('private derive public half matches public derive at m/0 and m/44/283/2/0', async function () {\n      for (const path of ['m/0', 'm/44/283/2/0']) {\n        const pub = await softDeriveChildPubEd25519AtPath(composite, path);\n        const prv = await softDeriveChildPrvEd25519AtPath({ seedStrKey: STRKEY_SEED, chainCode: chainCodeStr, path });\n        prv.pub.equals(pub).should.equal(true);\n        // Recompute the public point directly from kL to prove the private scalar maps to pub.\n        bigIntToBufferLE(Eddsa.curve.basePointMult(bigIntFromBufferLE(prv.kL)), 32)\n          .equals(prv.pub)\n          .should.equal(true);\n      }\n    });\n\n    it('rejects hardened and out-of-range paths', async function () {\n      await softDeriveChildPubEd25519AtPath(composite, \"m/0'\").should.be.rejectedWith(/Invalid soft derivation path/);\n      await softDeriveChildPrvEd25519AtPath({\n        seedStrKey: STRKEY_SEED,\n        chainCode: chainCodeStr,\n        path: \"m/0'\",\n      }).should.be.rejectedWith(/Invalid soft derivation path/);\n      await softDeriveChildPubEd25519AtPath(composite, 'm/2147483648').should.be.rejectedWith(/out of range/);\n    });\n  });\n\n  describe('Stellar user-key codecs', function () {\n    it('keeps Stellar encoding separate from the neutral root format', function () {\n      isValidEd25519StrKeyPublicKey(STRKEY_PUBLIC).should.equal(true);\n      encodeEd25519StrKeyPublicKey(decodeEd25519StrKeyPublicKey(STRKEY_PUBLIC)).should.equal(STRKEY_PUBLIC);\n      decodeEd25519StrKeySecretSeed(STRKEY_SEED).length.should.equal(32);\n      isDerivableEd25519Pub(STRKEY_PUBLIC).should.equal(false);\n      isChecksumValidStrKeyEd25519Pub(STRKEY_PUBLIC).should.equal(true);\n    });\n\n    it('rejects a public key with a corrupted checksum', function () {\n      isValidEd25519StrKeyPublicKey('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYA').should.equal(false);\n    });\n\n    it('rejects a secret seed where a public key is required', function () {\n      isValidEd25519StrKeyPublicKey('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH').should.equal(false);\n      (() => decodeEd25519StrKeyPublicKey('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH')).should.throw(\n        /StrKey public key/\n      );\n    });\n\n    it('rejects a non-base32 character, the empty string, and lowercase', function () {\n      isValidEd25519StrKeyPublicKey('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKY1').should.equal(false);\n      isValidEd25519StrKeyPublicKey('').should.equal(false);\n      isValidEd25519StrKeyPublicKey(STRKEY_PUBLIC.toLowerCase()).should.equal(false);\n    });\n  });\n\n  describe('extended-key signing', function () {\n    const seed = decodeEd25519StrKeySecretSeed(STRKEY_SEED);\n    const message = Buffer.from('extended-key signature');\n    const rootChainCode = Buffer.alloc(32, 0xab);\n    const chainCodeStr = encodeEd25519ChainCode(rootChainCode);\n\n    it('matches the seed-based signer for a seed-backed key', async function () {\n      const h = createHash('sha512').update(seed).digest();\n      const kL = bigIntToBufferLE(clamp(bigIntFromBufferLE(h.subarray(0, 32))), 32);\n      const kR = h.subarray(32);\n      const sig = await signEd25519Extended(message, kL, kR);\n      const expected = Buffer.from(nacl.sign.detached(message, nacl.sign.keyPair.fromSeed(seed).secretKey));\n      sig.equals(expected).should.equal(true);\n    });\n\n    it('signs a soft-derived key with no seed and verifies against its pub', async function () {\n      const prv = await softDeriveChildPrvEd25519AtPath({\n        seedStrKey: STRKEY_SEED,\n        chainCode: chainCodeStr,\n        path: 'm/0',\n      });\n      const sig = await signEd25519Extended(message, prv.kL, prv.kR);\n      nacl.sign.detached.verify(message, sig, prv.pub).should.equal(true);\n      // The soft-derived scalar has no seed: treating kL as a seed yields a different pub.\n      Buffer.from(nacl.sign.keyPair.fromSeed(prv.kL).publicKey).equals(prv.pub).should.equal(false);\n    });\n\n    it('rejects kL/kR that are not 32 bytes', async function () {\n      await signEd25519Extended(message, Buffer.alloc(31), Buffer.alloc(32)).should.be.rejectedWith(/kL length/);\n      await signEd25519Extended(message, Buffer.alloc(32), Buffer.alloc(33)).should.be.rejectedWith(/kR length/);\n    });\n  });\n\n  describe('ExternalEd25519Signer', function () {\n    const message = Buffer.from('external-signer message');\n    const keyPair = nacl.sign.keyPair.fromSeed(Buffer.alloc(32, 0x42));\n    const publicKey = Buffer.from(keyPair.publicKey).toString('hex');\n    const otherKeyPair = nacl.sign.keyPair.fromSeed(Buffer.alloc(32, 0x77));\n    const validSigner: ExternalEd25519Signer = {\n      publicKey,\n      sign: async (m: Uint8Array) => ({\n        signature: Buffer.from(nacl.sign.detached(m, keyPair.secretKey)).toString('hex'),\n      }),\n    };\n\n    it('rejects a malformed public key', function () {\n      (() =>\n        assertValidExternalEd25519Signer({\n          publicKey: 'not-hex',\n          sign: async () => ({ signature: 'a'.repeat(128) }),\n        })).should.throw(/expected 32 bytes/);\n    });\n\n    it('rejects a public key with trailing garbage after 64 hex chars', function () {\n      // Buffer.from(pub, 'hex') truncates at the first bad pair, so a length-only check would\n      // accept this; the strict regex must not.\n      (() =>\n        assertValidExternalEd25519Signer({\n          publicKey: 'f1'.repeat(32) + 'zz',\n          sign: async () => ({ signature: 'a'.repeat(128) }),\n        })).should.throw(/expected 32 bytes/);\n    });\n\n    it('rejects a signer without a sign function', function () {\n      (() =>\n        assertValidExternalEd25519Signer({\n          publicKey,\n          sign: undefined as unknown as ExternalEd25519Signer['sign'],\n        })).should.throw(/sign must be a function/);\n    });\n\n    it('rejects a non-64-byte signature', async function () {\n      await signWithExternalEd25519Signer(\n        { publicKey, sign: async () => ({ signature: 'ab' }) },\n        message\n      ).should.be.rejectedWith(/expected 64 bytes/);\n    });\n\n    it('rejects when sign resolves to a non-object', async function () {\n      await signWithExternalEd25519Signer(\n        { publicKey, sign: async () => null as unknown as { signature: string } },\n        message\n      ).should.be.rejectedWith(/sign must resolve to \\{ signature: string \\}/);\n    });\n\n    it('rejects a well-formed signature from the wrong key', async function () {\n      await signWithExternalEd25519Signer(\n        {\n          publicKey,\n          sign: async (m: Uint8Array) => ({\n            signature: Buffer.from(nacl.sign.detached(m, otherKeyPair.secretKey)).toString('hex'),\n          }),\n        },\n        message\n      ).should.be.rejectedWith(/does not verify against its public key/);\n    });\n\n    it('signs and returns a verified 64-byte signature', async function () {\n      const signature = await signWithExternalEd25519Signer(validSigner, message);\n      signature.should.match(/^[0-9a-f]{128}$/);\n      nacl.sign.detached.verify(message, Buffer.from(signature, 'hex'), keyPair.publicKey).should.equal(true);\n    });\n\n    it('rejects a signer that mutates its message argument, leaving the original message intact', async function () {\n      const originalMessage = Uint8Array.from(message);\n      const mutatingSigner: ExternalEd25519Signer = {\n        publicKey,\n        sign: async (m: Uint8Array) => {\n          m.fill(0x00);\n          return { signature: Buffer.from(nacl.sign.detached(m, keyPair.secretKey)).toString('hex') };\n        },\n      };\n      await signWithExternalEd25519Signer(mutatingSigner, originalMessage).should.be.rejectedWith(\n        /does not verify against its public key/\n      );\n      // The authoritative message must be unchanged: the signer only ever saw a defensive copy.\n      Buffer.from(originalMessage).equals(Buffer.from(message)).should.equal(true);\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/safe/fixtures/derivableEd25519Pub.json

@@ -0,0 +1,72 @@
+{
+    "$comment": "Shared ed25519Multisig safe-root fixture: raw 32-byte public key || raw 32-byte chain code encoded together as canonical unpadded RFC 4648 base32 (uppercase A-Z2-7, 103 characters). Plain JSON with no repo-specific imports so wallet-platform, BitGoJS sdk-core, BitGoJS modules/key-card and WRW can all consume this identical file. The final base32 character carries 2 significant bits and 3 zero padding bits, so 8 spellings decode to the same 64 bytes and only the zero-padded one is valid — validators must re-encode, not just match the alphabet. The softDerivation vectors pin the m/<index> unhardened child public key expected from a root: they were generated with @bitgo-beta/account-lib's Eddsa.deriveUnhardened (via @bitgo-beta/sdk-core) over genuine ed25519 points, and every consuming implementation MUST reproduce them exactly — a divergent unhardened derivation derives co-signer keys nobody else can reproduce, permanently bricking the wallets minted with it. The child chain code is deliberately not pinned: consumers discard it after deriving the child public key.",
+    "publicKeyBytes": 32,
+    "chainCodeBytes": 32,
+    "rootPubBase32Length": 103,
+    "valid": [
+        {
+            "name": "zero public key and repeated chain code",
+            "pub": "0000000000000000000000000000000000000000000000000000000000000000",
+            "chainCode": "abababababababababababababababababababababababababababababababab",
+            "composite": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XKY"
+        },
+        {
+            "name": "mixed public key and chain code",
+            "pub": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+            "chainCode": "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210",
+            "composite": "AERUKZ4JVPG66AJDIVTYTK6N54ASGRLHRGV433YBENCWPCNLZXX75XF2TB3FIMQQ73OLVGDWKQZBB7W4XKMHMVBSCD7NZOUYOZKDEEA"
+        },
+        {
+            "name": "typical public key with a mixed chain code",
+            "pub": "d5a7c39b1f84e206a93f7c4b8d2e615f0a9c3b7e5d1f48c2a6b0e3947f518d26",
+            "chainCode": "3c9f1a7b5e2d84c6a0f3b9d7e1c5a2846f0b3d9e7c1a5f8b2d04e6c9a3f7b1d5",
+            "composite": "2WT4HGY7QTRANKJ7PRFY2LTBL4FJYO36LUPURQVGWDRZI72RRUTDZHY2PNPC3BGGUDZ3TV7BYWRII3YLHWPHYGS7RMWQJZWJUP33DVI"
+        },
+        {
+            "name": "typical public key with a repeating chain code",
+            "pub": "9b2f7d4a1e8c3b6f5a0d9e2c7b4f1a8d3e6c9b2f5a8d1e4c7b0f3a6d9e2c5b81",
+            "chainCode": "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+            "composite": "TMXX2SQ6RQ5W6WQNTYWHWTY2RU7GZGZPLKGR4TD3B45G3HRMLOA43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TI"
+        }
+    ],
+    "invalidComposite": [
+        {
+            "name": "lowercase",
+            "composite": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaakxk5lvov2xk5lvov2xk5lvov2xk5lvov2xk5lvov2xk5lvov2xky"
+        },
+        {
+            "name": "short",
+            "composite": "AA"
+        },
+        {
+            "name": "non-canonical trailing bits",
+            "composite": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XKZ"
+        }
+    ],
+    "softDerivation": [
+        {
+            "name": "root A at m/0",
+            "index": 0,
+            "pub": "07a2206d82e1238043906260d95f86e046056610756050d558d282476556d0a6",
+            "chainCode": "1111111111111111111111111111111111111111111111111111111111111111",
+            "composite": "A6RCA3MC4ERYAQ4QMJQNSX4G4BDAKZQQOVQFBVKY2KBEOZKW2CTBCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEI",
+            "childPub": "3cec3c1be67f00f8f8d5a33cc3937ba7d7da96a79332af622942f38150f32d6e"
+        },
+        {
+            "name": "root A at m/1",
+            "index": 1,
+            "pub": "07a2206d82e1238043906260d95f86e046056610756050d558d282476556d0a6",
+            "chainCode": "1111111111111111111111111111111111111111111111111111111111111111",
+            "composite": "A6RCA3MC4ERYAQ4QMJQNSX4G4BDAKZQQOVQFBVKY2KBEOZKW2CTBCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEI",
+            "childPub": "b315782a33f863e87a40731157456e62ce7d4e941cfb2e3f71c56edb993bf7af"
+        },
+        {
+            "name": "root B at max non-hardened m/2147483647",
+            "index": 2147483647,
+            "pub": "6af98980a20d1d090d729aee97e8cab65df61eeec9dc7b6070baa6b0e02f860d",
+            "chainCode": "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+            "composite": "NL4YTAFCBUOQSDLSTLXJP2GKWZO7MHXOZHOHWYDQXKTLBYBPQYG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TI",
+            "childPub": "acda5ebd6543ed99141eb9da0cf1101e3ce11a637ee83743786b67a3b319439e"
+        }
+    ]
+}