@arkade-os/sdk 0.0.16

package/dist/cjs/utils/bip21.js

@@ -0,0 +1,114 @@
+"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 {
+    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 ARK 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}`;
+    }
+    static parse(uri) {
+        if (!uri.toLowerCase().startsWith("bitcoin:")) {
+            throw new Error(BIP21Error.INVALID_URI);
+        }
+        // Remove bitcoin: prefix, preserving 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 ARK 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/coinselect.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectCoins = selectCoins;
+exports.selectVirtualCoins = selectVirtualCoins;
+/**
+ * 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
+ */
+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
+ */
+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/cjs/utils/psbt.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VTXO_TAPROOT_TREE_KEY_PREFIX = exports.CONDITION_WITNESS_KEY_PREFIX = void 0;
+exports.addVtxoTaprootTree = addVtxoTaprootTree;
+exports.addConditionWitness = addConditionWitness;
+exports.createVirtualTx = createVirtualTx;
+const btc_signer_1 = require("@scure/btc-signer");
+const tapscript_1 = require("../script/tapscript");
+const base_1 = require("../script/base");
+const address_1 = require("../script/address");
+const base_2 = require("@scure/base");
+const ARK_UNKNOWN_KEY_TYPE = 255;
+// Constant for condition witness key prefix
+exports.CONDITION_WITNESS_KEY_PREFIX = new TextEncoder().encode("condition");
+exports.VTXO_TAPROOT_TREE_KEY_PREFIX = new TextEncoder().encode("taptree");
+function addVtxoTaprootTree(inIndex, tx, scripts) {
+    tx.updateInput(inIndex, {
+        unknown: [
+            ...(tx.getInput(inIndex)?.unknown ?? []),
+            [
+                {
+                    type: ARK_UNKNOWN_KEY_TYPE,
+                    key: exports.VTXO_TAPROOT_TREE_KEY_PREFIX,
+                },
+                encodeTaprootTree(scripts),
+            ],
+        ],
+    });
+}
+function addConditionWitness(inIndex, tx, witness) {
+    const witnessBytes = btc_signer_1.RawWitness.encode(witness);
+    tx.updateInput(inIndex, {
+        unknown: [
+            ...(tx.getInput(inIndex)?.unknown ?? []),
+            [
+                {
+                    type: ARK_UNKNOWN_KEY_TYPE,
+                    key: exports.CONDITION_WITNESS_KEY_PREFIX,
+                },
+                witnessBytes,
+            ],
+        ],
+    });
+}
+function createVirtualTx(inputs, outputs) {
+    let lockTime;
+    for (const input of inputs) {
+        const tapscript = (0, tapscript_1.decodeTapscript)((0, base_1.scriptFromTapLeafScript)(input.tapLeafScript));
+        if (tapscript_1.CLTVMultisigTapscript.is(tapscript)) {
+            lockTime = Number(tapscript.params.absoluteTimelock);
+        }
+    }
+    const tx = new btc_signer_1.Transaction({
+        allowUnknown: true,
+        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_1.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(base_2.hex.decode));
+    }
+    for (const output of outputs) {
+        tx.addOutput({
+            amount: output.amount,
+            script: address_1.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;
+    }
+}

package/dist/cjs/utils/transactionHistory.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vtxosToTxs = vtxosToTxs;
+const wallet_1 = require("../wallet");
+/**
+ * Helper function to find vtxos that were spent in a settlement
+ */
+function findVtxosSpentInSettlement(vtxos, vtxo) {
+    if (vtxo.virtualStatus.state === "pending") {
+        return [];
+    }
+    return vtxos.filter((v) => {
+        if (!v.spentBy)
+            return false;
+        return v.spentBy === vtxo.virtualStatus.batchTxID;
+    });
+}
+/**
+ * Helper function to find vtxos that were spent in a payment
+ */
+function findVtxosSpentInPayment(vtxos, vtxo) {
+    return vtxos.filter((v) => {
+        if (!v.spentBy)
+            return false;
+        return v.spentBy === vtxo.txid;
+    });
+}
+/**
+ * Helper function to find vtxos that resulted from a spentBy transaction
+ */
+function findVtxosResultedFromSpentBy(vtxos, spentBy) {
+    return vtxos.filter((v) => {
+        if (v.virtualStatus.state !== "pending" &&
+            v.virtualStatus.batchTxID === spentBy) {
+            return true;
+        }
+        return v.txid === spentBy;
+    });
+}
+/**
+ * Helper function to reduce vtxos to their total amount
+ */
+function reduceVtxosAmount(vtxos) {
+    return vtxos.reduce((sum, v) => sum + v.value, 0);
+}
+/**
+ * Helper function to get a vtxo from a list of vtxos
+ */
+function getVtxo(resultedVtxos, spentVtxos) {
+    if (resultedVtxos.length === 0) {
+        return spentVtxos[0];
+    }
+    return resultedVtxos[0];
+}
+function vtxosToTxs(spendable, spent, boardingRounds) {
+    const txs = [];
+    // Receive case
+    // All vtxos are received unless:
+    // - they resulted from a settlement (either boarding or refresh)
+    // - they are the change of a spend tx
+    let vtxosLeftToCheck = [...spent];
+    for (const vtxo of [...spendable, ...spent]) {
+        if (vtxo.virtualStatus.state !== "pending" &&
+            boardingRounds.has(vtxo.virtualStatus.batchTxID || "")) {
+            continue;
+        }
+        const settleVtxos = findVtxosSpentInSettlement(vtxosLeftToCheck, vtxo);
+        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, settleVtxos);
+        const settleAmount = reduceVtxosAmount(settleVtxos);
+        if (vtxo.value <= settleAmount) {
+            continue; // settlement or change, ignore
+        }
+        const spentVtxos = findVtxosSpentInPayment(vtxosLeftToCheck, vtxo);
+        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, spentVtxos);
+        const spentAmount = reduceVtxosAmount(spentVtxos);
+        if (vtxo.value <= spentAmount) {
+            continue; // settlement or change, ignore
+        }
+        const txKey = {
+            roundTxid: vtxo.virtualStatus.batchTxID || "",
+            boardingTxid: "",
+            redeemTxid: "",
+        };
+        let settled = vtxo.virtualStatus.state !== "pending";
+        if (vtxo.virtualStatus.state === "pending") {
+            txKey.redeemTxid = vtxo.txid;
+            if (vtxo.spentBy) {
+                settled = true;
+            }
+        }
+        txs.push({
+            key: txKey,
+            amount: vtxo.value - settleAmount - spentAmount,
+            type: wallet_1.TxType.TxReceived,
+            createdAt: vtxo.createdAt.getTime(),
+            settled,
+        });
+    }
+    // send case
+    // All "spentBy" vtxos are payments unless:
+    // - they are settlements
+    // aggregate spent by spentId
+    const vtxosBySpentBy = new Map();
+    for (const v of spent) {
+        if (!v.spentBy)
+            continue;
+        if (!vtxosBySpentBy.has(v.spentBy)) {
+            vtxosBySpentBy.set(v.spentBy, []);
+        }
+        const currentVtxos = vtxosBySpentBy.get(v.spentBy);
+        vtxosBySpentBy.set(v.spentBy, [...currentVtxos, v]);
+    }
+    for (const [sb, vtxos] of vtxosBySpentBy) {
+        const resultedVtxos = findVtxosResultedFromSpentBy([...spendable, ...spent], sb);
+        const resultedAmount = reduceVtxosAmount(resultedVtxos);
+        const spentAmount = reduceVtxosAmount(vtxos);
+        if (spentAmount <= resultedAmount) {
+            continue; // settlement or change, ignore
+        }
+        const vtxo = getVtxo(resultedVtxos, vtxos);
+        const txKey = {
+            roundTxid: vtxo.virtualStatus.batchTxID || "",
+            boardingTxid: "",
+            redeemTxid: "",
+        };
+        if (vtxo.virtualStatus.state === "pending") {
+            txKey.redeemTxid = vtxo.txid;
+        }
+        txs.push({
+            key: txKey,
+            amount: spentAmount - resultedAmount,
+            type: wallet_1.TxType.TxSent,
+            createdAt: vtxo.createdAt.getTime(),
+            settled: true,
+        });
+    }
+    return txs;
+}
+function removeVtxosFromList(vtxos, vtxosToRemove) {
+    return vtxos.filter((v) => {
+        for (const vtxoToRemove of vtxosToRemove) {
+            if (v.txid === vtxoToRemove.txid && v.vout === vtxoToRemove.vout) {
+                return false;
+            }
+        }
+        return true;
+    });
+}

package/dist/cjs/utils/txSizeEstimator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxWeightEstimator = void 0;
+class TxWeightEstimator {
+    constructor(hasWitness, inputCount, outputCount, inputSize, inputWitnessSize, outputSize) {
+        this.hasWitness = hasWitness;
+        this.inputCount = inputCount;
+        this.outputCount = outputCount;
+        this.inputSize = inputSize;
+        this.inputWitnessSize = inputWitnessSize;
+        this.outputSize = outputSize;
+    }
+    static create() {
+        return new TxWeightEstimator(false, 0, 0, 0, 0, 0);
+    }
+    addKeySpendInput(isDefault = true) {
+        this.inputCount++;
+        this.inputWitnessSize += 64 + 1 + (isDefault ? 0 : 1);
+        this.inputSize += TxWeightEstimator.INPUT_SIZE;
+        this.hasWitness = true;
+        return this;
+    }
+    addP2PKHInput() {
+        this.inputCount++;
+        this.inputWitnessSize++;
+        this.inputSize +=
+            TxWeightEstimator.INPUT_SIZE +
+                TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE;
+        return this;
+    }
+    addTapscriptInput(leafWitnessSize, leafScriptSize, leafControlBlockSize) {
+        const controlBlockWitnessSize = 1 +
+            TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE +
+            1 +
+            leafScriptSize +
+            1 +
+            leafControlBlockSize;
+        this.inputCount++;
+        this.inputWitnessSize += leafWitnessSize + controlBlockWitnessSize;
+        this.inputSize += TxWeightEstimator.INPUT_SIZE;
+        this.hasWitness = true;
+        this.inputCount++;
+        return this;
+    }
+    addP2WKHOutput() {
+        this.outputCount++;
+        this.outputSize +=
+            TxWeightEstimator.OUTPUT_SIZE + TxWeightEstimator.P2WKH_OUTPUT_SIZE;
+        return this;
+    }
+    vsize() {
+        const getVarIntSize = (n) => {
+            if (n < 0xfd)
+                return 1;
+            if (n < 0xffff)
+                return 3;
+            if (n < 0xffffffff)
+                return 5;
+            return 9;
+        };
+        const inputCount = getVarIntSize(this.inputCount);
+        const outputCount = getVarIntSize(this.outputCount);
+        // Calculate the size of the transaction without witness data
+        const txSizeStripped = TxWeightEstimator.BASE_TX_SIZE +
+            inputCount +
+            this.inputSize +
+            outputCount +
+            this.outputSize;
+        // Calculate the total weight
+        let weight = txSizeStripped * TxWeightEstimator.WITNESS_SCALE_FACTOR;
+        // Add witness data if present
+        if (this.hasWitness) {
+            weight +=
+                TxWeightEstimator.WITNESS_HEADER_SIZE + this.inputWitnessSize;
+        }
+        // Convert weight to vsize (weight / 4, rounded up)
+        return vsize(weight);
+    }
+}
+exports.TxWeightEstimator = TxWeightEstimator;
+TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE = 1 + 73 + 1 + 33;
+TxWeightEstimator.INPUT_SIZE = 32 + 4 + 1 + 4;
+TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE = 1 + 32;
+TxWeightEstimator.OUTPUT_SIZE = 8 + 1;
+TxWeightEstimator.P2WKH_OUTPUT_SIZE = 1 + 1 + 20;
+TxWeightEstimator.BASE_TX_SIZE = 8 + 2; // Version + LockTime
+TxWeightEstimator.WITNESS_HEADER_SIZE = 2; // Flag + Marker
+TxWeightEstimator.WITNESS_SCALE_FACTOR = 4;
+const vsize = (weight) => {
+    const value = BigInt(Math.ceil(weight / TxWeightEstimator.WITNESS_SCALE_FACTOR));
+    return {
+        value,
+        fee: (feeRate) => feeRate * value,
+    };
+};

package/dist/cjs/wallet/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxType = void 0;
+var TxType;
+(function (TxType) {
+    TxType["TxSent"] = "SENT";
+    TxType["TxReceived"] = "RECEIVED";
+})(TxType || (exports.TxType = TxType = {}));