@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/cjs/utils/arkTransaction.js

@@ -1,271 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOffchainTx = buildOffchainTx;
-exports.hasBoardingTxExpired = hasBoardingTxExpired;
-exports.verifyTapscriptSignatures = verifyTapscriptSignatures;
-exports.combineTapscriptSigs = combineTapscriptSigs;
-exports.isValidArkAddress = isValidArkAddress;
-const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
-const base_1 = require("@scure/base");
-const btc_signer_1 = require("@scure/btc-signer");
-const payment_js_1 = require("@scure/btc-signer/payment.js");
-const tapscript_1 = require("../script/tapscript");
-const base_2 = require("../script/base");
-const anchor_1 = require("./anchor");
-const unknownFields_1 = require("./unknownFields");
-const transaction_1 = require("./transaction");
-const address_1 = require("../script/address");
-const extension_1 = require("../extension");
-/**
- * Builds an offchain transaction with checkpoint transactions.
- *
- * Creates one checkpoint transaction per input and a virtual transaction that
- * combines all the checkpoints, sending to the specified outputs. This is the
- * core function for creating Arkade transactions.
- *
- * @param inputs - Array of virtual transaction inputs
- * @param outputs - Array of transaction outputs
- * @param serverUnrollScript - Server unroll script for checkpoint transactions
- * @returns Object containing the virtual transaction and checkpoint transactions
- */
-function buildOffchainTx(inputs, outputs, serverUnrollScript) {
-    // TODO: use arkd /info
-    const MAX_OP_RETURN = 2;
-    let countOpReturn = 0;
-    let hasExtensionOutput = false;
-    for (const [index, output] of outputs.entries()) {
-        if (!output.script)
-            throw new Error(`missing output script ${index}`);
-        const isExtension = extension_1.Extension.isExtension(output.script);
-        const isOpReturn = isExtension || btc_signer_1.Script.decode(output.script)[0] === "RETURN";
-        if (isOpReturn) {
-            countOpReturn++;
-        }
-        if (!isExtension)
-            continue;
-        if (hasExtensionOutput)
-            throw new Error("multiple extension outputs");
-        hasExtensionOutput = true;
-    }
-    if (countOpReturn > MAX_OP_RETURN) {
-        throw new Error(`too many OP_RETURN outputs: ${countOpReturn} > ${MAX_OP_RETURN}`);
-    }
-    const checkpoints = inputs.map((input) => buildCheckpointTx(input, serverUnrollScript));
-    const arkTx = buildVirtualTx(checkpoints.map((c) => c.input), outputs);
-    return {
-        arkTx,
-        checkpoints: checkpoints.map((c) => c.tx),
-    };
-}
-function buildVirtualTx(inputs, outputs) {
-    let lockTime = 0n;
-    for (const input of inputs) {
-        const tapscript = (0, tapscript_1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(input.tapLeafScript));
-        if (tapscript_1.CLTVMultisigTapscript.is(tapscript)) {
-            if (lockTime !== 0n) {
-                // if a locktime is already set, check if the new locktime is in the same unit
-                if (isSeconds(lockTime) !==
-                    isSeconds(tapscript.params.absoluteTimelock)) {
-                    throw new Error("cannot mix seconds and blocks locktime");
-                }
-            }
-            if (tapscript.params.absoluteTimelock > lockTime) {
-                lockTime = tapscript.params.absoluteTimelock;
-            }
-        }
-    }
-    const tx = new transaction_1.Transaction({
-        version: 3,
-        lockTime: Number(lockTime),
-    });
-    for (const [i, input] of inputs.entries()) {
-        tx.addInput({
-            txid: input.txid,
-            index: input.vout,
-            sequence: lockTime ? btc_signer_1.DEFAULT_SEQUENCE - 1 : undefined,
-            witnessUtxo: {
-                script: base_2.VtxoScript.decode(input.tapTree).pkScript,
-                amount: BigInt(input.value),
-            },
-            tapLeafScript: [input.tapLeafScript],
-        });
-        (0, unknownFields_1.setArkPsbtField)(tx, i, unknownFields_1.VtxoTaprootTree, input.tapTree);
-    }
-    for (const output of outputs) {
-        tx.addOutput(output);
-    }
-    // add the anchor output
-    tx.addOutput(anchor_1.P2A);
-    return tx;
-}
-function buildCheckpointTx(vtxo, serverUnrollScript) {
-    // create the checkpoint virtual output script from collaborative closure
-    const collaborativeClosure = (0, tapscript_1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(vtxo.tapLeafScript));
-    // create the checkpoint virtual output script combining collaborative closure and server unroll script
-    const checkpointVtxoScript = new base_2.VtxoScript([
-        serverUnrollScript.script,
-        collaborativeClosure.script,
-    ]);
-    // build the checkpoint virtual tx
-    const checkpointTx = buildVirtualTx([vtxo], [
-        {
-            amount: BigInt(vtxo.value),
-            script: checkpointVtxoScript.pkScript,
-        },
-    ]);
-    // get the collaborative leaf proof
-    const collaborativeLeafProof = checkpointVtxoScript.findLeaf(base_1.hex.encode(collaborativeClosure.script));
-    // create the checkpoint input that will be used as input of the virtual tx
-    const checkpointInput = {
-        txid: checkpointTx.id,
-        vout: 0,
-        value: vtxo.value,
-        tapLeafScript: collaborativeLeafProof,
-        tapTree: checkpointVtxoScript.encode(),
-    };
-    return {
-        tx: checkpointTx,
-        input: checkpointInput,
-    };
-}
-const nLocktimeMinSeconds = 500000000n;
-function isSeconds(locktime) {
-    return locktime >= nLocktimeMinSeconds;
-}
-function hasBoardingTxExpired(coin, boardingTimelock, chainTipHeight) {
-    if (!coin.status.block_time)
-        return false;
-    if (boardingTimelock.value === 0n)
-        return true;
-    if (boardingTimelock.type === "blocks") {
-        if (chainTipHeight === undefined || !coin.status.block_height)
-            return false;
-        return (BigInt(chainTipHeight - coin.status.block_height) >=
-            boardingTimelock.value);
-    }
-    // validate expiry in terms of seconds
-    const now = BigInt(Math.floor(Date.now() / 1000));
-    const blockTime = BigInt(Math.floor(coin.status.block_time));
-    return blockTime + boardingTimelock.value <= now;
-}
-/**
- * Formats a sighash type as a hex string (e.g., 0x01)
- */
-function formatSighash(type) {
-    return `0x${type.toString(16).padStart(2, "0")}`;
-}
-/**
- * Verify tapscript signatures on a transaction input
- * @param tx Transaction to verify
- * @param inputIndex Index of the input to verify
- * @param requiredSigners List of required signer pubkeys (hex encoded)
- * @param excludePubkeys List of pubkeys to exclude from verification (hex encoded, e.g., server key not yet signed)
- * @param allowedSighashTypes List of allowed sighash types (defaults to [SigHash.DEFAULT])
- * @throws Error if verification fails
- */
-function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubkeys = [], allowedSighashTypes = [btc_signer_1.SigHash.DEFAULT]) {
-    const input = tx.getInput(inputIndex);
-    // Collect prevout scripts and amounts for ALL inputs (required for preimageWitnessV1)
-    const prevoutScripts = [];
-    const prevoutAmounts = [];
-    for (let i = 0; i < tx.inputsLength; i++) {
-        const inp = tx.getInput(i);
-        if (!inp.witnessUtxo) {
-            throw new Error(`Input ${i} is missing witnessUtxo`);
-        }
-        prevoutScripts.push(inp.witnessUtxo.script);
-        prevoutAmounts.push(inp.witnessUtxo.amount);
-    }
-    // Verify tapScriptSig signatures
-    if (!input.tapScriptSig || input.tapScriptSig.length === 0) {
-        throw new Error(`Input ${inputIndex} is missing tapScriptSig`);
-    }
-    // Verify each signature in tapScriptSig
-    for (const [tapScriptSigData, signature] of input.tapScriptSig) {
-        const pubKey = tapScriptSigData.pubKey;
-        const pubKeyHex = base_1.hex.encode(pubKey);
-        // Skip verification for excluded pubkeys
-        if (excludePubkeys.includes(pubKeyHex)) {
-            continue;
-        }
-        // Extract sighash type from signature
-        // Schnorr signatures are 64 bytes, with optional 1-byte sighash appended
-        const sighashType = signature.length === 65 ? signature[64] : btc_signer_1.SigHash.DEFAULT;
-        const sig = signature.subarray(0, 64);
-        // Verify sighash type is allowed
-        if (!allowedSighashTypes.includes(sighashType)) {
-            const sighashName = formatSighash(sighashType);
-            throw new Error(`Unallowed sighash type ${sighashName} for input ${inputIndex}, pubkey ${pubKeyHex}.`);
-        }
-        // Find the tapLeafScript that matches this signature's leafHash
-        if (!input.tapLeafScript || input.tapLeafScript.length === 0) {
-            throw new Error();
-        }
-        // Search for the leaf that matches the leafHash in tapScriptSigData
-        const leafHash = tapScriptSigData.leafHash;
-        const leafHashHex = base_1.hex.encode(leafHash);
-        let matchingScript;
-        let matchingVersion;
-        for (const [_, scriptWithVersion] of input.tapLeafScript) {
-            const script = scriptWithVersion.subarray(0, -1);
-            const version = scriptWithVersion[scriptWithVersion.length - 1];
-            // Compute the leaf hash for this script and compare as hex strings
-            const computedLeafHash = (0, payment_js_1.tapLeafHash)(script, version);
-            const computedHex = base_1.hex.encode(computedLeafHash);
-            if (computedHex === leafHashHex) {
-                matchingScript = script;
-                matchingVersion = version;
-                break;
-            }
-        }
-        if (!matchingScript || matchingVersion === undefined) {
-            throw new Error(`Input ${inputIndex}: No tapLeafScript found matching leafHash ${base_1.hex.encode(leafHash)}`);
-        }
-        // Reconstruct the message that was signed
-        // Note: preimageWitnessV1 requires ALL input prevout scripts and amounts
-        const message = tx.preimageWitnessV1(inputIndex, prevoutScripts, sighashType, prevoutAmounts, undefined, matchingScript, matchingVersion);
-        // Verify the schnorr signature
-        const isValid = secp256k1_js_1.schnorr.verify(sig, message, pubKey);
-        if (!isValid) {
-            throw new Error(`Invalid signature for input ${inputIndex}, pubkey ${pubKeyHex}`);
-        }
-    }
-    // Verify we have signatures from all required signers (excluding those we're skipping)
-    const signedPubkeys = input.tapScriptSig.map(([data]) => base_1.hex.encode(data.pubKey));
-    const requiredNotExcluded = requiredSigners.filter((pk) => !excludePubkeys.includes(pk));
-    const missingSigners = requiredNotExcluded.filter((pk) => !signedPubkeys.includes(pk));
-    if (missingSigners.length > 0) {
-        throw new Error(`Missing signatures from: ${missingSigners.map((pk) => pk.slice(0, 16)).join(", ")}...`);
-    }
-}
-/**
- * Merges the signed transaction with the original transaction
- * @param signedTx signed transaction
- * @param originalTx original transaction
- */
-function combineTapscriptSigs(signedTx, originalTx) {
-    for (let i = 0; i < signedTx.inputsLength; i++) {
-        const input = originalTx.getInput(i);
-        const signedInput = signedTx.getInput(i);
-        if (!input.tapScriptSig)
-            throw new Error("No tapScriptSig");
-        originalTx.updateInput(i, {
-            tapScriptSig: input.tapScriptSig?.concat(signedInput.tapScriptSig),
-        });
-    }
-    return originalTx;
-}
-/**
- * Validates if a given string is a valid Arkade address by attempting to decode it.
- * @param address The Arkade address to validate.
- * @returns True if the address is valid, false otherwise.
- */
-function isValidArkAddress(address) {
-    try {
-        address_1.ArkAddress.decode(address);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}

package/dist/cjs/utils/bip21.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BIP21 = exports.BIP21Error = void 0;
-var BIP21Error;
-(function (BIP21Error) {
-    BIP21Error["INVALID_URI"] = "Invalid BIP21 URI";
-    BIP21Error["INVALID_ADDRESS"] = "Invalid address";
-})(BIP21Error || (exports.BIP21Error = BIP21Error = {}));
-class BIP21 {
-    /**
-     * Create a BIP21 URI from the provided parameters.
-     *
-     * @param params - BIP21 parameters to encode
-     * @returns Encoded BIP21 URI
-     */
-    static create(params) {
-        const { address, ...options } = params;
-        // Build query string
-        const queryParams = {};
-        for (const [key, value] of Object.entries(options)) {
-            if (value === undefined)
-                continue;
-            if (key === "amount") {
-                if (!isFinite(value)) {
-                    console.warn("Invalid amount");
-                    continue;
-                }
-                if (value < 0) {
-                    continue;
-                }
-                queryParams[key] = value;
-            }
-            else if (key === "ark") {
-                // Validate Arkade address format
-                if (typeof value === "string" &&
-                    (value.startsWith("ark") || value.startsWith("tark"))) {
-                    queryParams[key] = value;
-                }
-                else {
-                    console.warn("Invalid ARK address format");
-                }
-            }
-            else if (key === "sp") {
-                // Validate Silent Payment address format (placeholder)
-                if (typeof value === "string" && value.startsWith("sp")) {
-                    queryParams[key] = value;
-                }
-                else {
-                    console.warn("Invalid Silent Payment address format");
-                }
-            }
-            else if (typeof value === "string" || typeof value === "number") {
-                queryParams[key] = value;
-            }
-        }
-        const query = Object.keys(queryParams).length > 0
-            ? "?" +
-                new URLSearchParams(Object.fromEntries(Object.entries(queryParams).map(([k, v]) => [
-                    k,
-                    String(v),
-                ]))).toString()
-            : "";
-        return `bitcoin:${address ? address.toLowerCase() : ""}${query}`;
-    }
-    /**
-     * Parse a BIP21 URI and return its decoded parameters.
-     *
-     * @param uri - BIP21 URI to parse
-     * @returns Parsed BIP21 URI data
-     * @throws Error if the URI does not start with the `bitcoin:` scheme
-     */
-    static parse(uri) {
-        if (!uri.toLowerCase().startsWith("bitcoin:")) {
-            throw new Error(BIP21Error.INVALID_URI);
-        }
-        // Remove the `bitcoin:` prefix while preserving the case of the rest.
-        const withoutPrefix = uri.slice(uri.toLowerCase().indexOf("bitcoin:") + 8);
-        const [address, query] = withoutPrefix.split("?");
-        const params = {};
-        if (address) {
-            params.address = address.toLowerCase();
-        }
-        if (query) {
-            const queryParams = new URLSearchParams(query);
-            for (const [key, value] of queryParams.entries()) {
-                if (!value)
-                    continue;
-                if (key === "amount") {
-                    const amount = Number(value);
-                    if (!isFinite(amount)) {
-                        continue;
-                    }
-                    if (amount < 0) {
-                        continue;
-                    }
-                    params[key] = amount;
-                }
-                else if (key === "ark") {
-                    // Validate Arkade address format
-                    if (value.startsWith("ark") || value.startsWith("tark")) {
-                        params[key] = value;
-                    }
-                    else {
-                        console.warn("Invalid ARK address format");
-                    }
-                }
-                else if (key === "sp") {
-                    // Validate Silent Payment address format (placeholder)
-                    if (value.startsWith("sp")) {
-                        params[key] = value;
-                    }
-                    else {
-                        console.warn("Invalid Silent Payment address format");
-                    }
-                }
-                else {
-                    params[key] = value;
-                }
-            }
-        }
-        return {
-            originalString: uri,
-            params,
-        };
-    }
-}
-exports.BIP21 = BIP21;

package/dist/cjs/utils/syncCursors.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERLAP_MS = exports.SAFETY_LAG_MS = void 0;
-exports.updateWalletState = updateWalletState;
-exports.getSyncCursor = getSyncCursor;
-exports.advanceSyncCursor = advanceSyncCursor;
-exports.clearSyncCursor = clearSyncCursor;
-exports.computeSyncWindow = computeSyncWindow;
-exports.cursorCutoff = cursorCutoff;
-/** Lag behind real-time to avoid racing with indexer writes. */
-exports.SAFETY_LAG_MS = 30000;
-/** Overlap window so boundary virtual outputs are never missed. */
-exports.OVERLAP_MS = 24 * 60 * 60 * 1000;
-/**
- * Per-repository mutex that serializes wallet-state mutations so that
- * concurrent read-modify-write cycles never silently overwrite
- * each other's changes.
- */
-const walletStateLocks = new WeakMap();
-/**
- * Atomically read, mutate, and persist wallet state.
- * All callers that modify wallet state should go through this helper
- * to avoid lost-update races between interleaved async operations.
- */
-async function updateWalletState(repo, updater) {
-    const prev = walletStateLocks.get(repo) ?? Promise.resolve();
-    const op = prev.then(async () => {
-        const state = (await repo.getWalletState()) ?? {};
-        await repo.saveWalletState(updater(state));
-    });
-    // Store a version that never rejects so the chain doesn't break.
-    walletStateLocks.set(repo, op.catch(() => { }));
-    return op;
-}
-/**
- * Settings key that gates interpretation of the `lastSyncTime` field.
- *
- * The `lastSyncTime` column existed pre-PR with a different semantic
- * (wall-clock at sync completion, written by the buggy sync loop this
- * PR fixes). On upgrade we cannot trust any pre-existing value, so the
- * cursor is only honoured after the first successful post-upgrade
- * advance writes this marker into the `settings` JSON blob. Reusing
- * `settings` avoids any schema migration.
- */
-const CURSOR_MIGRATED_KEY = "vtxoCursorMigrated";
-function hasMigrationMarker(state) {
-    return state?.settings?.[CURSOR_MIGRATED_KEY] === true;
-}
-/**
- * Read the global high-water mark for VTXO indexer syncs.
- *
- * Returns `0` when:
- *  - the wallet has never been synced (bootstrap case), or
- *  - the stored `lastSyncTime` was written by pre-PR code and is not
- *    safe to reuse under the new semantics (see {@link CURSOR_MIGRATED_KEY}).
- */
-async function getSyncCursor(repo) {
-    const state = await repo.getWalletState();
-    if (!hasMigrationMarker(state))
-        return 0;
-    return state?.lastSyncTime ?? 0;
-}
-/**
- * Advance the global cursor after a successful full-scope delta sync.
- *
- * Clamped with `Math.max` against the current value so concurrent syncs
- * that finish out of order can't rewind the cursor: `lastUpdatedAt` is
- * captured before each sync enters the `updateWalletState` mutex, and
- * the later-started sync would otherwise overwrite the earlier-captured
- * one with a smaller value. The legacy value is discarded on the first
- * advance if the migration marker is absent so pre-PR data doesn't
- * survive the upgrade.
- */
-async function advanceSyncCursor(repo, lastUpdatedAt) {
-    await updateWalletState(repo, (state) => {
-        const current = hasMigrationMarker(state)
-            ? (state.lastSyncTime ?? 0)
-            : 0;
-        return {
-            ...state,
-            lastSyncTime: Math.max(current, lastUpdatedAt),
-            settings: {
-                ...(state.settings ?? {}),
-                [CURSOR_MIGRATED_KEY]: true,
-            },
-        };
-    });
-}
-/**
- * Remove the sync cursor, forcing a full re-bootstrap on next sync.
- *
- * Also clears the migration marker so any stored `lastSyncTime` is
- * treated as untrusted on the next read.
- */
-async function clearSyncCursor(repo) {
-    await updateWalletState(repo, (state) => {
-        const { [CURSOR_MIGRATED_KEY]: _, ...restSettings } = state.settings ?? {};
-        return {
-            ...state,
-            lastSyncTime: undefined,
-            settings: restSettings,
-        };
-    });
-}
-/**
- * Compute the `after` lower-bound for a delta sync query.
- *
- * No upper bound (`before`) is applied to the query so that freshly
- * created virtual outputs are never excluded. The safety lag is applied only
- * when advancing the cursor (see @see cursorCutoff).
- */
-function computeSyncWindow(cursor) {
-    const after = Math.max(0, cursor - exports.OVERLAP_MS);
-    return { after };
-}
-/**
- * The safe high-water mark for cursor advancement.
- * Lags behind real-time by @see SAFETY_LAG_MS so that virtual outputs still
- * being indexed are re-queried on the next sync.
- *
- * When `requestStartedAt` is provided the cutoff is frozen to the
- * request start rather than wall-clock at commit time, preventing
- * long-running paginated fetches from advancing the cursor past the
- * data they actually observed.
- */
-function cursorCutoff(requestStartedAt) {
-    return (requestStartedAt ?? Date.now()) - exports.SAFETY_LAG_MS;
-}

package/dist/cjs/utils/timelock.js

@@ -1,59 +0,0 @@
-"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.timelockToSequence = timelockToSequence;
-exports.sequenceToTimelock = sequenceToTimelock;
-const bip68 = __importStar(require("bip68"));
-/**
- * Convert RelativeTimelock to BIP68 sequence number.
- */
-function timelockToSequence(timelock) {
-    return bip68.encode(timelock.type === "blocks"
-        ? { blocks: Number(timelock.value) }
-        : { seconds: Number(timelock.value) });
-}
-/**
- * Convert BIP68 sequence number back to RelativeTimelock.
- */
-function sequenceToTimelock(sequence) {
-    const decoded = bip68.decode(sequence);
-    if ("blocks" in decoded && decoded.blocks !== undefined) {
-        return { type: "blocks", value: BigInt(decoded.blocks) };
-    }
-    if ("seconds" in decoded && decoded.seconds !== undefined) {
-        return { type: "seconds", value: BigInt(decoded.seconds) };
-    }
-    throw new Error(`Invalid BIP68 sequence: ${sequence}`);
-}

package/dist/cjs/utils/transaction.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-const btc_signer_1 = require("@scure/btc-signer");
-/**
- * Transaction is a wrapper around the @scure/btc-signer Transaction class.
- * It adds the Arkade protocol specific options to the transaction.
- */
-class Transaction extends btc_signer_1.Transaction {
-    constructor(opts) {
-        super(withArkOpts(opts));
-    }
-    static fromPSBT(psbt_, opts) {
-        return btc_signer_1.Transaction.fromPSBT(psbt_, withArkOpts(opts));
-    }
-    static fromRaw(raw, opts) {
-        return btc_signer_1.Transaction.fromRaw(raw, withArkOpts(opts));
-    }
-}
-exports.Transaction = Transaction;
-Transaction.ARK_TX_OPTS = {
-    allowUnknown: true,
-    allowUnknownOutputs: true,
-    allowUnknownInputs: true,
-};
-function withArkOpts(opts) {
-    return { ...Transaction.ARK_TX_OPTS, ...opts };
-}