@dcasegr/amm-client 0.0.0-stage → 0.38.1

package/dist/vendor/runar/runar-sdk/src/deployment.d.ts

@@ -0,0 +1,36 @@
+import { Transaction } from '@bsv/sdk';
+import type { UTXO } from './types.js';
+/**
+ * Build a transaction that creates an output with the given locking script.
+ * The transaction consumes the provided UTXOs, places the contract output
+ * first, and sends any remaining value (minus fees) to a change address.
+ *
+ * Returns the unsigned Transaction object and the number of inputs (needed
+ * so the caller knows how many inputs to sign).
+ */
+export declare function buildDeployTransaction(lockingScript: string, utxos: UTXO[], satoshis: number, changeAddress: string, changeScript: string, feeRate?: number): {
+    tx: Transaction;
+    inputCount: number;
+};
+/**
+ * Estimate the fee for a deploy transaction given the number of P2PKH
+ * inputs and the contract locking script byte length. Includes a P2PKH
+ * change output.
+ *
+ * @param numInputs              - Number of P2PKH inputs.
+ * @param lockingScriptByteLen   - Byte length of the contract locking script.
+ * @param feeRate                - Fee rate in satoshis per KB (default: 100).
+ * @param extraInputBytes        - Serialized byte size of any NON-P2PKH inputs
+ *   that this fee must also cover (e.g. a contract/covenant input being spent
+ *   in the same tx). Defaults to 0 — pure-deploy and funding-only selection
+ *   are unaffected. Used by `prepareCall` so funding coin-selection sizes the
+ *   fee against the real contract-input unlock bytes (which can be tens of KB
+ *   for a MERGE that embeds both parent txs) instead of ignoring them.
+ */
+export declare function estimateDeployFee(numInputs: number, lockingScriptByteLen: number, feeRate?: number, extraInputBytes?: number, extraOutputBytes?: number): number;
+/**
+ * Select the minimum set of UTXOs needed to fund a deployment, using a
+ * largest-first strategy. Returns the selected subset (possibly all UTXOs
+ * if the total is still insufficient -- the caller should check).
+ */
+export declare function selectUtxos(utxos: UTXO[], targetSatoshis: number, lockingScriptByteLen: number, feeRate?: number, extraInputBytes?: number, extraOutputBytes?: number): UTXO[];

package/dist/vendor/runar/runar-sdk/src/deployment.js

@@ -0,0 +1,119 @@
+// ---------------------------------------------------------------------------
+// runar-sdk/deployment.ts -- Transaction construction for contract deployment
+// ---------------------------------------------------------------------------
+import { Transaction, LockingScript, UnlockingScript } from '@bsv/sdk';
+import { buildP2PKHScript } from './script-utils.js';
+/**
+ * Build a transaction that creates an output with the given locking script.
+ * The transaction consumes the provided UTXOs, places the contract output
+ * first, and sends any remaining value (minus fees) to a change address.
+ *
+ * Returns the unsigned Transaction object and the number of inputs (needed
+ * so the caller knows how many inputs to sign).
+ */
+export function buildDeployTransaction(lockingScript, utxos, satoshis, changeAddress, changeScript, feeRate = 100) {
+    if (utxos.length === 0) {
+        throw new Error('buildDeployTransaction: no UTXOs provided');
+    }
+    const totalInput = utxos.reduce((sum, u) => sum + u.satoshis, 0);
+    const fee = estimateDeployFee(utxos.length, lockingScript.length / 2, feeRate);
+    const change = totalInput - satoshis - fee;
+    if (change < 0) {
+        throw new Error(`buildDeployTransaction: insufficient funds. Need ${satoshis + fee} sats, have ${totalInput}`);
+    }
+    const tx = new Transaction();
+    // Inputs (unsigned — no unlocking script)
+    for (const utxo of utxos) {
+        tx.addInput({
+            sourceTXID: utxo.txid,
+            sourceOutputIndex: utxo.outputIndex,
+            unlockingScript: new UnlockingScript(),
+            sequence: 0xffffffff,
+        });
+    }
+    // Output 0: contract locking script
+    tx.addOutput({
+        satoshis,
+        lockingScript: LockingScript.fromHex(lockingScript),
+    });
+    // Output 1: change (if any)
+    if (change > 0) {
+        const actualChangeScript = changeScript || buildP2PKHScript(changeAddress);
+        tx.addOutput({
+            satoshis: change,
+            lockingScript: LockingScript.fromHex(actualChangeScript),
+        });
+    }
+    return { tx, inputCount: utxos.length };
+}
+// ---------------------------------------------------------------------------
+// Fee estimation
+// ---------------------------------------------------------------------------
+/** Estimated size of a P2PKH input (prevTxid + index + sig + pubkey + seq). */
+const P2PKH_INPUT_SIZE = 148;
+/** Estimated size of a P2PKH output (satoshis + varint + 25-byte script). */
+const P2PKH_OUTPUT_SIZE = 34;
+/** Transaction overhead: version(4) + input varint(1) + output varint(1) + locktime(4). */
+const TX_OVERHEAD = 10;
+function varIntByteSize(n) {
+    if (n < 0xfd)
+        return 1;
+    if (n <= 0xffff)
+        return 3;
+    if (n <= 0xffffffff)
+        return 5;
+    return 9;
+}
+/**
+ * Estimate the fee for a deploy transaction given the number of P2PKH
+ * inputs and the contract locking script byte length. Includes a P2PKH
+ * change output.
+ *
+ * @param numInputs              - Number of P2PKH inputs.
+ * @param lockingScriptByteLen   - Byte length of the contract locking script.
+ * @param feeRate                - Fee rate in satoshis per KB (default: 100).
+ * @param extraInputBytes        - Serialized byte size of any NON-P2PKH inputs
+ *   that this fee must also cover (e.g. a contract/covenant input being spent
+ *   in the same tx). Defaults to 0 — pure-deploy and funding-only selection
+ *   are unaffected. Used by `prepareCall` so funding coin-selection sizes the
+ *   fee against the real contract-input unlock bytes (which can be tens of KB
+ *   for a MERGE that embeds both parent txs) instead of ignoring them.
+ */
+export function estimateDeployFee(numInputs, lockingScriptByteLen, feeRate = 100, extraInputBytes = 0, extraOutputBytes = 0) {
+    const inputsSize = numInputs * P2PKH_INPUT_SIZE + extraInputBytes;
+    const contractOutputSize = 8 + varIntByteSize(lockingScriptByteLen) + lockingScriptByteLen;
+    // extraOutputBytes carries the serialized framing (8 + varint + scriptLen) of
+    // every output BEYOND the single `lockingScriptByteLen` one counted above —
+    // additional multi-outputs, raw outputs (finding G1), and data outputs. A
+    // call-path selection that ignored them under-provisioned funding on
+    // multi-output / large-dataOutput calls, so it would stop one UTXO short and
+    // the built tx's change would go negative (finding C15). Deploy passes 0.
+    const changeOutputSize = P2PKH_OUTPUT_SIZE;
+    const txSize = TX_OVERHEAD + inputsSize + contractOutputSize + extraOutputBytes + changeOutputSize;
+    return Math.ceil(txSize * feeRate / 1000);
+}
+/**
+ * Select the minimum set of UTXOs needed to fund a deployment, using a
+ * largest-first strategy. Returns the selected subset (possibly all UTXOs
+ * if the total is still insufficient -- the caller should check).
+ */
+export function selectUtxos(utxos, targetSatoshis, lockingScriptByteLen, feeRate = 100, extraInputBytes = 0, extraOutputBytes = 0) {
+    const sorted = [...utxos].sort((a, b) => b.satoshis - a.satoshis);
+    const selected = [];
+    let total = 0;
+    for (const utxo of sorted) {
+        selected.push(utxo);
+        total += utxo.satoshis;
+        // extraInputBytes carries the serialized size of any non-P2PKH inputs the
+        // same tx spends (the contract/covenant input); extraOutputBytes carries the
+        // framing of any outputs beyond the single continuation (multi-output / raw /
+        // data outputs). Both keep the fee — and therefore how much funding we
+        // select — from being under-provisioned (findings C2 / C15).
+        const fee = estimateDeployFee(selected.length, lockingScriptByteLen, feeRate, extraInputBytes, extraOutputBytes);
+        if (total >= targetSatoshis + fee) {
+            return selected;
+        }
+    }
+    // Return all UTXOs; buildDeployTransaction will throw if still insufficient
+    return selected;
+}

package/dist/vendor/runar/runar-sdk/src/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Thrown when a deploy / call entry point or provider UTXO lookup
+ * encounters a script that exceeds {@link InputLimits.MAX_SCRIPT_BYTES}.
+ *
+ * Guards fire BEFORE any heavy operation (signing, broadcasting) so that
+ * pathological scripts cannot drive the SDK into expensive crypto work.
+ */
+export declare class ScriptSizeExceededError extends Error {
+    readonly limit: number;
+    readonly actual: number;
+    readonly context: string;
+    constructor(info: {
+        limit: number;
+        actual: number;
+        context: string;
+    });
+}
+/**
+ * Assert that a script (hex string or byte length) is within the SDK's
+ * MAX_SCRIPT_BYTES bound. Throws {@link ScriptSizeExceededError} otherwise.
+ *
+ * @param scriptHex hex-encoded script (2 hex chars per byte)
+ * @param context human-readable origin string for the error message
+ */
+export declare function assertScriptHexUnderLimit(scriptHex: string, limit: number, context: string): void;
+/**
+ * Thrown when a method call requires a caller-supplied intent-intrinsic
+ * witness value (auto-injected `_prevOutScript_<i>` or `_serialisedOutputs`)
+ * that has not been set on the RunarContract.
+ *
+ * Auto-injected witness params come from the compiler when a contract method
+ * uses `extractPrevOutputScript(i)` or `requireOutputP2PKH(...)`. The caller
+ * must supply concrete bytes for each before invoking `call()` /
+ * `prepareCall()` via {@link RunarContract.setPrevOutScript} and
+ * {@link RunarContract.setSerialisedOutputs}.
+ */
+export declare class WitnessValueMissingError extends Error {
+    readonly paramName: string;
+    readonly methodName: string;
+    readonly contractName: string;
+    constructor(info: {
+        paramName: string;
+        methodName: string;
+        contractName: string;
+    });
+}

package/dist/vendor/runar/runar-sdk/src/errors.js

@@ -0,0 +1,59 @@
+// ---------------------------------------------------------------------------
+// runar-sdk/errors.ts — Typed SDK errors
+// ---------------------------------------------------------------------------
+/**
+ * Thrown when a deploy / call entry point or provider UTXO lookup
+ * encounters a script that exceeds {@link InputLimits.MAX_SCRIPT_BYTES}.
+ *
+ * Guards fire BEFORE any heavy operation (signing, broadcasting) so that
+ * pathological scripts cannot drive the SDK into expensive crypto work.
+ */
+export class ScriptSizeExceededError extends Error {
+    limit;
+    actual;
+    context;
+    constructor(info) {
+        super(`script exceeds MAX_SCRIPT_BYTES (limit=${info.limit}, actual=${info.actual}, context=${info.context})`);
+        this.name = 'ScriptSizeExceededError';
+        this.limit = info.limit;
+        this.actual = info.actual;
+        this.context = info.context;
+    }
+}
+/**
+ * Assert that a script (hex string or byte length) is within the SDK's
+ * MAX_SCRIPT_BYTES bound. Throws {@link ScriptSizeExceededError} otherwise.
+ *
+ * @param scriptHex hex-encoded script (2 hex chars per byte)
+ * @param context human-readable origin string for the error message
+ */
+export function assertScriptHexUnderLimit(scriptHex, limit, context) {
+    // hex string is 2x the byte length; tolerate odd-length defensively
+    const actualBytes = Math.ceil(scriptHex.length / 2);
+    if (actualBytes > limit) {
+        throw new ScriptSizeExceededError({ limit, actual: actualBytes, context });
+    }
+}
+/**
+ * Thrown when a method call requires a caller-supplied intent-intrinsic
+ * witness value (auto-injected `_prevOutScript_<i>` or `_serialisedOutputs`)
+ * that has not been set on the RunarContract.
+ *
+ * Auto-injected witness params come from the compiler when a contract method
+ * uses `extractPrevOutputScript(i)` or `requireOutputP2PKH(...)`. The caller
+ * must supply concrete bytes for each before invoking `call()` /
+ * `prepareCall()` via {@link RunarContract.setPrevOutScript} and
+ * {@link RunarContract.setSerialisedOutputs}.
+ */
+export class WitnessValueMissingError extends Error {
+    paramName;
+    methodName;
+    contractName;
+    constructor(info) {
+        super(`witness value missing for auto-injected param '${info.paramName}' on ${info.contractName}.${info.methodName} — call setPrevOutScript(i, bytes) or setSerialisedOutputs(bytes) before invoking the method`);
+        this.name = 'WitnessValueMissingError';
+        this.paramName = info.paramName;
+        this.methodName = info.methodName;
+        this.contractName = info.contractName;
+    }
+}

package/dist/vendor/runar/runar-sdk/src/oppushtx.d.ts

@@ -0,0 +1,23 @@
+import { Transaction } from '@bsv/sdk';
+/**
+ * Compute the OP_PUSH_TX DER signature and BIP-143 preimage for a contract input.
+ *
+ * @param txOrHex     - The Transaction object or raw hex string
+ * @param inputIndex  - The contract input index (usually 0)
+ * @param subscript   - The locking script of the UTXO being spent (hex)
+ * @param satoshis    - The satoshi value of the UTXO being spent
+ * @param codeSeparatorIndex - Byte offset of OP_CODESEPARATOR in the locking script (optional).
+ *                             When present, the scriptCode in BIP-143 is the portion AFTER
+ *                             the OP_CODESEPARATOR (excluding the separator byte itself).
+ * @param sigHashType - BIP-143 sighash type the preimage is built under (issue #123).
+ *                      Defaults to `0x41` (ALL|FORKID). Must match the method's declared
+ *                      `@sighash` mode: it drives which preimage fields @bsv/sdk zeroes
+ *                      (hashPrevouts / hashSequence / hashOutputs) AND the sighash flag
+ *                      byte appended to the DER signature. A mismatch makes the on-chain
+ *                      OP_PUSH_TX binding fail to verify.
+ * @returns Object with `sigHex` (DER + sighash byte) and `preimageHex` (raw preimage)
+ */
+export declare function computeOpPushTx(txOrHex: Transaction | string, inputIndex: number, subscript: string, satoshis: number, codeSeparatorIndex?: number, sigHashType?: number): {
+    sigHex: string;
+    preimageHex: string;
+};

package/dist/vendor/runar/runar-sdk/src/oppushtx.js

@@ -0,0 +1,95 @@
+// ---------------------------------------------------------------------------
+// runar-sdk/oppushtx.ts — OP_PUSH_TX helper for checkPreimage contracts
+// ---------------------------------------------------------------------------
+//
+// Computes the BIP-143 sighash preimage and OP_PUSH_TX signature for contracts
+// that use checkPreimage() (both stateful and stateless).
+//
+// The OP_PUSH_TX technique uses private key k=1 (public key = generator point G).
+// The on-chain script derives the signature from the preimage, so both must be
+// provided in the unlocking script.
+// ---------------------------------------------------------------------------
+import { PrivateKey, TransactionSignature, Hash, Transaction, Script, BigNumber } from '@bsv/sdk';
+/** SIGHASH_ALL | SIGHASH_FORKID — the default BSV sighash type. */
+const SIGHASH_ALL_FORKID = 0x41;
+/** secp256k1 curve order N. */
+const CURVE_ORDER = new BigNumber('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16);
+/** OP_PUSH_TX private key (k=1). */
+const opPushTxPrivKey = PrivateKey.fromHex('0000000000000000000000000000000000000000000000000000000000000001');
+/**
+ * Compute the OP_PUSH_TX DER signature and BIP-143 preimage for a contract input.
+ *
+ * @param txOrHex     - The Transaction object or raw hex string
+ * @param inputIndex  - The contract input index (usually 0)
+ * @param subscript   - The locking script of the UTXO being spent (hex)
+ * @param satoshis    - The satoshi value of the UTXO being spent
+ * @param codeSeparatorIndex - Byte offset of OP_CODESEPARATOR in the locking script (optional).
+ *                             When present, the scriptCode in BIP-143 is the portion AFTER
+ *                             the OP_CODESEPARATOR (excluding the separator byte itself).
+ * @param sigHashType - BIP-143 sighash type the preimage is built under (issue #123).
+ *                      Defaults to `0x41` (ALL|FORKID). Must match the method's declared
+ *                      `@sighash` mode: it drives which preimage fields @bsv/sdk zeroes
+ *                      (hashPrevouts / hashSequence / hashOutputs) AND the sighash flag
+ *                      byte appended to the DER signature. A mismatch makes the on-chain
+ *                      OP_PUSH_TX binding fail to verify.
+ * @returns Object with `sigHex` (DER + sighash byte) and `preimageHex` (raw preimage)
+ */
+export function computeOpPushTx(txOrHex, inputIndex, subscript, satoshis, codeSeparatorIndex, sigHashType = SIGHASH_ALL_FORKID) {
+    const tx = typeof txOrHex === 'string' ? Transaction.fromHex(txOrHex) : txOrHex;
+    const input = tx.inputs[inputIndex];
+    const otherInputs = tx.inputs
+        .filter((_inp, i) => i !== inputIndex)
+        .map((inp) => ({
+        sourceTXID: inp.sourceTXID,
+        sourceOutputIndex: inp.sourceOutputIndex,
+        sequence: inp.sequence,
+    }));
+    const outputs = tx.outputs.map((out) => ({
+        satoshis: out.satoshis,
+        lockingScript: out.lockingScript,
+    }));
+    // If OP_CODESEPARATOR is present, use only the script after it as scriptCode.
+    // The separator byte itself (0xab) is excluded from the scriptCode.
+    let scriptCode = subscript;
+    if (codeSeparatorIndex !== undefined) {
+        // Each byte is 2 hex chars. Skip past the separator byte (+1 byte = +2 hex chars).
+        // R-178: String.slice() past the end returns '', so an out-of-range index
+        // used to sign an EMPTY scriptCode — silently, from a fund-moving
+        // primitive. There is no correct signature for a separator offset that is
+        // not in the script.
+        const trimPos = (codeSeparatorIndex + 1) * 2;
+        if (trimPos > subscript.length) {
+            throw new Error(`computeOpPushTx: codeSeparatorIndex ${codeSeparatorIndex} is past the end of ` +
+                `the subscript (${subscript.length / 2} bytes)`);
+        }
+        scriptCode = subscript.slice(trimPos);
+    }
+    // Compute BIP-143 preimage
+    const preimage = TransactionSignature.format({
+        sourceTXID: input.sourceTXID,
+        sourceOutputIndex: input.sourceOutputIndex,
+        sourceSatoshis: satoshis,
+        transactionVersion: tx.version,
+        otherInputs: otherInputs,
+        outputs: outputs,
+        inputIndex,
+        subscript: Script.fromHex(scriptCode),
+        inputSequence: input.sequence,
+        lockTime: tx.lockTime,
+        scope: sigHashType,
+    });
+    // Double-SHA256 for BIP-143 sighash
+    const sighash = Hash.sha256(preimage);
+    // Sign with k=1 private key
+    const signature = opPushTxPrivKey.sign(sighash);
+    // Enforce low-S
+    const halfN = CURVE_ORDER.div(new BigNumber(2));
+    if (signature.s.gt(halfN)) {
+        signature.s = CURVE_ORDER.sub(signature.s);
+    }
+    const derHex = signature.toDER('hex');
+    const sigHex = derHex + (sigHashType & 0xff).toString(16).padStart(2, '0');
+    // Convert preimage to hex
+    const preimageHex = Array.from(preimage).map((b) => b.toString(16).padStart(2, '0')).join('');
+    return { sigHex, preimageHex };
+}

package/dist/vendor/runar/runar-sdk/src/ordinals/envelope.d.ts

@@ -0,0 +1,31 @@
+import type { Inscription, EnvelopeBounds } from './types.js';
+/**
+ * Build a 1sat ordinals inscription envelope as hex.
+ *
+ * @param contentType - MIME type (e.g. "image/png", "application/bsv-20")
+ * @param data - Hex-encoded inscription content
+ * @returns Hex string of the full envelope script fragment
+ */
+export declare function buildInscriptionEnvelope(contentType: string, data: string): string;
+/**
+ * Find the inscription envelope within a script hex string.
+ *
+ * Walks the script as Bitcoin Script opcodes (identical in shape to
+ * `findLastOpReturn` in state.ts) looking for the pattern:
+ *   OP_FALSE(00) OP_IF(63) PUSH3 "ord"(03 6f7264) ...
+ *
+ * @returns Hex-char offsets of the envelope, or null if not found.
+ */
+export declare function findInscriptionEnvelope(scriptHex: string): EnvelopeBounds | null;
+/**
+ * Parse an inscription envelope from a script hex string.
+ *
+ * @returns The inscription data, or null if no envelope is found.
+ */
+export declare function parseInscriptionEnvelope(scriptHex: string): Inscription | null;
+/**
+ * Remove the inscription envelope from a script, returning the bare script.
+ *
+ * @returns Script hex with the envelope removed, or the original if none found.
+ */
+export declare function stripInscriptionEnvelope(scriptHex: string): string;