@arkade-os/sdk 0.1.4 → 0.2.0

package/dist/esm/identity/inMemoryKey.js

@@ -1,36 +0,0 @@
-import { pubSchnorr, randomPrivateKeyBytes } from "@scure/btc-signer/utils";
-import { hex } from "@scure/base";
-import { TreeSignerSession } from '../tree/signingSession.js';
-const ZERO_32 = new Uint8Array(32).fill(0);
-export class InMemoryKey {
-    constructor(key) {
-        this.key = key || randomPrivateKeyBytes();
-    }
-    static fromPrivateKey(privateKey) {
-        return new InMemoryKey(privateKey);
-    }
-    static fromHex(privateKeyHex) {
-        return new InMemoryKey(hex.decode(privateKeyHex));
-    }
-    async sign(tx, inputIndexes) {
-        const txCpy = tx.clone();
-        if (!inputIndexes) {
-            if (!txCpy.sign(this.key, undefined, ZERO_32)) {
-                throw new Error("Failed to sign transaction");
-            }
-            return txCpy;
-        }
-        for (const inputIndex of inputIndexes) {
-            if (!txCpy.signIdx(this.key, inputIndex, undefined, ZERO_32)) {
-                throw new Error(`Failed to sign input #${inputIndex}`);
-            }
-        }
-        return txCpy;
-    }
-    xOnlyPublicKey() {
-        return pubSchnorr(this.key);
-    }
-    signerSession() {
-        return TreeSignerSession.random();
-    }
-}

package/dist/esm/tree/vtxoTree.js

@@ -1,191 +0,0 @@
-import * as bip68 from "bip68";
-import { RawTx, ScriptNum, Transaction } from "@scure/btc-signer";
-import { sha256x2 } from "@scure/btc-signer/utils";
-import { base64, hex } from "@scure/base";
-export class TxTreeError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "TxTreeError";
-    }
-}
-export const ErrLeafNotFound = new TxTreeError("leaf not found in tx tree");
-export const ErrParentNotFound = new TxTreeError("parent not found");
-// TxTree is represented as a matrix of Node objects
-// the first level of the matrix is the root of the tree
-export class TxTree {
-    constructor(tree) {
-        this.tree = tree;
-    }
-    get levels() {
-        return this.tree;
-    }
-    // Returns the root node of the vtxo tree
-    root() {
-        if (this.tree.length <= 0 || this.tree[0].length <= 0) {
-            throw new TxTreeError("empty vtxo tree");
-        }
-        return this.tree[0][0];
-    }
-    // Returns the leaves of the vtxo tree
-    leaves() {
-        const leaves = [...this.tree[this.tree.length - 1]];
-        // Check other levels for leaf nodes
-        for (let i = 0; i < this.tree.length - 1; i++) {
-            for (const node of this.tree[i]) {
-                if (node.leaf) {
-                    leaves.push(node);
-                }
-            }
-        }
-        return leaves;
-    }
-    // Returns all nodes that have the given node as parent
-    children(nodeTxid) {
-        const children = [];
-        for (const level of this.tree) {
-            for (const node of level) {
-                if (node.parentTxid === nodeTxid) {
-                    children.push(node);
-                }
-            }
-        }
-        return children;
-    }
-    // Returns the total number of nodes in the vtxo tree
-    numberOfNodes() {
-        return this.tree.reduce((count, level) => count + level.length, 0);
-    }
-    // Returns the branch of the given vtxo txid from root to leaf
-    branch(vtxoTxid) {
-        const branch = [];
-        const leaves = this.leaves();
-        // Check if the vtxo is a leaf
-        const leaf = leaves.find((leaf) => leaf.txid === vtxoTxid);
-        if (!leaf) {
-            throw ErrLeafNotFound;
-        }
-        branch.push(leaf);
-        const rootTxid = this.root().txid;
-        while (branch[0].txid !== rootTxid) {
-            const parent = this.findParent(branch[0]);
-            branch.unshift(parent);
-        }
-        return branch;
-    }
-    // Returns the remaining transactions to broadcast in order to exit the vtxo
-    async exitBranch(vtxoTxid, isTxConfirmed) {
-        const offchainPart = await getOffchainPart(this.branch(vtxoTxid), isTxConfirmed);
-        return offchainPart.map(getExitTransaction);
-    }
-    // Helper method to find parent of a node
-    findParent(node) {
-        for (const level of this.tree) {
-            for (const potentialParent of level) {
-                if (potentialParent.txid === node.parentTxid) {
-                    return potentialParent;
-                }
-            }
-        }
-        throw ErrParentNotFound;
-    }
-    // Validates that the tree is coherent by checking txids and parent relationships
-    validate() {
-        // Skip the root level, validate from level 1 onwards
-        for (let i = 1; i < this.tree.length; i++) {
-            for (const node of this.tree[i]) {
-                // Verify that the node's transaction matches its claimed txid
-                const tx = Transaction.fromPSBT(base64.decode(node.tx));
-                const txid = hex.encode(sha256x2(tx.toBytes(true)).reverse());
-                if (txid !== node.txid) {
-                    throw new TxTreeError(`node ${node.txid} has txid ${node.txid}, but computed txid is ${txid}`);
-                }
-                // Verify that the node has a valid parent
-                try {
-                    this.findParent(node);
-                }
-                catch (err) {
-                    throw new TxTreeError(`node ${node.txid} has no parent: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-        }
-    }
-}
-const COSIGNER_KEY_PREFIX = new Uint8Array("cosigner".split("").map((c) => c.charCodeAt(0)));
-const VTXO_TREE_EXPIRY_PSBT_KEY = new Uint8Array("expiry".split("").map((c) => c.charCodeAt(0)));
-export function getVtxoTreeExpiry(input) {
-    if (!input.unknown)
-        return null;
-    for (const u of input.unknown) {
-        // Check if key contains the VTXO tree expiry key
-        if (u.key.length < VTXO_TREE_EXPIRY_PSBT_KEY.length)
-            continue;
-        let found = true;
-        for (let i = 0; i < VTXO_TREE_EXPIRY_PSBT_KEY.length; i++) {
-            if (u.key[i] !== VTXO_TREE_EXPIRY_PSBT_KEY[i]) {
-                found = false;
-                break;
-            }
-        }
-        if (found) {
-            const value = ScriptNum(6, true).decode(u.value);
-            const { blocks, seconds } = bip68.decode(Number(value));
-            return {
-                type: blocks ? "blocks" : "seconds",
-                value: BigInt(blocks ?? seconds ?? 0),
-            };
-        }
-    }
-    return null;
-}
-function parsePrefixedCosignerKey(key) {
-    if (key.length < COSIGNER_KEY_PREFIX.length)
-        return false;
-    for (let i = 0; i < COSIGNER_KEY_PREFIX.length; i++) {
-        if (key[i] !== COSIGNER_KEY_PREFIX[i])
-            return false;
-    }
-    return true;
-}
-export function getCosignerKeys(tx) {
-    const keys = [];
-    const input = tx.getInput(0);
-    if (!input.unknown)
-        return keys;
-    for (const unknown of input.unknown) {
-        const ok = parsePrefixedCosignerKey(new Uint8Array([unknown[0].type, ...unknown[0].key]));
-        if (!ok)
-            continue;
-        // Assuming the value is already a valid public key in compressed format
-        keys.push(unknown[1]);
-    }
-    return keys;
-}
-async function getOffchainPart(branch, isTxConfirmed) {
-    let offchainPath = [...branch];
-    // Iterate from the end of the branch (leaf) to the beginning (root)
-    for (let i = branch.length - 1; i >= 0; i--) {
-        const node = branch[i];
-        // check if the transaction is confirmed on-chain
-        if (await isTxConfirmed(node.txid)) {
-            // if this is the leaf node, return empty array as everything is confirmed
-            if (i === branch.length - 1) {
-                return [];
-            }
-            // otherwise, return the unconfirmed part of the branch
-            return branch.slice(i + 1);
-        }
-    }
-    // no confirmation: everything is offchain
-    return offchainPath;
-}
-// getExitTransaction finalizes the psbt's input using the musig2 tapkey signature
-function getExitTransaction(treeNode) {
-    const tx = Transaction.fromPSBT(base64.decode(treeNode.tx));
-    const input = tx.getInput(0);
-    if (!input.tapKeySig)
-        throw new TxTreeError("missing tapkey signature");
-    const rawTx = RawTx.decode(tx.unsignedTx);
-    rawTx.witnesses = [[input.tapKeySig]];
-    rawTx.segwitFlag = true;
-    return hex.encode(RawTx.encode(rawTx));
-}

package/dist/esm/utils/coinselect.js

@@ -1,69 +0,0 @@
-/**
- * Select coins to reach a target amount, prioritizing those closer to expiry
- * @param coins List of coins to select from
- * @param targetAmount Target amount to reach in satoshis
- * @returns Selected coins and change amount, or null if insufficient funds
- */
-export function selectCoins(coins, targetAmount) {
-    // Sort coins by amount (descending)
-    const sortedCoins = [...coins].sort((a, b) => b.value - a.value);
-    const selectedCoins = [];
-    let selectedAmount = 0;
-    // Select coins until we have enough
-    for (const coin of sortedCoins) {
-        selectedCoins.push(coin);
-        selectedAmount += coin.value;
-        if (selectedAmount >= targetAmount) {
-            break;
-        }
-    }
-    // Check if we have enough
-    if (selectedAmount < targetAmount) {
-        return { inputs: null, changeAmount: 0 };
-    }
-    // Calculate change
-    const changeAmount = selectedAmount - targetAmount;
-    return {
-        inputs: selectedCoins,
-        changeAmount,
-    };
-}
-/**
- * Select virtual coins to reach a target amount, prioritizing those closer to expiry
- * @param coins List of virtual coins to select from
- * @param targetAmount Target amount to reach in satoshis
- * @returns Selected coins and change amount, or null if insufficient funds
- */
-export function selectVirtualCoins(coins, targetAmount) {
-    // Sort VTXOs by expiry (ascending) and amount (descending)
-    const sortedCoins = [...coins].sort((a, b) => {
-        // First sort by expiry if available
-        const expiryA = a.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
-        const expiryB = b.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
-        if (expiryA !== expiryB) {
-            return expiryA - expiryB; // Earlier expiry first
-        }
-        // Then sort by amount
-        return b.value - a.value; // Larger amount first
-    });
-    const selectedCoins = [];
-    let selectedAmount = 0;
-    // Select coins until we have enough
-    for (const coin of sortedCoins) {
-        selectedCoins.push(coin);
-        selectedAmount += coin.value;
-        if (selectedAmount >= targetAmount) {
-            break;
-        }
-    }
-    // Check if we have enough
-    if (selectedAmount < targetAmount) {
-        return { inputs: null, changeAmount: 0 };
-    }
-    // Calculate change
-    const changeAmount = selectedAmount - targetAmount;
-    return {
-        inputs: selectedCoins,
-        changeAmount,
-    };
-}

package/dist/esm/utils/psbt.js

@@ -1,131 +0,0 @@
-import { DEFAULT_SEQUENCE, RawWitness, Transaction } from "@scure/btc-signer";
-import { CLTVMultisigTapscript, decodeTapscript } from '../script/tapscript.js';
-import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
-import { ArkAddress } from '../script/address.js';
-import { hex } from "@scure/base";
-const ARK_UNKNOWN_KEY_TYPE = 255;
-// Constant for condition witness key prefix
-export const CONDITION_WITNESS_KEY_PREFIX = new TextEncoder().encode("condition");
-export const VTXO_TAPROOT_TREE_KEY_PREFIX = new TextEncoder().encode("taptree");
-export function addVtxoTaprootTree(inIndex, tx, scripts) {
-    tx.updateInput(inIndex, {
-        unknown: [
-            ...(tx.getInput(inIndex)?.unknown ?? []),
-            [
-                {
-                    type: ARK_UNKNOWN_KEY_TYPE,
-                    key: VTXO_TAPROOT_TREE_KEY_PREFIX,
-                },
-                encodeTaprootTree(scripts),
-            ],
-        ],
-    });
-}
-export function addConditionWitness(inIndex, tx, witness) {
-    const witnessBytes = RawWitness.encode(witness);
-    tx.updateInput(inIndex, {
-        unknown: [
-            ...(tx.getInput(inIndex)?.unknown ?? []),
-            [
-                {
-                    type: ARK_UNKNOWN_KEY_TYPE,
-                    key: CONDITION_WITNESS_KEY_PREFIX,
-                },
-                witnessBytes,
-            ],
-        ],
-    });
-}
-export function createVirtualTx(inputs, outputs) {
-    let lockTime = 0n;
-    for (const input of inputs) {
-        const tapscript = decodeTapscript(scriptFromTapLeafScript(input.tapLeafScript));
-        if (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({
-        allowUnknown: true,
-        lockTime: Number(lockTime),
-    });
-    for (const [i, input] of inputs.entries()) {
-        tx.addInput({
-            txid: input.txid,
-            index: input.vout,
-            sequence: lockTime ? DEFAULT_SEQUENCE - 1 : undefined,
-            witnessUtxo: {
-                script: VtxoScript.decode(input.scripts).pkScript,
-                amount: BigInt(input.value),
-            },
-            tapLeafScript: [input.tapLeafScript],
-        });
-        // add BIP371 encoded taproot tree to the unknown key field
-        addVtxoTaprootTree(i, tx, input.scripts.map(hex.decode));
-    }
-    for (const output of outputs) {
-        tx.addOutput({
-            amount: output.amount,
-            script: ArkAddress.decode(output.address).pkScript,
-        });
-    }
-    return tx;
-}
-function encodeTaprootTree(leaves) {
-    const chunks = [];
-    // Write number of leaves as compact size uint
-    chunks.push(encodeCompactSizeUint(leaves.length));
-    for (const tapscript of leaves) {
-        // Write depth (always 1 for now)
-        chunks.push(new Uint8Array([1]));
-        // Write leaf version (0xc0 for tapscript)
-        chunks.push(new Uint8Array([0xc0]));
-        // Write script length and script
-        chunks.push(encodeCompactSizeUint(tapscript.length));
-        chunks.push(tapscript);
-    }
-    // Concatenate all chunks
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return result;
-}
-function encodeCompactSizeUint(value) {
-    if (value < 0xfd) {
-        return new Uint8Array([value]);
-    }
-    else if (value <= 0xffff) {
-        const buffer = new Uint8Array(3);
-        buffer[0] = 0xfd;
-        new DataView(buffer.buffer).setUint16(1, value, true);
-        return buffer;
-    }
-    else if (value <= 0xffffffff) {
-        const buffer = new Uint8Array(5);
-        buffer[0] = 0xfe;
-        new DataView(buffer.buffer).setUint32(1, value, true);
-        return buffer;
-    }
-    else {
-        const buffer = new Uint8Array(9);
-        buffer[0] = 0xff;
-        new DataView(buffer.buffer).setBigUint64(1, BigInt(value), true);
-        return buffer;
-    }
-}
-const nLocktimeMinSeconds = 500000000n;
-function isSeconds(locktime) {
-    return locktime >= nLocktimeMinSeconds;
-}

package/dist/types/identity/inMemoryKey.d.ts

@@ -1,12 +0,0 @@
-import { Transaction } from "@scure/btc-signer";
-import { Identity } from ".";
-import { SignerSession } from "../tree/signingSession";
-export declare class InMemoryKey implements Identity {
-    private key;
-    private constructor();
-    static fromPrivateKey(privateKey: Uint8Array): InMemoryKey;
-    static fromHex(privateKeyHex: string): InMemoryKey;
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    xOnlyPublicKey(): Uint8Array;
-    signerSession(): SignerSession;
-}

package/dist/types/tree/vtxoTree.d.ts

@@ -1,33 +0,0 @@
-import { Transaction } from "@scure/btc-signer";
-import { RelativeTimelock } from "../script/tapscript";
-export interface TreeNode {
-    txid: string;
-    tx: string;
-    parentTxid: string;
-    leaf: boolean;
-}
-export declare class TxTreeError extends Error {
-    constructor(message: string);
-}
-export declare const ErrLeafNotFound: TxTreeError;
-export declare const ErrParentNotFound: TxTreeError;
-export declare class TxTree {
-    private tree;
-    constructor(tree: TreeNode[][]);
-    get levels(): TreeNode[][];
-    root(): TreeNode;
-    leaves(): TreeNode[];
-    children(nodeTxid: string): TreeNode[];
-    numberOfNodes(): number;
-    branch(vtxoTxid: string): TreeNode[];
-    exitBranch(vtxoTxid: string, isTxConfirmed: (txid: string) => Promise<boolean>): Promise<string[]>;
-    private findParent;
-    validate(): void;
-}
-export declare function getVtxoTreeExpiry(input: {
-    unknown?: {
-        key: Uint8Array;
-        value: Uint8Array;
-    }[];
-}): RelativeTimelock | null;
-export declare function getCosignerKeys(tx: Transaction): Uint8Array[];

package/dist/types/utils/coinselect.d.ts

@@ -1,21 +0,0 @@
-import type { Coin, VirtualCoin } from "../wallet";
-/**
- * Select coins to reach a target amount, prioritizing those closer to expiry
- * @param coins List of coins to select from
- * @param targetAmount Target amount to reach in satoshis
- * @returns Selected coins and change amount, or null if insufficient funds
- */
-export declare function selectCoins(coins: Coin[], targetAmount: number): {
-    inputs: Coin[] | null;
-    changeAmount: number;
-};
-/**
- * Select virtual coins to reach a target amount, prioritizing those closer to expiry
- * @param coins List of virtual coins to select from
- * @param targetAmount Target amount to reach in satoshis
- * @returns Selected coins and change amount, or null if insufficient funds
- */
-export declare function selectVirtualCoins(coins: VirtualCoin[], targetAmount: number): {
-    inputs: VirtualCoin[] | null;
-    changeAmount: number;
-};

package/dist/types/utils/psbt.d.ts

@@ -1,11 +0,0 @@
-import { Transaction } from "@scure/btc-signer";
-import { VirtualCoin } from "../wallet";
-import { Output } from "../providers/ark";
-import { EncodedVtxoScript, TapLeafScript } from "../script/base";
-export declare const CONDITION_WITNESS_KEY_PREFIX: Uint8Array<ArrayBufferLike>;
-export declare const VTXO_TAPROOT_TREE_KEY_PREFIX: Uint8Array<ArrayBufferLike>;
-export declare function addVtxoTaprootTree(inIndex: number, tx: Transaction, scripts: Uint8Array[]): void;
-export declare function addConditionWitness(inIndex: number, tx: Transaction, witness: Uint8Array[]): void;
-export declare function createVirtualTx(inputs: ({
-    tapLeafScript: TapLeafScript;
-} & EncodedVtxoScript & Pick<VirtualCoin, "txid" | "vout" | "value">)[], outputs: Output[]): Transaction;