@arkade-os/sdk 0.4.27 → 0.4.29

package/dist/esm/extension/asset/utils.js

@@ -1,99 +0,0 @@
-export class BufferWriter {
-    constructor() {
-        this.buffer = [];
-    }
-    write(data) {
-        for (const byte of data) {
-            this.buffer.push(byte);
-        }
-    }
-    writeByte(byte) {
-        this.buffer.push(byte & 0xff);
-    }
-    writeUint16LE(value) {
-        const buf = new Uint8Array(2);
-        new DataView(buf.buffer).setUint16(0, value, true); // true = little endian
-        this.write(buf);
-    }
-    writeVarUint(value) {
-        if (typeof value === "number") {
-            if (!Number.isInteger(value) || value < 0) {
-                throw new RangeError("writeVarUint: value must be a non-negative integer");
-            }
-        }
-        else if (value < 0n) {
-            throw new RangeError("writeVarUint: value must be a non-negative integer");
-        }
-        const val = typeof value === "number" ? BigInt(value) : value;
-        const bytes = [];
-        let remaining = val;
-        do {
-            let byte = Number(remaining & 0x7fn);
-            remaining >>= 7n;
-            if (remaining > 0n) {
-                byte |= 0x80;
-            }
-            bytes.push(byte);
-        } while (remaining > 0n);
-        this.write(new Uint8Array(bytes));
-    }
-    writeVarSlice(data) {
-        this.writeVarUint(data.length);
-        this.write(data);
-    }
-    toBytes() {
-        return new Uint8Array(this.buffer);
-    }
-}
-export class BufferReader {
-    constructor(data) {
-        this.offset = 0;
-        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    }
-    remaining() {
-        return this.view.byteLength - this.offset;
-    }
-    readByte() {
-        if (this.offset >= this.view.byteLength) {
-            throw new Error("unexpected end of buffer");
-        }
-        return this.view.getUint8(this.offset++);
-    }
-    readSlice(size) {
-        if (this.offset + size > this.view.byteLength) {
-            throw new Error("unexpected end of buffer");
-        }
-        const result = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, size);
-        this.offset += size;
-        return result;
-    }
-    readUint16LE() {
-        if (this.offset + 2 > this.view.byteLength) {
-            throw new Error("unexpected end of buffer");
-        }
-        const value = this.view.getUint16(this.offset, true);
-        this.offset += 2;
-        return value;
-    }
-    readVarUint() {
-        let result = 0n;
-        let shift = 0n;
-        let byte;
-        do {
-            if (this.offset >= this.view.byteLength) {
-                throw new Error("unexpected end of buffer");
-            }
-            byte = this.view.getUint8(this.offset++);
-            result |= BigInt(byte & 0x7f) << shift;
-            shift += 7n;
-        } while (byte & 0x80);
-        return result;
-    }
-    readVarSlice() {
-        const length = Number(this.readVarUint());
-        return this.readSlice(length);
-    }
-}
-export function isZeroBytes(bytes) {
-    return bytes.every((byte) => byte === 0);
-}

package/dist/esm/extension/index.js

@@ -1,248 +0,0 @@
-import { hex } from "@scure/base";
-import { Script } from "@scure/btc-signer";
-import { equalBytes } from "@scure/btc-signer/utils.js";
-import { Packet } from "./asset/packet.js";
-import { BufferReader } from "./asset/utils.js";
-import { UnknownPacket } from "./packet.js";
-export { UnknownPacket } from "./packet.js";
-/**
- * ArkadeMagic is the 3-byte magic prefix ("ARK") that identifies an OP_RETURN
- * output as an Arkade extension blob.
- */
-export const ARKADE_MAGIC = new Uint8Array([0x41, 0x52, 0x4b]); // "ARK"
-/**
- * ErrExtensionNotFound is thrown when no extension output is found in a transaction.
- */
-export class ExtensionNotFoundError extends Error {
-    constructor() {
-        super("no extension output found in transaction");
-        this.name = "ExtensionNotFoundError";
-    }
-}
-/**
- * Extension is a set of typed packets encoded in an OP_RETURN output.
- *
- * Wire format:
- *   OP_RETURN | <push> | ARK(3B) | [type(1B) | varint_len | data]...
- */
-export class Extension {
-    constructor(packets) {
-        this.packets = packets;
-    }
-    static create(packets) {
-        if (packets.length === 0) {
-            throw new Error("missing packets");
-        }
-        const seen = new Set();
-        for (const p of packets) {
-            if (seen.has(p.type())) {
-                throw new Error(`duplicate packet type ${p.type()}`);
-            }
-            seen.add(p.type());
-        }
-        return new Extension(packets);
-    }
-    /**
-     * isExtension returns true if the script is an OP_RETURN whose push data
-     * begins with the ARK magic bytes.
-     */
-    static isExtension(script) {
-        try {
-            const decoded = Script.decode(script);
-            if (decoded.length < 2 || decoded[0] !== "RETURN")
-                return false;
-            const data = decoded[1];
-            if (!(data instanceof Uint8Array))
-                return false;
-            return (data.length >= ARKADE_MAGIC.length &&
-                equalBytes(data.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * fromBytes parses an Extension from a raw OP_RETURN script.
-     */
-    static fromBytes(script) {
-        if (!script || script.length === 0) {
-            throw new Error("missing OP_RETURN");
-        }
-        let decoded;
-        try {
-            decoded = Script.decode(script);
-        }
-        catch {
-            throw new Error("expected OP_RETURN");
-        }
-        if (decoded.length === 0 || decoded[0] !== "RETURN") {
-            throw new Error("expected OP_RETURN");
-        }
-        const dataPushes = decoded
-            .slice(1)
-            .filter((x) => x instanceof Uint8Array);
-        if (dataPushes.length === 0) {
-            throw new Error("missing magic prefix: EOF");
-        }
-        // Concatenate all data pushes (handles OP_PUSHDATA1/2/4)
-        const payload = new Uint8Array(dataPushes.reduce((acc, d) => acc + d.length, 0));
-        let offset = 0;
-        for (const d of dataPushes) {
-            payload.set(d, offset);
-            offset += d.length;
-        }
-        // Check ARK magic
-        if (payload.length < ARKADE_MAGIC.length ||
-            !equalBytes(payload.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC)) {
-            throw new Error(`expected magic prefix ${hex.encode(ARKADE_MAGIC)}, got ${hex.encode(payload.slice(0, Math.min(payload.length, ARKADE_MAGIC.length)))}`);
-        }
-        // Parse TLV records
-        const reader = new BufferReader(payload.slice(ARKADE_MAGIC.length));
-        const packets = [];
-        while (reader.remaining() > 0) {
-            const packetType = reader.readByte();
-            let data;
-            try {
-                data = reader.readVarSlice();
-            }
-            catch {
-                throw new Error("missing packet data");
-            }
-            packets.push(parsePacket(packetType, data));
-        }
-        if (packets.length === 0) {
-            throw new Error("missing packets");
-        }
-        // Reject duplicate packet types
-        const seen = new Set();
-        for (const p of packets) {
-            if (seen.has(p.type())) {
-                throw new Error(`duplicate packet type ${p.type()}`);
-            }
-            seen.add(p.type());
-        }
-        return new Extension(packets);
-    }
-    /**
-     * fromTx searches the transaction outputs for an extension blob and parses it.
-     * Throws ExtensionNotFoundError if none is found.
-     */
-    static fromTx(tx) {
-        for (let i = 0; i < tx.outputsLength; i++) {
-            const output = tx.getOutput(i);
-            if (!output?.script)
-                continue;
-            if (Extension.isExtension(output.script)) {
-                return Extension.fromBytes(output.script);
-            }
-        }
-        throw new ExtensionNotFoundError();
-    }
-    /**
-     * serialize encodes the extension as an OP_RETURN script.
-     *
-     * Layout: OP_RETURN | <push> | ARK | [type | varint_len | data]...
-     */
-    serialize() {
-        // Build payload: ARK magic + TLV records
-        const parts = [ARKADE_MAGIC];
-        for (const p of this.packets) {
-            const data = p.serialize();
-            // type (1 byte)
-            const typeByte = new Uint8Array([p.type()]);
-            // varint length prefix + data
-            const lengthBuf = encodeVarUint(data.length);
-            parts.push(typeByte, lengthBuf, data);
-        }
-        const totalLen = parts.reduce((acc, p) => acc + p.length, 0);
-        const payload = new Uint8Array(totalLen);
-        let off = 0;
-        for (const p of parts) {
-            payload.set(p, off);
-            off += p.length;
-        }
-        return buildOpReturnScript(payload);
-    }
-    /**
-     * txOut returns the extension as a zero-value OP_RETURN transaction output.
-     */
-    txOut() {
-        return {
-            script: this.serialize(),
-            amount: 0n,
-        };
-    }
-    /**
-     * getAssetPacket returns the embedded Packet, or null if not present.
-     */
-    getAssetPacket() {
-        for (const p of this.packets) {
-            if (p instanceof Packet) {
-                return p;
-            }
-        }
-        return null;
-    }
-}
-/**
- * parsePacket dispatches to a known packet type or falls back to UnknownPacket.
- */
-function parsePacket(packetType, data) {
-    if (packetType === Packet.PACKET_TYPE) {
-        return Packet.fromBytes(data);
-    }
-    return new UnknownPacket(packetType, data);
-}
-/**
- * encodeVarUint encodes a non-negative integer as a LEB128 unsigned varint.
- */
-function encodeVarUint(value) {
-    const bytes = [];
-    let remaining = value;
-    do {
-        let byte = remaining & 0x7f;
-        remaining >>>= 7;
-        if (remaining > 0)
-            byte |= 0x80;
-        bytes.push(byte);
-    } while (remaining > 0);
-    return new Uint8Array(bytes);
-}
-/**
- * buildOpReturnScript builds an OP_RETURN script with an arbitrary-length data push.
- * Manually constructed to avoid the 520-byte cap in some script builders.
- *
- * Opcodes: 0x6a=OP_RETURN, 0x4c=OP_PUSHDATA1, 0x4d=OP_PUSHDATA2, 0x4e=OP_PUSHDATA4
- */
-function buildOpReturnScript(data) {
-    const n = data.length;
-    let script;
-    if (n <= 75) {
-        script = new Uint8Array(2 + n);
-        script[0] = 0x6a; // OP_RETURN
-        script[1] = n;
-        script.set(data, 2);
-    }
-    else if (n <= 255) {
-        script = new Uint8Array(3 + n);
-        script[0] = 0x6a;
-        script[1] = 0x4c; // OP_PUSHDATA1
-        script[2] = n;
-        script.set(data, 3);
-    }
-    else if (n <= 65535) {
-        script = new Uint8Array(4 + n);
-        script[0] = 0x6a;
-        script[1] = 0x4d; // OP_PUSHDATA2
-        new DataView(script.buffer).setUint16(2, n, true);
-        script.set(data, 4);
-    }
-    else {
-        script = new Uint8Array(6 + n);
-        script[0] = 0x6a;
-        script[1] = 0x4e; // OP_PUSHDATA4
-        new DataView(script.buffer).setUint32(2, n, true);
-        script.set(data, 6);
-    }
-    return script;
-}

package/dist/esm/extension/packet.js

@@ -1,16 +0,0 @@
-/**
- * UnknownPacket holds a packet whose type is not recognized by this implementation.
- * It round-trips opaquely: the raw bytes are preserved as-is.
- */
-export class UnknownPacket {
-    constructor(packetType, data) {
-        this.packetType = packetType;
-        this.data = data;
-    }
-    type() {
-        return this.packetType;
-    }
-    serialize() {
-        return this.data;
-    }
-}

package/dist/esm/forfeit.js

@@ -1,41 +0,0 @@
-import { Transaction } from "./utils/transaction.js";
-import { P2A } from "./utils/anchor.js";
-/**
- * Build a forfeit transaction that spends the provided inputs to a single forfeit output.
- *
- * @param inputs - Inputs to include in the forfeit transaction
- * @param forfeitPkScript - ScriptPubKey for the forfeit output
- * @param txLocktime - Optional locktime to apply to the transaction
- */
-export function buildForfeitTx(inputs, forfeitPkScript, txLocktime) {
-    let amount = 0n;
-    for (const input of inputs) {
-        if (!input.witnessUtxo) {
-            throw new Error("input needs witness utxo");
-        }
-        amount += input.witnessUtxo.amount;
-    }
-    return buildForfeitTxWithOutput(inputs, {
-        script: forfeitPkScript,
-        amount,
-    }, txLocktime);
-}
-/**
- * Build a forfeit transaction using an explicit output descriptor (used for delegated renewals)
- *
- * @param inputs - Inputs to include in the forfeit transaction
- * @param output - Primary transaction output
- * @param txLocktime - Optional locktime to apply to the transaction
- */
-export function buildForfeitTxWithOutput(inputs, output, txLocktime) {
-    const tx = new Transaction({
-        version: 3,
-        lockTime: txLocktime,
-    });
-    for (const input of inputs) {
-        tx.addInput(input);
-    }
-    tx.addOutput(output);
-    tx.addOutput(P2A);
-    return tx;
-}

package/dist/esm/identity/descriptor.js

@@ -1,161 +0,0 @@
-import { expand, networks } from "@bitcoinerlab/descriptors-scure";
-import { hex } from "@scure/base";
-/**
- * True iff `descriptor` is a Bitcoin mainnet descriptor (xpub-prefixed
- * BIP32 key).
- *
- * Note: testnet, signet, regtest, mutinynet, and other non-mainnet
- * networks all share the same `tpub` BIP32 version bytes — they cannot
- * be distinguished from one another at the descriptor level. Callers
- * that need a `Network` constants object for `expand()` pick
- * `networks.bitcoin` vs `networks.testnet` themselves; callers that
- * need the *actual* network the wallet is on must track that
- * out-of-band.
- */
-export function isMainnetDescriptor(descriptor) {
-    return !descriptor.includes("tpub");
-}
-/**
- * Shared "does `candidate` belong to the identity backed by
- * `ourDescriptor`?" predicate.
- *
- * - HD descriptors (expanding to a `bip32` key) match by account xpub
- *   on both sides — index-agnostic, so a wildcard template and any
- *   concrete index under it all collapse to the same xpub.
- * - Bare `tr(pubkey)` candidates fall back to comparing the candidate
- *   pubkey against `ourXOnlyPubkey` (the cached pubkey on the identity
- *   side, since pulling it from `ourDescriptor` would require an index
- *   substitution the caller already performed).
- */
-export function descriptorIsOurs(candidate, ourDescriptor, ourXOnlyPubkey) {
-    if (!isDescriptor(candidate))
-        return false;
-    try {
-        const candidateInfo = expand({
-            descriptor: candidate,
-            network: isMainnetDescriptor(candidate)
-                ? networks.bitcoin
-                : networks.testnet,
-        }).expansionMap?.["@0"];
-        if (!candidateInfo)
-            return false;
-        if (candidateInfo.bip32) {
-            const ourBip32 = expand({
-                descriptor: ourDescriptor,
-                network: isMainnetDescriptor(ourDescriptor)
-                    ? networks.bitcoin
-                    : networks.testnet,
-            }).expansionMap?.["@0"]?.bip32;
-            if (!ourBip32)
-                return false;
-            return ourBip32.toBase58() === candidateInfo.bip32.toBase58();
-        }
-        if (candidateInfo.pubkey) {
-            // For tr() the library hands back a 32-byte x-only key, but
-            // strip a leading parity byte defensively so a 33-byte
-            // compressed key (mismatched length) doesn't silently
-            // false-negative against our 32-byte x-only side.
-            const candidatePub = candidateInfo.pubkey.length === 33
-                ? candidateInfo.pubkey.subarray(1)
-                : candidateInfo.pubkey;
-            if (candidatePub.length !== ourXOnlyPubkey.length)
-                return false;
-            return hex.encode(candidatePub) === hex.encode(ourXOnlyPubkey);
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if a string is a descriptor of the shape `tr(...)`.
- *
- * This is a shape check only — it does not validate the inner key material.
- * Use {@link expand} (via {@link extractPubKey} / {@link parseHDDescriptor})
- * for full parsing. The guard rejects empty bodies and missing/trailing
- * parentheses so callers can safely branch on descriptor vs. raw pubkey.
- */
-export function isDescriptor(value) {
-    if (typeof value !== "string")
-        return false;
-    if (!value.startsWith("tr(") || !value.endsWith(")"))
-        return false;
-    // body length > 0 after stripping "tr(" and ")"
-    return value.length > "tr()".length;
-}
-/**
- * Normalize a value to descriptor format.
- * If already a descriptor, return as-is. If hex pubkey, wrap as tr(pubkey).
- * Throws when the value is empty or not a string so we never produce
- * malformed descriptors like `tr()` that downstream parsers would reject.
- */
-export function normalizeToDescriptor(value) {
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error("normalizeToDescriptor: expected a non-empty string value");
-    }
-    if (isDescriptor(value)) {
-        return value;
-    }
-    return `tr(${value})`;
-}
-/**
- * Extract the public key from a simple descriptor.
- * For simple descriptors (tr(pubkey)), extracts the pubkey using the library.
- * For HD descriptors, throws — use DescriptorProvider to derive the key.
- */
-export function extractPubKey(descriptor) {
-    if (!isDescriptor(descriptor)) {
-        return descriptor;
-    }
-    const network = isMainnetDescriptor(descriptor)
-        ? networks.bitcoin
-        : networks.testnet;
-    const expansion = expand({ descriptor, network });
-    if (!expansion.expansionMap) {
-        throw new Error("Cannot extract pubkey from descriptor: expansion failed.");
-    }
-    const key = expansion.expansionMap["@0"];
-    // HD descriptors (have a bip32 key) require DescriptorProvider for derivation
-    if (key?.bip32) {
-        throw new Error("Cannot extract pubkey from HD descriptor without derivation. " +
-            "Use DescriptorProvider to derive the key from the xpub.");
-    }
-    if (!key?.pubkey) {
-        throw new Error("Cannot extract pubkey from descriptor: no key found.");
-    }
-    return hex.encode(key.pubkey);
-}
-/**
- * Parse an HD descriptor into its components.
- * HD descriptors have the format: tr([fingerprint/path']xpub/derivation)
- * Returns null if the descriptor is not in HD format.
- */
-export function parseHDDescriptor(descriptor) {
-    if (!isDescriptor(descriptor)) {
-        return null;
-    }
-    let expansion;
-    try {
-        const network = isMainnetDescriptor(descriptor)
-            ? networks.bitcoin
-            : networks.testnet;
-        expansion = expand({ descriptor, network });
-    }
-    catch {
-        return null;
-    }
-    const key = expansion.expansionMap?.["@0"];
-    if (!key?.masterFingerprint ||
-        !key.originPath ||
-        !key.keyPath ||
-        !key.bip32) {
-        return null;
-    }
-    return {
-        fingerprint: hex.encode(key.masterFingerprint),
-        basePath: key.originPath.replace(/^\//, ""),
-        xpub: key.bip32.toBase58(),
-        derivationPath: key.keyPath.replace(/^\//, ""),
-    };
-}

package/dist/esm/identity/descriptorProvider.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/identity/hdCapableIdentity.js

@@ -1,17 +0,0 @@
-/**
- * Structural type guard for {@link HDCapableIdentity}. Returns `true`
- * when the value exposes the four members the HD wallet flow relies on:
- * `descriptor`, `isOurs`, `signWithDescriptor`, and
- * `signMessageWithDescriptor`. Used by callers that need to opt into
- * the HD path (e.g. installing an `HDDescriptorProvider`) without
- * coupling to a concrete identity class.
- */
-export function isHDCapableIdentity(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const v = value;
-    return (typeof v.descriptor === "string" &&
-        typeof v.isOurs === "function" &&
-        typeof v.signWithDescriptor === "function" &&
-        typeof v.signMessageWithDescriptor === "function");
-}

package/dist/esm/identity/index.js

@@ -1,13 +0,0 @@
-/** Type guard for identities that support batch signing. */
-export function isBatchSignable(identity) {
-    return ("signMultiple" in identity &&
-        typeof identity.signMultiple === "function");
-}
-export * from "./singleKey.js";
-export { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from "./seedIdentity.js";
-export * from "./serialize.js";
-// Descriptor utilities
-export { isDescriptor, normalizeToDescriptor, extractPubKey, parseHDDescriptor, } from "./descriptor.js";
-export { isHDCapableIdentity } from "./hdCapableIdentity.js";
-// Static descriptor provider (wrapper for legacy Identity)
-export { StaticDescriptorProvider } from "./staticDescriptorProvider.js";