@arkade-os/sdk 0.0.16

package/dist/esm/arknote/index.js

@@ -0,0 +1,81 @@
+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
+export class ArkNote {
+    constructor(data, signature) {
+        this.data = data;
+        this.signature = signature;
+    }
+    encode() {
+        const detailsBytes = this.data.encode();
+        const result = new Uint8Array(detailsBytes.length + this.signature.length);
+        result.set(detailsBytes);
+        result.set(this.signature, detailsBytes.length);
+        return result;
+    }
+    static decode(data) {
+        if (data.length < 12) {
+            throw new Error(`invalid data length: expected at least 12 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);
+    }
+    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}`);
+        }
+        const decoded = base58.decode(encoded);
+        if (decoded.length === 0) {
+            throw new Error("failed to decode base58 string");
+        }
+        return ArkNote.decode(new Uint8Array(decoded));
+    }
+    toString() {
+        return ArkNote.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);
+}
+function writeUInt32BE(array, value, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 4);
+    view.setUint32(0, value, false);
+}
+function readUInt32BE(array, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 4);
+    return view.getUint32(0, false);
+}

package/dist/esm/forfeit.js

@@ -0,0 +1,35 @@
+import { SigHash, Transaction } from "@scure/btc-signer";
+export function buildForfeitTx({ connectorInput, vtxoInput, vtxoAmount, connectorAmount, feeAmount, vtxoPkScript, connectorPkScript, serverPkScript, txLocktime, }) {
+    const tx = new Transaction({
+        version: 2,
+        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);
+    // Add main output to server
+    tx.addOutput({
+        script: serverPkScript,
+        amount,
+    });
+    return tx;
+}

package/dist/esm/identity/inMemoryKey.js

@@ -0,0 +1,36 @@
+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/identity/index.js

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

package/dist/esm/index.js

@@ -0,0 +1,39 @@
+import { InMemoryKey } from './identity/inMemoryKey.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 { ServiceWorkerWallet } from './wallet/serviceWorker/wallet.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 { 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 { IndexedDBVtxoRepository } from './wallet/serviceWorker/db/vtxo/idb.js';
+import { networks } from './networks.js';
+export { 
+// Classes
+Wallet, ServiceWorkerWallet, InMemoryKey, 
+// Providers
+ESPLORA_URL, EsploraProvider, RestArkProvider, 
+// Script-related
+ArkAddress, DefaultVtxo, VtxoScript, VHTLC, 
+// Enums
+TxType, 
+// Service Worker
+Worker, Request, Response, 
+// Tapscript
+decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, 
+// Utils
+addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx, 
+// Arknote
+ArkNote, ArkNoteData, 
+// Network
+networks, 
+// Database
+IndexedDBVtxoRepository, };

package/dist/esm/musig2/index.js

@@ -0,0 +1,3 @@
+export { generateNonces } from './nonces.js';
+export { PartialSig, sign } from './sign.js';
+export { aggregateKeys } from './keys.js';

package/dist/esm/musig2/keys.js

@@ -0,0 +1,21 @@
+import * as musig from "@scure/btc-signer/musig2";
+import { schnorr } from "@noble/curves/secp256k1";
+// Aggregates multiple public keys according to the MuSig2 algorithm
+export function aggregateKeys(publicKeys, sort, options = {}) {
+    if (sort) {
+        publicKeys = musig.sortKeys(publicKeys);
+    }
+    const { aggPublicKey: preTweakedKey } = musig.keyAggregate(publicKeys);
+    if (!options.taprootTweak) {
+        return {
+            preTweakedKey: preTweakedKey.toRawBytes(true),
+            finalKey: preTweakedKey.toRawBytes(true),
+        };
+    }
+    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toRawBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
+    const { aggPublicKey: finalKey } = musig.keyAggregate(publicKeys, [tweakBytes], [true]);
+    return {
+        preTweakedKey: preTweakedKey.toRawBytes(true),
+        finalKey: finalKey.toRawBytes(true),
+    };
+}

package/dist/esm/musig2/nonces.js

@@ -0,0 +1,8 @@
+import * as musig from "@scure/btc-signer/musig2";
+/**
+ * Generates a pair of public and secret nonces for MuSig2 signing
+ */
+export function generateNonces(publicKey) {
+    const nonces = musig.nonceGen(publicKey);
+    return { secNonce: nonces.secret, pubNonce: nonces.public };
+}

package/dist/esm/musig2/sign.js

@@ -0,0 +1,63 @@
+import * as musig from "@scure/btc-signer/musig2";
+import { bytesToNumberBE } from "@noble/curves/abstract/utils";
+import { CURVE } from "@noble/secp256k1";
+import { aggregateKeys } from './keys.js';
+import { schnorr } from "@noble/curves/secp256k1";
+// Add this error type for decode failures
+export class PartialSignatureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PartialSignatureError";
+    }
+}
+// Implement a concrete class for PartialSignature
+export class PartialSig {
+    constructor(s, R) {
+        this.s = s;
+        this.R = R;
+        if (s.length !== 32) {
+            throw new PartialSignatureError("Invalid s length");
+        }
+        if (R.length !== 33) {
+            throw new PartialSignatureError("Invalid R length");
+        }
+    }
+    /**
+     * Encodes the partial signature into bytes
+     * Returns a 32-byte array containing just the s value
+     */
+    encode() {
+        // Return copy of s bytes
+        return new Uint8Array(this.s);
+    }
+    /**
+     * Decodes a partial signature from bytes
+     * @param bytes - 32-byte array containing s value
+     */
+    static decode(bytes) {
+        if (bytes.length !== 32) {
+            throw new PartialSignatureError("Invalid partial signature length");
+        }
+        // Verify s is less than curve order
+        const s = bytesToNumberBE(bytes);
+        if (s >= CURVE.n) {
+            throw new PartialSignatureError("s value overflows curve order");
+        }
+        // For decode we don't have R, so we'll need to compute it later
+        const R = new Uint8Array(33); // Zero R for now
+        return new PartialSig(bytes, R);
+    }
+}
+/**
+ * Generates a MuSig2 partial signature
+ */
+export function sign(secNonce, privateKey, combinedNonce, publicKeys, message, options) {
+    let tweakBytes;
+    if (options?.taprootTweak !== undefined) {
+        const { preTweakedKey } = aggregateKeys(options?.sortKeys ? musig.sortKeys(publicKeys) : publicKeys, true);
+        tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.subarray(1), options.taprootTweak);
+    }
+    const session = new musig.Session(combinedNonce, options?.sortKeys ? musig.sortKeys(publicKeys) : publicKeys, message, tweakBytes ? [tweakBytes] : undefined, tweakBytes ? [true] : undefined);
+    const partialSig = session.sign(secNonce, privateKey);
+    return PartialSig.decode(partialSig);
+}

package/dist/esm/networks.js

@@ -0,0 +1,22 @@
+import { NETWORK, TEST_NETWORK } from "@scure/btc-signer";
+export const getNetwork = (network) => {
+    return networks[network];
+};
+export const networks = {
+    bitcoin: withArkPrefix(NETWORK, "ark"),
+    testnet: withArkPrefix(TEST_NETWORK, "tark"),
+    signet: withArkPrefix(TEST_NETWORK, "tark"),
+    mutinynet: withArkPrefix(TEST_NETWORK, "tark"),
+    regtest: withArkPrefix({
+        ...TEST_NETWORK,
+        bech32: "bcrt",
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+    }, "tark"),
+};
+function withArkPrefix(network, prefix) {
+    return {
+        ...network,
+        hrp: prefix,
+    };
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}