@arkade-os/sdk 0.1.4 → 0.2.0

package/dist/esm/arknote/index.js

@@ -1,76 +1,77 @@
-import { base58 } from "@scure/base";
-// ArkNoteData is the unsigned data part of a note
-export class ArkNoteData {
-    constructor(id, value) {
-        this.id = id;
-        this.value = value;
-    }
-    encode() {
-        const array = new Uint8Array(12);
-        writeBigUInt64BE(array, this.id, 0);
-        writeUInt32BE(array, this.value, 8);
-        return array;
-    }
-    static decode(data) {
-        if (data.length !== 12) {
-            throw new Error(`invalid data length: expected 12 bytes, got ${data.length}`);
-        }
-        const id = readBigUInt64BE(data, 0);
-        const value = readUInt32BE(data, 8);
-        return new ArkNoteData(id, value);
-    }
-}
-// ArkNote is a note with the issuer's signature
+import { base58, hex } from "@scure/base";
+import { VtxoScript } from '../script/base.js';
+import { sha256 } from "@scure/btc-signer/utils";
+import { Script } from "@scure/btc-signer";
+/**
+ * ArkNotes are special virtual coins in the Ark protocol that can be created
+ * and spent without requiring any transactions. The server mints them, and they
+ * are encoded as base58 strings with a human-readable prefix. It contains a
+ * preimage and value.
+ *
+ * @example
+ * ```typescript
+ * // Create an ArkNote
+ * const note = new ArkNote(preimage, 50000);
+ *
+ * // Encode to string
+ * const noteString = note.toString();
+ *
+ * // Decode from string
+ * const decodedNote = ArkNote.fromString(noteString);
+ * ```
+ */
 export class ArkNote {
-    constructor(data, signature) {
-        this.data = data;
-        this.signature = signature;
+    constructor(preimage, value, HRP = ArkNote.DefaultHRP) {
+        this.preimage = preimage;
+        this.value = value;
+        this.HRP = HRP;
+        this.vout = 0;
+        const preimageHash = sha256(this.preimage);
+        this.vtxoScript = new VtxoScript([noteTapscript(preimageHash)]);
+        const leaf = this.vtxoScript.leaves[0];
+        this.txid = hex.encode(new Uint8Array(preimageHash).reverse());
+        this.tapTree = this.vtxoScript.encode();
+        this.forfeitTapLeafScript = leaf;
+        this.intentTapLeafScript = leaf;
+        this.value = value;
+        this.status = { confirmed: true };
+        this.extraWitness = [this.preimage];
     }
     encode() {
-        const detailsBytes = this.data.encode();
-        const result = new Uint8Array(detailsBytes.length + this.signature.length);
-        result.set(detailsBytes);
-        result.set(this.signature, detailsBytes.length);
+        const result = new Uint8Array(ArkNote.Length);
+        result.set(this.preimage, 0);
+        writeUInt32BE(result, this.value, this.preimage.length);
         return result;
     }
-    static decode(data) {
-        if (data.length < 12) {
-            throw new Error(`invalid data length: expected at least 12 bytes, got ${data.length}`);
+    static decode(data, hrp = ArkNote.DefaultHRP) {
+        if (data.length !== ArkNote.Length) {
+            throw new Error(`invalid data length: expected ${ArkNote.Length} bytes, got ${data.length}`);
         }
-        const noteData = ArkNoteData.decode(data.subarray(0, 12));
-        const signature = data.subarray(12);
-        if (signature.length !== 64) {
-            throw new Error(`invalid signature length: expected 64 bytes, got ${signature.length}`);
-        }
-        return new ArkNote(noteData, signature);
+        const preimage = data.subarray(0, ArkNote.PreimageLength);
+        const value = readUInt32BE(data, ArkNote.PreimageLength);
+        return new ArkNote(preimage, value, hrp);
     }
-    static fromString(noteStr) {
-        if (!noteStr.startsWith(ArkNote.HRP)) {
-            throw new Error(`invalid human-readable part: expected ${ArkNote.HRP} prefix (note '${noteStr}')`);
-        }
-        const encoded = noteStr.slice(ArkNote.HRP.length);
-        if (encoded.length < 103 || encoded.length > 104) {
-            throw new Error(`invalid note length: expected 103 or 104 chars, got ${encoded.length}`);
+    static fromString(noteStr, hrp = ArkNote.DefaultHRP) {
+        noteStr = noteStr.trim();
+        if (!noteStr.startsWith(hrp)) {
+            throw new Error(`invalid human-readable part: expected ${hrp} prefix (note '${noteStr}')`);
         }
+        const encoded = noteStr.slice(hrp.length);
         const decoded = base58.decode(encoded);
         if (decoded.length === 0) {
             throw new Error("failed to decode base58 string");
         }
-        return ArkNote.decode(new Uint8Array(decoded));
+        return ArkNote.decode(decoded, hrp);
     }
     toString() {
-        return ArkNote.HRP + base58.encode(this.encode());
+        return this.HRP + base58.encode(this.encode());
     }
 }
-ArkNote.HRP = "arknote";
-function writeBigUInt64BE(array, value, offset) {
-    const view = new DataView(array.buffer, array.byteOffset + offset, 8);
-    view.setBigUint64(0, value, false);
-}
-function readBigUInt64BE(array, offset) {
-    const view = new DataView(array.buffer, array.byteOffset + offset, 8);
-    return view.getBigUint64(0, false);
-}
+ArkNote.DefaultHRP = "arknote";
+ArkNote.PreimageLength = 32; // 32 bytes for the preimage
+ArkNote.ValueLength = 4; // 4 bytes for the value
+ArkNote.Length = ArkNote.PreimageLength + ArkNote.ValueLength;
+ArkNote.FakeOutpointIndex = 0;
 function writeUInt32BE(array, value, offset) {
     const view = new DataView(array.buffer, array.byteOffset + offset, 4);
     view.setUint32(0, value, false);
@@ -79,3 +80,6 @@ function readUInt32BE(array, offset) {
     const view = new DataView(array.buffer, array.byteOffset + offset, 4);
     return view.getUint32(0, false);
 }
+function noteTapscript(preimageHash) {
+    return Script.encode(["SHA256", preimageHash, "EQUAL"]);
+}

package/dist/esm/bip322/errors.js

@@ -0,0 +1,9 @@
+export class BIP322Error extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BIP322Error";
+    }
+}
+export const ErrMissingInputs = new BIP322Error("missing inputs");
+export const ErrMissingData = new BIP322Error("missing data");
+export const ErrMissingWitnessUtxo = new BIP322Error("missing witness utxo");

package/dist/esm/bip322/index.js

@@ -0,0 +1,174 @@
+import { OP, Transaction, Script, SigHash } from "@scure/btc-signer";
+import { ErrMissingData, ErrMissingInputs, ErrMissingWitnessUtxo, } from './errors.js';
+import { schnorr } from "@noble/curves/secp256k1";
+import { base64 } from "@scure/base";
+/**
+ * BIP-322 signature implementation for Bitcoin message signing.
+ *
+ * BIP-322 defines a standard for signing Bitcoin messages as well as proving
+ * ownership of coins. This namespace provides utilities for creating and
+ * validating BIP-322.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Create a BIP-322 proof
+ * const proof = BIP322.create(
+ *   "Hello Bitcoin!",
+ *   [input],
+ *   [output]
+ * );
+ *
+ * // Sign the proof
+ * const signedProof = await identity.sign(proof);
+ *
+ * // Extract the signature
+ * const signature = BIP322.signature(signedProof);
+ * ```
+ */
+export var BIP322;
+(function (BIP322) {
+    /**
+     * Creates a new BIP-322 "full" proof of funds unsigned transaction.
+     *
+     * This function constructs a special transaction that can be signed to prove
+     * ownership of VTXOs and UTXOs. The proof includes the message to be
+     * signed and the inputs/outputs that demonstrate ownership.
+     *
+     * @param message - The BIP-322 message to be signed
+     * @param inputs - Array of transaction inputs to prove ownership of
+     * @param outputs - Optional array of transaction outputs
+     * @returns An unsigned BIP-322 proof transaction
+     */
+    function create(message, inputs, outputs = []) {
+        if (inputs.length == 0)
+            throw ErrMissingInputs;
+        if (!validateInputs(inputs))
+            throw ErrMissingData;
+        if (!validateOutputs(outputs))
+            throw ErrMissingData;
+        // create the initial transaction to spend
+        const toSpend = craftToSpendTx(message, inputs[0].witnessUtxo.script);
+        // create the transaction to sign
+        return craftToSignTx(toSpend, inputs, outputs);
+    }
+    BIP322.create = create;
+    /**
+     * Finalizes and extracts the FullProof transaction into a BIP-322 signature.
+     *
+     * This function takes a signed proof transaction and converts it into a
+     * base64-encoded signature string. If the proof's inputs have special
+     * spending conditions, a custom finalizer can be provided.
+     *
+     * @param signedProof - The signed BIP-322 proof transaction
+     * @param finalizer - Optional custom finalizer function
+     * @returns Base64-encoded BIP-322 signature
+     */
+    function signature(signedProof, finalizer = (tx) => tx.finalize()) {
+        finalizer(signedProof);
+        return base64.encode(signedProof.extract());
+    }
+    BIP322.signature = signature;
+})(BIP322 || (BIP322 = {}));
+const OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([OP.RETURN]);
+const ZERO_32 = new Uint8Array(32).fill(0);
+const MAX_INDEX = 0xffffffff;
+const TAG_BIP322 = "BIP0322-signed-message";
+function validateInput(input) {
+    if (input.index === undefined)
+        throw ErrMissingData;
+    if (input.txid === undefined)
+        throw ErrMissingData;
+    if (input.witnessUtxo === undefined)
+        throw ErrMissingWitnessUtxo;
+    return true;
+}
+function validateInputs(inputs) {
+    inputs.forEach(validateInput);
+    return true;
+}
+function validateOutput(output) {
+    if (output.amount === undefined)
+        throw ErrMissingData;
+    if (output.script === undefined)
+        throw ErrMissingData;
+    return true;
+}
+function validateOutputs(outputs) {
+    outputs.forEach(validateOutput);
+    return true;
+}
+// craftToSpendTx creates the initial transaction that will be spent in the proof
+export function craftToSpendTx(message, pkScript) {
+    const messageHash = hashMessage(message);
+    const tx = new Transaction({
+        version: 0,
+        allowUnknownOutputs: true,
+        allowUnknown: true,
+        allowUnknownInputs: true,
+    });
+    // add input with zero hash and max index
+    tx.addInput({
+        txid: ZERO_32, // zero hash
+        index: MAX_INDEX,
+        sequence: 0,
+    });
+    // add output with zero value and provided pkScript
+    tx.addOutput({
+        amount: 0n,
+        script: pkScript,
+    });
+    tx.updateInput(0, {
+        finalScriptSig: Script.encode(["OP_0", messageHash]),
+    });
+    return tx;
+}
+// craftToSignTx creates the transaction that will be signed for the proof
+function craftToSignTx(toSpend, inputs, outputs) {
+    const firstInput = inputs[0];
+    const tx = new Transaction({
+        version: 2,
+        allowUnknownOutputs: outputs.length === 0,
+        allowUnknown: true,
+        allowUnknownInputs: true,
+        lockTime: 0,
+    });
+    // add the first "toSpend" input
+    tx.addInput({
+        ...firstInput,
+        txid: toSpend.id,
+        index: 0,
+        witnessUtxo: {
+            script: firstInput.witnessUtxo.script,
+            amount: 0n,
+        },
+        sighashType: SigHash.ALL,
+    });
+    // add other inputs
+    for (const input of inputs) {
+        tx.addInput({
+            ...input,
+            sighashType: SigHash.ALL,
+        });
+    }
+    // add the special OP_RETURN output if no outputs are provided
+    if (outputs.length === 0) {
+        outputs = [
+            {
+                amount: 0n,
+                script: OP_RETURN_EMPTY_PKSCRIPT,
+            },
+        ];
+    }
+    for (const output of outputs) {
+        tx.addOutput({
+            amount: output.amount,
+            script: output.script,
+        });
+    }
+    return tx;
+}
+function hashMessage(message) {
+    return schnorr.utils.taggedHash(TAG_BIP322, new TextEncoder().encode(message));
+}

package/dist/esm/forfeit.js

@@ -1,35 +1,24 @@
-import { SigHash, Transaction } from "@scure/btc-signer";
-export function buildForfeitTx({ connectorInput, vtxoInput, vtxoAmount, connectorAmount, feeAmount, vtxoPkScript, connectorPkScript, serverPkScript, txLocktime, }) {
+import { Transaction } from "@scure/btc-signer";
+import { P2A } from './utils/anchor.js';
+export function buildForfeitTx(inputs, forfeitPkScript, txLocktime) {
     const tx = new Transaction({
-        version: 2,
+        version: 3,
         lockTime: txLocktime,
     });
-    // Add connector input
-    tx.addInput({
-        txid: connectorInput.txid,
-        index: connectorInput.vout,
-        witnessUtxo: {
-            script: connectorPkScript,
-            amount: connectorAmount,
-        },
-        sequence: 0xffffffff,
-    });
-    // Add VTXO input
-    tx.addInput({
-        txid: vtxoInput.txid,
-        index: vtxoInput.vout,
-        witnessUtxo: {
-            script: vtxoPkScript,
-            amount: vtxoAmount,
-        },
-        sequence: txLocktime ? 0xfffffffe : 0xffffffff, // MAX_SEQUENCE - 1 if locktime is set
-        sighashType: SigHash.DEFAULT,
-    });
-    const amount = BigInt(vtxoAmount) + BigInt(connectorAmount) - BigInt(feeAmount);
+    let amount = 0n;
+    for (const input of inputs) {
+        if (!input.witnessUtxo) {
+            throw new Error("input needs witness utxo");
+        }
+        amount += input.witnessUtxo.amount;
+        tx.addInput(input);
+    }
     // Add main output to server
     tx.addOutput({
-        script: serverPkScript,
+        script: forfeitPkScript,
         amount,
     });
+    // Add P2A output
+    tx.addOutput(P2A);
     return tx;
 }

package/dist/esm/identity/singleKey.js

@@ -0,0 +1,64 @@
+import { pubSchnorr, randomPrivateKeyBytes } from "@scure/btc-signer/utils";
+import { hex } from "@scure/base";
+import { SigHash } from "@scure/btc-signer";
+import { TreeSignerSession } from '../tree/signingSession.js';
+const ZERO_32 = new Uint8Array(32).fill(0);
+const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
+/**
+ * In-memory single key implementation for Bitcoin transaction signing.
+ *
+ * @example
+ * ```typescript
+ * // Create from hex string
+ * const key = SingleKey.fromHex('your_private_key_hex');
+ *
+ * // Create from raw bytes
+ * const key = SingleKey.fromPrivateKey(privateKeyBytes);
+ *
+ * // Sign a transaction
+ * const signedTx = await key.sign(transaction);
+ * ```
+ */
+export class SingleKey {
+    constructor(key) {
+        this.key = key || randomPrivateKeyBytes();
+    }
+    static fromPrivateKey(privateKey) {
+        return new SingleKey(privateKey);
+    }
+    static fromHex(privateKeyHex) {
+        return new SingleKey(hex.decode(privateKeyHex));
+    }
+    async sign(tx, inputIndexes) {
+        const txCpy = tx.clone();
+        if (!inputIndexes) {
+            try {
+                if (!txCpy.sign(this.key, ALL_SIGHASH, ZERO_32)) {
+                    throw new Error("Failed to sign transaction");
+                }
+            }
+            catch (e) {
+                if (e instanceof Error &&
+                    e.message.includes("No inputs signed")) {
+                    // ignore
+                }
+                else {
+                    throw e;
+                }
+            }
+            return txCpy;
+        }
+        for (const inputIndex of inputIndexes) {
+            if (!txCpy.signIdx(this.key, inputIndex, ALL_SIGHASH, ZERO_32)) {
+                throw new Error(`Failed to sign input #${inputIndex}`);
+            }
+        }
+        return txCpy;
+    }
+    xOnlyPublicKey() {
+        return pubSchnorr(this.key);
+    }
+    signerSession() {
+        return TreeSignerSession.random();
+    }
+}

package/dist/esm/index.js

@@ -1,38 +1,56 @@
-import { InMemoryKey } from './identity/inMemoryKey.js';
+import { SingleKey } from './identity/singleKey.js';
 import { ArkAddress } from './script/address.js';
 import { VHTLC } from './script/vhtlc.js';
 import { DefaultVtxo } from './script/default.js';
 import { VtxoScript } from './script/base.js';
 import { TxType, } from './wallet/index.js';
-import { Wallet } from './wallet/wallet.js';
+import { Wallet, waitForIncomingFunds } from './wallet/wallet.js';
+import { TxTree } from './tree/txTree.js';
+import { Ramps } from './wallet/ramps.js';
 import { ServiceWorkerWallet } from './wallet/serviceWorker/wallet.js';
+import { OnchainWallet } from './wallet/onchain.js';
 import { setupServiceWorker } from './wallet/serviceWorker/utils.js';
 import { Worker } from './wallet/serviceWorker/worker.js';
 import { Request } from './wallet/serviceWorker/request.js';
 import { Response } from './wallet/serviceWorker/response.js';
-import { ESPLORA_URL, EsploraProvider } from './providers/onchain.js';
-import { RestArkProvider } from './providers/ark.js';
+import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
+import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
-import { addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx, } from './utils/psbt.js';
-import { ArkNote, ArkNoteData } from './arknote/index.js';
+import { buildOffchainTx, } from './utils/arkTransaction.js';
+import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
+import { BIP322 } from './bip322/index.js';
+import { ArkNote } from './arknote/index.js';
 import { IndexedDBVtxoRepository } from './wallet/serviceWorker/db/vtxo/idb.js';
 import { networks } from './networks.js';
-export { Wallet, InMemoryKey, 
+import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
+import { P2A } from './utils/anchor.js';
+import { Unroll } from './wallet/unroll.js';
+export { 
+// Wallets
+Wallet, SingleKey, OnchainWallet, Ramps, 
 // Providers
-ESPLORA_URL, EsploraProvider, RestArkProvider, 
+ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, 
 // Script-related
 ArkAddress, DefaultVtxo, VtxoScript, VHTLC, 
 // Enums
-TxType, 
+TxType, IndexerTxType, ChainTxType, SettlementEventType, 
 // Service Worker
 setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, 
 // Tapscript
 decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, 
+// Ark PSBT fields
+ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
 // Utils
-addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx, 
+buildOffchainTx, waitForIncomingFunds, 
 // Arknote
-ArkNote, ArkNoteData, 
+ArkNote, 
 // Network
 networks, 
 // Database
-IndexedDBVtxoRepository, };
+IndexedDBVtxoRepository, 
+// BIP322
+BIP322, 
+// TxTree
+TxTree, 
+// Anchor
+P2A, Unroll, };