@bitgo-beta/utxo-staking 1.1.1-beta.84 → 1.1.1-beta.841

package/dist/cjs/test/unit/coreDao/opReturn.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const testutil_1 = require("@bitgo-beta/utxo-core/testutil");
+const coreDao_1 = require("../../../src/coreDao");
+describe('OP_RETURN', function () {
+    const validVersion = 2;
+    const validChainId = coreDao_1.CORE_DAO_MAINNET_CHAIN_ID;
+    // random 20 byte buffers
+    const validDelegator = Buffer.alloc(20, utxo_lib_1.testutil.getKey('wasm-possum').publicKey);
+    const validValidator = Buffer.alloc(20, utxo_lib_1.testutil.getKey('possum-wasm').publicKey);
+    const validFee = 1;
+    const validRedeemScript = Buffer.from('522103a8295453660d5e212d55556666666666666666666666666666666666', 'hex');
+    const validTimelock = 800800;
+    let defaultScript;
+    before(async function () {
+        // https://docs.coredao.org/docs/Learn/products/btc-staking/design#op_return-output-1
+        const script = await (0, testutil_1.getFixture)('test/fixtures/coreDao/opReturn/documentation.txt', undefined);
+        (0, assert_1.default)(typeof script === 'string');
+        defaultScript = script;
+    });
+    describe('createCoreDaoOpReturnOutputScript', function () {
+        it('should throw if invalid parameters are passed', function () {
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: 292,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            }));
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: Buffer.alloc(32, 0),
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            }));
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: Buffer.alloc(19, 0),
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            }));
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: Buffer.alloc(19, 0),
+                fee: validFee,
+                timelock: validTimelock,
+            }));
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: 256,
+                timelock: validTimelock,
+            }));
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: -1,
+            }));
+        });
+        it('should throw if the length of the script is too long', function () {
+            assert_1.default.throws(() => (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                redeemScript: Buffer.alloc(100),
+            }));
+        });
+        it('should return a buffer with the correct length', function () {
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            });
+            // Make sure that the first byte is the OP_RETURN opcode
+            assert_1.default.strictEqual(script[0], 0x6a);
+            // Make sure that the length of the script matches what is in the buffer
+            assert_1.default.strictEqual(
+            // We do not count the OP_RETURN opcode or the bytes for the length
+            script.length - 2, script[1]);
+        });
+        it('should have the correct placement of the values provided with a redeem script', function () {
+            // This should produce an Op_RETURN that needs the extra push bytes for the length
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                redeemScript: validRedeemScript,
+            });
+            // Make sure that the first byte is the OP_RETURN opcode
+            assert_1.default.strictEqual(script[0], 0x6a);
+            // Make sure that the length of the script matches what is in the buffer
+            assert_1.default.strictEqual(script[1], 0x4c);
+            assert_1.default.strictEqual(
+            // We do not count the OP_RETURN opcode or the length + pushbytes
+            script.length - 3, script[2]);
+            // Satoshi plus identifier
+            assert_1.default.deepStrictEqual(script.subarray(3, 7).toString('hex'), coreDao_1.CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));
+            // Make sure that the version is correct
+            assert_1.default.strictEqual(script[7], validVersion);
+            // Make sure that the chainId is correct
+            assert_1.default.deepStrictEqual(script.subarray(8, 10).toString('hex'), validChainId.toString('hex'));
+            // Make sure that the delegator is correct
+            assert_1.default.deepStrictEqual(script.subarray(10, 30).toString('hex'), validDelegator.toString('hex'));
+            // Make sure that the validator is correct
+            assert_1.default.deepStrictEqual(script.subarray(30, 50).toString('hex'), validValidator.toString('hex'));
+            // Make sure that the fee is correct
+            assert_1.default.strictEqual(script[50], validFee);
+            // Make sure that the redeemScript is correct
+            assert_1.default.deepStrictEqual(script.subarray(51, 51 + validRedeemScript.length).toString('hex'), validRedeemScript.toString('hex'));
+        });
+        it('should have the correct placement of the values provided with a blockheight timelock', function () {
+            // This should produce an Op_RETURN that needs the extra push bytes for the length
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            });
+            // Make sure that the first byte is the OP_RETURN opcode
+            assert_1.default.strictEqual(script[0], 0x6a);
+            // Make sure that the length of the script matches what is in the buffer
+            assert_1.default.strictEqual(
+            // We do not count the OP_RETURN opcode or the length
+            script.length - 2, script[1]);
+            // Satoshi plus identifier
+            assert_1.default.deepStrictEqual(script.subarray(2, 6).toString('hex'), coreDao_1.CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));
+            // Make sure that the version is correct
+            assert_1.default.strictEqual(script[6], validVersion);
+            // Make sure that the chainId is correct
+            assert_1.default.deepStrictEqual(script.subarray(7, 9).toString('hex'), validChainId.toString('hex'));
+            // Make sure that the delegator is correct
+            assert_1.default.deepStrictEqual(script.subarray(9, 29).toString('hex'), validDelegator.toString('hex'));
+            // Make sure that the validator is correct
+            assert_1.default.deepStrictEqual(script.subarray(29, 49).toString('hex'), validValidator.toString('hex'));
+            // Make sure that the fee is correct
+            assert_1.default.strictEqual(script[49], validFee);
+            // Make sure that the redeemScript is correct
+            assert_1.default.deepStrictEqual(script.subarray(50, 54).toString('hex'), (0, coreDao_1.encodeTimelock)(validTimelock).toString('hex'));
+            assert_1.default.deepStrictEqual((0, coreDao_1.decodeTimelock)(script.subarray(50, 54)), validTimelock);
+        });
+        it('should have the correct placement of the values provided with a time timelock', function () {
+            // This should produce an Op_RETURN that needs the extra push bytes for the length
+            const timelock = new Date('2022-01-01T00:00:00Z').getTime() / 1000;
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock,
+            });
+            // Make sure that the first byte is the OP_RETURN opcode
+            assert_1.default.strictEqual(script[0], 0x6a);
+            // Make sure that the length of the script matches what is in the buffer
+            assert_1.default.strictEqual(
+            // We do not count the OP_RETURN opcode or the length
+            script.length - 2, script[1]);
+            // Satoshi plus identifier
+            assert_1.default.deepStrictEqual(script.subarray(2, 6).toString('hex'), coreDao_1.CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));
+            // Make sure that the version is correct
+            assert_1.default.strictEqual(script[6], validVersion);
+            // Make sure that the chainId is correct
+            assert_1.default.deepStrictEqual(script.subarray(7, 9).toString('hex'), validChainId.toString('hex'));
+            // Make sure that the delegator is correct
+            assert_1.default.deepStrictEqual(script.subarray(9, 29).toString('hex'), validDelegator.toString('hex'));
+            // Make sure that the validator is correct
+            assert_1.default.deepStrictEqual(script.subarray(29, 49).toString('hex'), validValidator.toString('hex'));
+            // Make sure that the fee is correct
+            assert_1.default.strictEqual(script[49], validFee);
+            // Make sure that the redeemScript is correct
+            assert_1.default.deepStrictEqual(script.subarray(50, 54).toString('hex'), (0, coreDao_1.encodeTimelock)(timelock).toString('hex'));
+            assert_1.default.deepStrictEqual((0, coreDao_1.decodeTimelock)(script.subarray(50, 54)), timelock);
+        });
+        it('should recreate the example OP_RETURN correctly', function () {
+            assert_1.default.deepStrictEqual((0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: 1,
+                chainId: Buffer.from('045b', 'hex'),
+                delegator: Buffer.from('de60b7d0e6b758ca5dd8c61d377a2c5f1af51ec1', 'hex'),
+                validator: Buffer.from('a9e209f5ea0036c8c2f41078a3cebee57d8a47d5', 'hex'),
+                fee: 1,
+                redeemScript: Buffer.from('041f5e0e66b17576a914c4b8ae927ff2b9ce218e20bf06d425d6b68424fd88ac', 'hex'),
+            }).toString('hex'), defaultScript);
+        });
+    });
+    describe('parseCoreDaoOpReturnOutputScript', function () {
+        it('should parse a valid script with a timelock', function () {
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                timelock: validTimelock,
+            });
+            const parsed = (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(script);
+            assert_1.default.strictEqual(parsed.version, validVersion);
+            assert_1.default.deepStrictEqual(parsed.chainId, validChainId);
+            assert_1.default.deepStrictEqual(parsed.delegator, validDelegator);
+            assert_1.default.deepStrictEqual(parsed.validator, validValidator);
+            assert_1.default.strictEqual(parsed.fee, validFee);
+            (0, assert_1.default)('timelock' in parsed);
+            assert_1.default.deepStrictEqual(parsed.timelock, validTimelock);
+        });
+        it('should parse a valid script with a redeem script', function () {
+            const script = (0, coreDao_1.createCoreDaoOpReturnOutputScript)({
+                version: validVersion,
+                chainId: validChainId,
+                delegator: validDelegator,
+                validator: validValidator,
+                fee: validFee,
+                redeemScript: validRedeemScript,
+            });
+            const parsed = (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(script);
+            assert_1.default.strictEqual(parsed.version, validVersion);
+            assert_1.default.deepStrictEqual(parsed.chainId, validChainId);
+            assert_1.default.deepStrictEqual(parsed.delegator, validDelegator);
+            assert_1.default.deepStrictEqual(parsed.validator, validValidator);
+            assert_1.default.strictEqual(parsed.fee, validFee);
+            (0, assert_1.default)('redeemScript' in parsed);
+            assert_1.default.deepStrictEqual(parsed.redeemScript, validRedeemScript);
+        });
+        it('should parse valid opreturn script from testnet', async function () {
+            // Source: https://mempool.space/testnet/tx/66ed4cea26a410248a6d87f14b2bca514f33920c54d4af63ed46a903793115d5
+            const baseFixturePath = 'test/fixtures/coreDao/opReturn/66ed4cea26a410248a6d87f14b2bca514f33920c54d4af63ed46a903793115d5';
+            const opReturnHex = await (0, testutil_1.getFixture)(baseFixturePath + '.txt', undefined);
+            (0, assert_1.default)(typeof opReturnHex === 'string');
+            const parsed = (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(Buffer.from(opReturnHex, 'hex'));
+            const parsedFixture = await (0, testutil_1.getFixture)(baseFixturePath + '.json', JSON.parse((0, coreDao_1.toString)(parsed)));
+            assert_1.default.deepStrictEqual((0, coreDao_1.toString)(parsed), JSON.stringify(parsedFixture));
+        });
+        it('should fail if there is an invalid op-return', function () {
+            const script = defaultScript.replace('6a4c50', '6b4c50');
+            assert_1.default.throws(() => (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(Buffer.from(script, 'hex')));
+        });
+        it('should fail if the length is incorrect', function () {
+            const script = defaultScript.replace('4c50', '4c51');
+            assert_1.default.throws(() => (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(Buffer.from(script, 'hex')));
+        });
+        it('should fail if the satoshi+ identifier is incorrect', function () {
+            const script = defaultScript.replace('5341542b', '5341532b');
+            assert_1.default.throws(() => (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(Buffer.from(script, 'hex')));
+        });
+        it('should fail if the chainId is incorrect', function () {
+            const script = defaultScript.replace('045b', '0454');
+            assert_1.default.throws(() => (0, coreDao_1.parseCoreDaoOpReturnOutputScript)(Buffer.from(script, 'hex')));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"opReturn.js","sourceRoot":"","sources":["../../../../../test/unit/coreDao/opReturn.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport { testutil } from '@bitgo-beta/utxo-lib';\nimport { getFixture } from '@bitgo-beta/utxo-core/testutil';\n\nimport {\n  CORE_DAO_MAINNET_CHAIN_ID,\n  CORE_DAO_SATOSHI_PLUS_IDENTIFIER,\n  createCoreDaoOpReturnOutputScript,\n  decodeTimelock,\n  encodeTimelock,\n  parseCoreDaoOpReturnOutputScript,\n  toString,\n} from '../../../src/coreDao';\n\ndescribe('OP_RETURN', function () {\n  const validVersion = 2;\n  const validChainId = CORE_DAO_MAINNET_CHAIN_ID;\n  // random 20 byte buffers\n  const validDelegator = Buffer.alloc(20, testutil.getKey('wasm-possum').publicKey);\n  const validValidator = Buffer.alloc(20, testutil.getKey('possum-wasm').publicKey);\n  const validFee = 1;\n  const validRedeemScript = Buffer.from('522103a8295453660d5e212d55556666666666666666666666666666666666', 'hex');\n  const validTimelock = 800800;\n  let defaultScript: string;\n\n  before(async function () {\n    // https://docs.coredao.org/docs/Learn/products/btc-staking/design#op_return-output-1\n    const script = await getFixture('test/fixtures/coreDao/opReturn/documentation.txt', undefined);\n    assert(typeof script === 'string');\n    defaultScript = script;\n  });\n\n  describe('createCoreDaoOpReturnOutputScript', function () {\n    it('should throw if invalid parameters are passed', function () {\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: 292,\n          chainId: validChainId,\n          delegator: validDelegator,\n          validator: validValidator,\n          fee: validFee,\n          timelock: validTimelock,\n        })\n      );\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: Buffer.alloc(32, 0),\n          delegator: validDelegator,\n          validator: validValidator,\n          fee: validFee,\n          timelock: validTimelock,\n        })\n      );\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: validChainId,\n          delegator: Buffer.alloc(19, 0),\n          validator: validValidator,\n          fee: validFee,\n          timelock: validTimelock,\n        })\n      );\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: validChainId,\n          delegator: validDelegator,\n          validator: Buffer.alloc(19, 0),\n          fee: validFee,\n          timelock: validTimelock,\n        })\n      );\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: validChainId,\n          delegator: validDelegator,\n          validator: validValidator,\n          fee: 256,\n          timelock: validTimelock,\n        })\n      );\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: validChainId,\n          delegator: validDelegator,\n          validator: validValidator,\n          fee: validFee,\n          timelock: -1,\n        })\n      );\n    });\n\n    it('should throw if the length of the script is too long', function () {\n      assert.throws(() =>\n        createCoreDaoOpReturnOutputScript({\n          version: validVersion,\n          chainId: validChainId,\n          delegator: validDelegator,\n          validator: validValidator,\n          fee: validFee,\n          redeemScript: Buffer.alloc(100),\n        })\n      );\n    });\n\n    it('should return a buffer with the correct length', function () {\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        timelock: validTimelock,\n      });\n      // Make sure that the first byte is the OP_RETURN opcode\n      assert.strictEqual(script[0], 0x6a);\n      // Make sure that the length of the script matches what is in the buffer\n      assert.strictEqual(\n        // We do not count the OP_RETURN opcode or the bytes for the length\n        script.length - 2,\n        script[1]\n      );\n    });\n\n    it('should have the correct placement of the values provided with a redeem script', function () {\n      // This should produce an Op_RETURN that needs the extra push bytes for the length\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        redeemScript: validRedeemScript,\n      });\n      // Make sure that the first byte is the OP_RETURN opcode\n      assert.strictEqual(script[0], 0x6a);\n      // Make sure that the length of the script matches what is in the buffer\n      assert.strictEqual(script[1], 0x4c);\n      assert.strictEqual(\n        // We do not count the OP_RETURN opcode or the length + pushbytes\n        script.length - 3,\n        script[2]\n      );\n      // Satoshi plus identifier\n      assert.deepStrictEqual(script.subarray(3, 7).toString('hex'), CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));\n      // Make sure that the version is correct\n      assert.strictEqual(script[7], validVersion);\n      // Make sure that the chainId is correct\n      assert.deepStrictEqual(script.subarray(8, 10).toString('hex'), validChainId.toString('hex'));\n      // Make sure that the delegator is correct\n      assert.deepStrictEqual(script.subarray(10, 30).toString('hex'), validDelegator.toString('hex'));\n      // Make sure that the validator is correct\n      assert.deepStrictEqual(script.subarray(30, 50).toString('hex'), validValidator.toString('hex'));\n      // Make sure that the fee is correct\n      assert.strictEqual(script[50], validFee);\n      // Make sure that the redeemScript is correct\n      assert.deepStrictEqual(\n        script.subarray(51, 51 + validRedeemScript.length).toString('hex'),\n        validRedeemScript.toString('hex')\n      );\n    });\n\n    it('should have the correct placement of the values provided with a blockheight timelock', function () {\n      // This should produce an Op_RETURN that needs the extra push bytes for the length\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        timelock: validTimelock,\n      });\n      // Make sure that the first byte is the OP_RETURN opcode\n      assert.strictEqual(script[0], 0x6a);\n      // Make sure that the length of the script matches what is in the buffer\n      assert.strictEqual(\n        // We do not count the OP_RETURN opcode or the length\n        script.length - 2,\n        script[1]\n      );\n      // Satoshi plus identifier\n      assert.deepStrictEqual(script.subarray(2, 6).toString('hex'), CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));\n      // Make sure that the version is correct\n      assert.strictEqual(script[6], validVersion);\n      // Make sure that the chainId is correct\n      assert.deepStrictEqual(script.subarray(7, 9).toString('hex'), validChainId.toString('hex'));\n      // Make sure that the delegator is correct\n      assert.deepStrictEqual(script.subarray(9, 29).toString('hex'), validDelegator.toString('hex'));\n      // Make sure that the validator is correct\n      assert.deepStrictEqual(script.subarray(29, 49).toString('hex'), validValidator.toString('hex'));\n      // Make sure that the fee is correct\n      assert.strictEqual(script[49], validFee);\n      // Make sure that the redeemScript is correct\n      assert.deepStrictEqual(script.subarray(50, 54).toString('hex'), encodeTimelock(validTimelock).toString('hex'));\n      assert.deepStrictEqual(decodeTimelock(script.subarray(50, 54)), validTimelock);\n    });\n\n    it('should have the correct placement of the values provided with a time timelock', function () {\n      // This should produce an Op_RETURN that needs the extra push bytes for the length\n      const timelock = new Date('2022-01-01T00:00:00Z').getTime() / 1000;\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        timelock,\n      });\n      // Make sure that the first byte is the OP_RETURN opcode\n      assert.strictEqual(script[0], 0x6a);\n      // Make sure that the length of the script matches what is in the buffer\n      assert.strictEqual(\n        // We do not count the OP_RETURN opcode or the length\n        script.length - 2,\n        script[1]\n      );\n      // Satoshi plus identifier\n      assert.deepStrictEqual(script.subarray(2, 6).toString('hex'), CORE_DAO_SATOSHI_PLUS_IDENTIFIER.toString('hex'));\n      // Make sure that the version is correct\n      assert.strictEqual(script[6], validVersion);\n      // Make sure that the chainId is correct\n      assert.deepStrictEqual(script.subarray(7, 9).toString('hex'), validChainId.toString('hex'));\n      // Make sure that the delegator is correct\n      assert.deepStrictEqual(script.subarray(9, 29).toString('hex'), validDelegator.toString('hex'));\n      // Make sure that the validator is correct\n      assert.deepStrictEqual(script.subarray(29, 49).toString('hex'), validValidator.toString('hex'));\n      // Make sure that the fee is correct\n      assert.strictEqual(script[49], validFee);\n      // Make sure that the redeemScript is correct\n      assert.deepStrictEqual(script.subarray(50, 54).toString('hex'), encodeTimelock(timelock).toString('hex'));\n      assert.deepStrictEqual(decodeTimelock(script.subarray(50, 54)), timelock);\n    });\n\n    it('should recreate the example OP_RETURN correctly', function () {\n      assert.deepStrictEqual(\n        createCoreDaoOpReturnOutputScript({\n          version: 1,\n          chainId: Buffer.from('045b', 'hex'),\n          delegator: Buffer.from('de60b7d0e6b758ca5dd8c61d377a2c5f1af51ec1', 'hex'),\n          validator: Buffer.from('a9e209f5ea0036c8c2f41078a3cebee57d8a47d5', 'hex'),\n          fee: 1,\n          redeemScript: Buffer.from('041f5e0e66b17576a914c4b8ae927ff2b9ce218e20bf06d425d6b68424fd88ac', 'hex'),\n        }).toString('hex'),\n        defaultScript\n      );\n    });\n  });\n\n  describe('parseCoreDaoOpReturnOutputScript', function () {\n    it('should parse a valid script with a timelock', function () {\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        timelock: validTimelock,\n      });\n      const parsed = parseCoreDaoOpReturnOutputScript(script);\n      assert.strictEqual(parsed.version, validVersion);\n      assert.deepStrictEqual(parsed.chainId, validChainId);\n      assert.deepStrictEqual(parsed.delegator, validDelegator);\n      assert.deepStrictEqual(parsed.validator, validValidator);\n      assert.strictEqual(parsed.fee, validFee);\n      assert('timelock' in parsed);\n      assert.deepStrictEqual(parsed.timelock, validTimelock);\n    });\n\n    it('should parse a valid script with a redeem script', function () {\n      const script = createCoreDaoOpReturnOutputScript({\n        version: validVersion,\n        chainId: validChainId,\n        delegator: validDelegator,\n        validator: validValidator,\n        fee: validFee,\n        redeemScript: validRedeemScript,\n      });\n      const parsed = parseCoreDaoOpReturnOutputScript(script);\n      assert.strictEqual(parsed.version, validVersion);\n      assert.deepStrictEqual(parsed.chainId, validChainId);\n      assert.deepStrictEqual(parsed.delegator, validDelegator);\n      assert.deepStrictEqual(parsed.validator, validValidator);\n      assert.strictEqual(parsed.fee, validFee);\n      assert('redeemScript' in parsed);\n      assert.deepStrictEqual(parsed.redeemScript, validRedeemScript);\n    });\n\n    it('should parse valid opreturn script from testnet', async function () {\n      // Source: https://mempool.space/testnet/tx/66ed4cea26a410248a6d87f14b2bca514f33920c54d4af63ed46a903793115d5\n      const baseFixturePath =\n        'test/fixtures/coreDao/opReturn/66ed4cea26a410248a6d87f14b2bca514f33920c54d4af63ed46a903793115d5';\n      const opReturnHex = await getFixture(baseFixturePath + '.txt', undefined);\n      assert(typeof opReturnHex === 'string');\n      const parsed = parseCoreDaoOpReturnOutputScript(Buffer.from(opReturnHex, 'hex'));\n      const parsedFixture = await getFixture(baseFixturePath + '.json', JSON.parse(toString(parsed)));\n      assert.deepStrictEqual(toString(parsed), JSON.stringify(parsedFixture));\n    });\n\n    it('should fail if there is an invalid op-return', function () {\n      const script = defaultScript.replace('6a4c50', '6b4c50');\n      assert.throws(() => parseCoreDaoOpReturnOutputScript(Buffer.from(script, 'hex')));\n    });\n\n    it('should fail if the length is incorrect', function () {\n      const script = defaultScript.replace('4c50', '4c51');\n      assert.throws(() => parseCoreDaoOpReturnOutputScript(Buffer.from(script, 'hex')));\n    });\n\n    it('should fail if the satoshi+ identifier is incorrect', function () {\n      const script = defaultScript.replace('5341542b', '5341532b');\n      assert.throws(() => parseCoreDaoOpReturnOutputScript(Buffer.from(script, 'hex')));\n    });\n\n    it('should fail if the chainId is incorrect', function () {\n      const script = defaultScript.replace('045b', '0454');\n      assert.throws(() => parseCoreDaoOpReturnOutputScript(Buffer.from(script, 'hex')));\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,5 @@
+import { Descriptor } from '@bitgo/wasm-utxo';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+export declare function updateInputWithDescriptor(psbt: utxolib.Psbt, inputIndex: number, descriptor: Descriptor): void;
+export declare function finalizePsbt(psbt: utxolib.Psbt): utxolib.bitgo.UtxoPsbt;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cjs/test/unit/coreDao/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../test/unit/coreDao/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAQ,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAEhD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAM9G;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAMvE"}

package/dist/cjs/test/unit/coreDao/utils.js

@@ -0,0 +1,54 @@
+"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 });
+exports.updateInputWithDescriptor = updateInputWithDescriptor;
+exports.finalizePsbt = finalizePsbt;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+function updateInputWithDescriptor(psbt, inputIndex, descriptor) {
+    const wrappedPsbt = wasm_utxo_1.Psbt.deserialize(psbt.toBuffer());
+    wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
+    psbt.data.inputs[inputIndex] = utxolib.bitgo.UtxoPsbt.fromBuffer(Buffer.from(wrappedPsbt.serialize()), {
+        network: utxolib.networks.bitcoin,
+    }).data.inputs[inputIndex];
+}
+function finalizePsbt(psbt) {
+    const wrappedPsbt = wasm_utxo_1.Psbt.deserialize(psbt.toBuffer());
+    wrappedPsbt.finalize();
+    return utxolib.bitgo.UtxoPsbt.fromBuffer(Buffer.from(wrappedPsbt.serialize()), {
+        network: utxolib.networks.bitcoin,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+import assert from 'assert';
+import { ast } from '@bitgo/wasm-utxo';
+export declare function normalize(v: unknown): unknown;
+type EqualsAssertion = typeof assert.deepStrictEqual;
+export declare function assertEqualsFixture(fixtureName: string, value: unknown, n?: typeof normalize, eq?: EqualsAssertion): Promise<void>;
+export declare function assertTransactionEqualsFixture(fixtureName: string, tx: unknown): Promise<void>;
+export declare function assertEqualsMiniscript(script: Buffer, miniscript: ast.MiniscriptNode): void;
+export {};
+//# sourceMappingURL=fixtures.utils.d.ts.map

package/dist/cjs/test/unit/fixtures.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.utils.d.ts","sourceRoot":"","sources":["../../../../test/unit/fixtures.utils.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,GAAG,EAA0B,MAAM,kBAAkB,CAAC;AAM/D,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CA6B7C;AAED,KAAK,eAAe,GAAG,OAAO,MAAM,CAAC,eAAe,CAAC;AAErD,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,CAAC,mBAAY,EACb,EAAE,GAAE,eAAwC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpG;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,CAAC,cAAc,GAAG,IAAI,CAO3F"}

package/dist/cjs/test/unit/fixtures.utils.js

@@ -0,0 +1,91 @@
+"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 });
+exports.normalize = normalize;
+exports.assertEqualsFixture = assertEqualsFixture;
+exports.assertTransactionEqualsFixture = assertTransactionEqualsFixture;
+exports.assertEqualsMiniscript = assertEqualsMiniscript;
+const assert_1 = __importDefault(require("assert"));
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const bitcoinjslib = __importStar(require("bitcoinjs-lib"));
+const testutil_1 = require("@bitgo-beta/utxo-core/testutil");
+const descriptor_1 = require("@bitgo-beta/utxo-core/testutil/descriptor");
+function normalize(v) {
+    if (typeof v === 'bigint') {
+        return v.toString();
+    }
+    if (v instanceof wasm_utxo_1.Descriptor) {
+        return v.toString();
+    }
+    if (v instanceof Uint8Array) {
+        v = Buffer.from(v);
+    }
+    if (v instanceof Buffer) {
+        return v.toString('hex');
+    }
+    if (v instanceof bitcoinjslib.Psbt) {
+        v = utxolib.Psbt.fromBuffer(v.toBuffer());
+    }
+    if (v instanceof utxolib.Psbt) {
+        return (0, descriptor_1.toPlainObjectFromPsbt)(v);
+    }
+    if (v instanceof utxolib.Transaction) {
+        return (0, descriptor_1.toPlainObjectFromTx)(v);
+    }
+    if (Array.isArray(v)) {
+        return v.map(normalize);
+    }
+    if (typeof v === 'object' && v !== null) {
+        return Object.fromEntries(Object.entries(v).flatMap(([k, v]) => (v === undefined ? [] : [[k, normalize(v)]])));
+    }
+    return v;
+}
+async function assertEqualsFixture(fixtureName, value, n = normalize, eq = assert_1.default.deepStrictEqual) {
+    value = n(value);
+    eq(await (0, testutil_1.getFixture)(fixtureName, value), value);
+}
+async function assertTransactionEqualsFixture(fixtureName, tx) {
+    await assertEqualsFixture(fixtureName, normalize(tx));
+}
+function assertEqualsMiniscript(script, miniscript) {
+    const ms = wasm_utxo_1.Miniscript.fromBitcoinScript(script, 'tap');
+    assert_1.default.deepStrictEqual(wasm_utxo_1.ast.fromMiniscript(ms), miniscript);
+    assert_1.default.deepStrictEqual(script.toString('hex'), Buffer.from(wasm_utxo_1.Miniscript.fromString(wasm_utxo_1.ast.formatNode(miniscript), 'tap').encode()).toString('hex'));
+}
+//# sourceMappingURL=data:application/json;base64,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