@bitgo-beta/utxo-staking 1.1.1-beta.91 → 1.1.1-beta.910

package/dist/cjs/test/unit/babylon/vendor.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor.utils.d.ts","sourceRoot":"","sources":["../../../../../test/unit/babylon/vendor.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,MAAM,MAAM,2CAA2C,CAAC;AACpE,OAAO,KAAK,eAAe,MAAM,kCAAkC,CAAC;AAIpE,OAAO,EACL,wBAAwB,EAGxB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAI9B,KAAK,MAAM,GAAG;IACZ,qBAAqB,EAAE,gBAAgB,CAAC,eAAe,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;IAC7F,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC;CACrC,CAAC;AAEF,wBAAsB,yCAAyC,CAC7D,OAAO,EAAE,YAAY,CAAC,OAAO,EAC7B,SAAS,EAAE,eAAe,EAC1B,gBAAgB,EAAE,eAAe,EACjC,iBAAiB,EAAE,wBAAwB,EAC3C,aAAa,EAAE,MAAM,CAAC,sBAAsB,EAAE,EAC9C,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,CAAC,IAAI,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,YAAY,CAAC,OAAO,EAC7B,SAAS,EAAE,eAAe,EAC1B,gBAAgB,EAAE,eAAe,EACjC,iBAAiB,EAAE,wBAAwB,EAC3C,aAAa,EAAE,MAAM,CAAC,sBAAsB,EAAE,EAC9C,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,CAAC,IAAI,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAuCjB"}

package/dist/cjs/test/unit/babylon/vendor.utils.js

@@ -0,0 +1,78 @@
+"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.getBitGoUtxoStakingMsgCreateBtcDelegation = getBitGoUtxoStakingMsgCreateBtcDelegation;
+exports.getVendorMsgCreateBtcDelegation = getVendorMsgCreateBtcDelegation;
+const vendor = __importStar(require("@bitgo-beta/babylonlabs-io-btc-staking-ts"));
+const babylonProtobuf = __importStar(require("@babylonlabs-io/babylon-proto-ts"));
+const address_1 = require("bitcoinjs-lib/src/address");
+const babylonlabs_io_btc_staking_ts_1 = require("@bitgo-beta/babylonlabs-io-btc-staking-ts");
+const babylon_1 = require("../../../src/babylon");
+const key_utils_1 = require("./key.utils");
+async function getBitGoUtxoStakingMsgCreateBtcDelegation(network, stakerKey, finalityProvider, descriptorBuilder, stakingParams, changeAddress, amount, utxo, feeRateSatB, blockHeight) {
+    return await (0, babylon_1.createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider)((0, babylon_1.getBtcProviderForECKey)(descriptorBuilder, stakerKey), network, {
+        address: changeAddress,
+        publicKeyNoCoordHex: (0, key_utils_1.getXOnlyPubkey)(stakerKey).toString('hex'),
+    }, {
+        finalityProviderPksNoCoordHex: [(0, key_utils_1.getXOnlyPubkey)(finalityProvider).toString('hex')],
+        stakingAmountSat: amount,
+        stakingTimelock: (0, babylonlabs_io_btc_staking_ts_1.getBabylonParamByBtcHeight)(blockHeight, stakingParams).minStakingTimeBlocks,
+    }, 800000, [utxo], feeRateSatB, (0, address_1.toBech32)(Buffer.from('test'), 0, 'bbn'), 'delegation:create', stakingParams);
+}
+async function getVendorMsgCreateBtcDelegation(network, stakerKey, finalityProvider, descriptorBuilder, stakingParams, changeAddress, amount, utxo, feeRateSatB, blockHeight) {
+    const babylonProvider = {
+        async signTransaction(msg) {
+            // return unsigned payload
+            return babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation.encode(msg.value).finish();
+        },
+    };
+    const manager = new vendor.BabylonBtcStakingManager(network, stakingParams, (0, babylon_1.getBtcProviderForECKey)(descriptorBuilder, stakerKey), babylonProvider);
+    const result = await manager.preStakeRegistrationBabylonTransaction({
+        address: changeAddress,
+        publicKeyNoCoordHex: (0, key_utils_1.getXOnlyPubkey)(stakerKey).toString('hex'),
+    }, {
+        finalityProviderPksNoCoordHex: [(0, key_utils_1.getXOnlyPubkey)(finalityProvider).toString('hex')],
+        stakingAmountSat: amount,
+        stakingTimelock: (0, babylonlabs_io_btc_staking_ts_1.getBabylonParamByBtcHeight)(blockHeight, stakingParams).minStakingTimeBlocks,
+    }, blockHeight, [utxo], feeRateSatB, (0, address_1.toBech32)(Buffer.from('test'), 0, 'bbn'));
+    return {
+        unsignedDelegationMsg: {
+            typeUrl: '/babylon.btcstaking.v1.MsgCreateBTCDelegation',
+            value: babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation.decode(result.signedBabylonTx),
+        },
+        stakingTx: result.stakingTx,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const testutil_1 = require("@bitgo-beta/utxo-core/testutil");
+const coreDao_1 = require("../../../src/coreDao");
+const utils_1 = require("./utils");
+describe('descriptor', function () {
+    const baseFixturePath = 'test/fixtures/coreDao/descriptor/';
+    const rootWalletKeys = utxolib.testutil.getDefaultWalletKeys();
+    const key1 = rootWalletKeys.triple[0];
+    const key2 = rootWalletKeys.triple[1];
+    const key3 = rootWalletKeys.triple[2];
+    const validLocktime = 2048;
+    it('should fail if m is longer than the number of keys or not at least 1', function () {
+        assert.throws(() => {
+            (0, coreDao_1.createMultiSigDescriptor)('sh', validLocktime, 3, [key1, key2], false);
+        });
+        assert.throws(() => {
+            (0, coreDao_1.createMultiSigDescriptor)('sh', validLocktime, 0, [key1, key2], false);
+        });
+    });
+    it('should fail if locktime is invalid', function () {
+        assert.throws(() => {
+            (0, coreDao_1.createMultiSigDescriptor)('sh', 0, 2, [key1, key2], false);
+        });
+    });
+    async function runTestForParams(scriptType, m, keys) {
+        const fixturePath = baseFixturePath + `${scriptType}-${m}of${keys.length}`;
+        describe(`should create a ${m} of ${keys.length} multi-sig ${scriptType} descriptor`, function () {
+            it('has expected descriptor string', async function () {
+                const descriptorString = (0, coreDao_1.createMultiSigDescriptor)(scriptType, validLocktime, m, keys, false);
+                assert.strictEqual(descriptorString, await (0, testutil_1.getFixture)(fixturePath + `-string.txt`, descriptorString), descriptorString);
+            });
+            it('has expected AST', async function () {
+                const descriptor = wasm_utxo_1.Descriptor.fromString((0, coreDao_1.createMultiSigDescriptor)(scriptType, validLocktime, m, keys, false), 'derivable');
+                assert.deepStrictEqual(descriptor.node(), await (0, testutil_1.getFixture)(fixturePath + '-ast.json', descriptor.node()));
+            });
+            it('has expected asm', async function () {
+                const descriptor = wasm_utxo_1.Descriptor.fromString((0, coreDao_1.createMultiSigDescriptor)(scriptType, validLocktime, m, keys, false), 'derivable');
+                const asmString = descriptor.atDerivationIndex(0).toAsmString();
+                assert.strictEqual(asmString, await (0, testutil_1.getFixture)(fixturePath + '-asm.txt', asmString), asmString);
+            });
+            it('can be signed', async function () {
+                // Derive the script from the descriptor
+                const descriptor = wasm_utxo_1.Descriptor.fromString((0, coreDao_1.createMultiSigDescriptor)(scriptType, validLocktime, m, keys, false), 'derivable');
+                const descriptorAt0 = descriptor.atDerivationIndex(0);
+                const script = Buffer.from(descriptorAt0.scriptPubkey());
+                // Make the prevTx
+                const prevPsbt = utxolib.testutil.constructPsbt([{ scriptType: 'p2wsh', value: BigInt(1.1e8) }], [{ script: script.toString('hex'), value: BigInt(1e8) }], utxolib.networks.bitcoin, rootWalletKeys, 'fullsigned');
+                const prevTx = prevPsbt.finalizeAllInputs().extractTransaction();
+                // Create the PSBT and sign
+                const psbt = Object.assign(new utxolib.Psbt({ network: utxolib.networks.bitcoin }), {
+                    locktime: validLocktime,
+                });
+                psbt.addInput({
+                    hash: prevTx.getId(),
+                    index: 0,
+                    sequence: 0xfffffffe,
+                });
+                if (scriptType === 'sh-wsh') {
+                    psbt.updateInput(0, { witnessUtxo: { script, value: BigInt(1e8) } });
+                }
+                else {
+                    psbt.updateInput(0, { nonWitnessUtxo: prevTx.toBuffer() });
+                }
+                psbt.addOutput({ script, value: BigInt(0.9e8) });
+                (0, utils_1.updateInputWithDescriptor)(psbt, 0, descriptorAt0);
+                keys.forEach((signer, i) => {
+                    if (i >= m) {
+                        return;
+                    }
+                    psbt.signAllInputsHD(signer);
+                });
+                // Get the fully signed transaction and check
+                const signedTx = (0, utils_1.finalizePsbt)(psbt).extractTransaction().toBuffer();
+                assert.strictEqual(signedTx.toString('hex'), await (0, testutil_1.getFixture)(fixturePath + '-tx.txt', signedTx.toString('hex')));
+            });
+        });
+    }
+    runTestForParams('sh', 2, [key1, key2]);
+    runTestForParams('sh-wsh', 2, [key1, key2]);
+    runTestForParams('sh', 3, [key1, key2, key3]);
+    runTestForParams('wsh', 3, [key1, key2, key3]);
+    it('should recreate the script used in testnet staking transaction', function () {
+        // Source: https://mempool.space/testnet/address/2MxTi2EhHKgdJFKRTBttVGGxir9ZzjmKCXw
+        // 2 of 2 multisig
+        const timelock = 'fce4cb66';
+        const pubkey1 = '03ecb6d4b7f5d56962e547fc52dd588359f5729c0ba856d6978b84723895a16691';
+        const pubkey2 = '024aaea25d82b1db2be030a05b641d6302e48ed652b1ca9cb08a67267fcbb56747';
+        const redeemScriptASM = [
+            'OP_PUSHBYTES_4',
+            timelock,
+            'OP_CLTV',
+            'OP_DROP',
+            'OP_PUSHNUM_2',
+            'OP_PUSHBYTES_33',
+            pubkey1,
+            'OP_PUSHBYTES_33',
+            pubkey2,
+            'OP_PUSHNUM_2',
+            'OP_CHECKMULTISIG',
+        ].join(' ');
+        const decodedTimelock = (0, coreDao_1.decodeTimelock)(Buffer.from(timelock, 'hex'));
+        const descriptor = (0, coreDao_1.createMultiSigDescriptor)('sh', decodedTimelock, 2, [Buffer.from(pubkey1, 'hex'), Buffer.from(pubkey2, 'hex')], false);
+        const descriptorASM = wasm_utxo_1.Descriptor.fromString(descriptor, 'definite').toAsmString();
+        assert.deepStrictEqual(redeemScriptASM, descriptorASM);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"descriptor.js","sourceRoot":"","sources":["../../../../../test/unit/coreDao/descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\n\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { Descriptor } from '@bitgo/wasm-utxo';\nimport { getFixture } from '@bitgo-beta/utxo-core/testutil';\n\nimport { createMultiSigDescriptor, decodeTimelock } from '../../../src/coreDao';\n\nimport { finalizePsbt, updateInputWithDescriptor } from './utils';\n\ndescribe('descriptor', function () {\n  const baseFixturePath = 'test/fixtures/coreDao/descriptor/';\n  const rootWalletKeys = utxolib.testutil.getDefaultWalletKeys();\n  const key1 = rootWalletKeys.triple[0];\n  const key2 = rootWalletKeys.triple[1];\n  const key3 = rootWalletKeys.triple[2];\n  const validLocktime = 2048;\n\n  it('should fail if m is longer than the number of keys or not at least 1', function () {\n    assert.throws(() => {\n      createMultiSigDescriptor('sh', validLocktime, 3, [key1, key2], false);\n    });\n\n    assert.throws(() => {\n      createMultiSigDescriptor('sh', validLocktime, 0, [key1, key2], false);\n    });\n  });\n\n  it('should fail if locktime is invalid', function () {\n    assert.throws(() => {\n      createMultiSigDescriptor('sh', 0, 2, [key1, key2], false);\n    });\n  });\n\n  async function runTestForParams(scriptType: 'sh' | 'sh-wsh' | 'wsh', m: number, keys: utxolib.BIP32Interface[]) {\n    const fixturePath = baseFixturePath + `${scriptType}-${m}of${keys.length}`;\n    describe(`should create a ${m} of ${keys.length} multi-sig ${scriptType} descriptor`, function () {\n      it('has expected descriptor string', async function () {\n        const descriptorString = createMultiSigDescriptor(scriptType, validLocktime, m, keys, false);\n        assert.strictEqual(\n          descriptorString,\n          await getFixture(fixturePath + `-string.txt`, descriptorString),\n          descriptorString\n        );\n      });\n\n      it('has expected AST', async function () {\n        const descriptor = Descriptor.fromString(\n          createMultiSigDescriptor(scriptType, validLocktime, m, keys, false),\n          'derivable'\n        );\n\n        assert.deepStrictEqual(descriptor.node(), await getFixture(fixturePath + '-ast.json', descriptor.node()));\n      });\n\n      it('has expected asm', async function () {\n        const descriptor = Descriptor.fromString(\n          createMultiSigDescriptor(scriptType, validLocktime, m, keys, false),\n          'derivable'\n        );\n        const asmString = descriptor.atDerivationIndex(0).toAsmString();\n        assert.strictEqual(asmString, await getFixture(fixturePath + '-asm.txt', asmString), asmString);\n      });\n\n      it('can be signed', async function () {\n        // Derive the script from the descriptor\n        const descriptor = Descriptor.fromString(\n          createMultiSigDescriptor(scriptType, validLocktime, m, keys, false),\n          'derivable'\n        );\n        const descriptorAt0 = descriptor.atDerivationIndex(0);\n        const script = Buffer.from(descriptorAt0.scriptPubkey());\n\n        // Make the prevTx\n        const prevPsbt = utxolib.testutil.constructPsbt(\n          [{ scriptType: 'p2wsh', value: BigInt(1.1e8) }],\n          [{ script: script.toString('hex'), value: BigInt(1e8) }],\n          utxolib.networks.bitcoin,\n          rootWalletKeys,\n          'fullsigned'\n        );\n        const prevTx = prevPsbt.finalizeAllInputs().extractTransaction();\n\n        // Create the PSBT and sign\n        const psbt = Object.assign(new utxolib.Psbt({ network: utxolib.networks.bitcoin }), {\n          locktime: validLocktime,\n        });\n        psbt.addInput({\n          hash: prevTx.getId(),\n          index: 0,\n          sequence: 0xfffffffe,\n        });\n        if (scriptType === 'sh-wsh') {\n          psbt.updateInput(0, { witnessUtxo: { script, value: BigInt(1e8) } });\n        } else {\n          psbt.updateInput(0, { nonWitnessUtxo: prevTx.toBuffer() });\n        }\n        psbt.addOutput({ script, value: BigInt(0.9e8) });\n        updateInputWithDescriptor(psbt, 0, descriptorAt0);\n        keys.forEach((signer, i) => {\n          if (i >= m) {\n            return;\n          }\n          psbt.signAllInputsHD(signer);\n        });\n\n        // Get the fully signed transaction and check\n        const signedTx = finalizePsbt(psbt).extractTransaction().toBuffer();\n        assert.strictEqual(\n          signedTx.toString('hex'),\n          await getFixture(fixturePath + '-tx.txt', signedTx.toString('hex'))\n        );\n      });\n    });\n  }\n\n  runTestForParams('sh', 2, [key1, key2]);\n  runTestForParams('sh-wsh', 2, [key1, key2]);\n  runTestForParams('sh', 3, [key1, key2, key3]);\n  runTestForParams('wsh', 3, [key1, key2, key3]);\n\n  it('should recreate the script used in testnet staking transaction', function () {\n    // Source: https://mempool.space/testnet/address/2MxTi2EhHKgdJFKRTBttVGGxir9ZzjmKCXw\n    // 2 of 2 multisig\n    const timelock = 'fce4cb66';\n    const pubkey1 = '03ecb6d4b7f5d56962e547fc52dd588359f5729c0ba856d6978b84723895a16691';\n    const pubkey2 = '024aaea25d82b1db2be030a05b641d6302e48ed652b1ca9cb08a67267fcbb56747';\n    const redeemScriptASM = [\n      'OP_PUSHBYTES_4',\n      timelock,\n      'OP_CLTV',\n      'OP_DROP',\n      'OP_PUSHNUM_2',\n      'OP_PUSHBYTES_33',\n      pubkey1,\n      'OP_PUSHBYTES_33',\n      pubkey2,\n      'OP_PUSHNUM_2',\n      'OP_CHECKMULTISIG',\n    ].join(' ');\n\n    const decodedTimelock = decodeTimelock(Buffer.from(timelock, 'hex'));\n    const descriptor = createMultiSigDescriptor(\n      'sh',\n      decodedTimelock,\n      2,\n      [Buffer.from(pubkey1, 'hex'), Buffer.from(pubkey2, 'hex')],\n      false\n    );\n    const descriptorASM = Descriptor.fromString(descriptor, 'definite').toAsmString();\n    assert.deepStrictEqual(redeemScriptASM, descriptorASM);\n  });\n});\n"]}

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

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

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

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

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"]}