@arkade-os/sdk 0.0.16

package/dist/cjs/providers/onchain.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsploraProvider = exports.ESPLORA_URL = void 0;
+exports.ESPLORA_URL = {
+    bitcoin: "https://mempool.space/api",
+    testnet: "https://mempool.space/testnet/api",
+    signet: "https://mempool.space/signet/api",
+    mutinynet: "https://mutinynet.com/api",
+    regtest: "http://localhost:3000",
+};
+class EsploraProvider {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async getCoins(address) {
+        const response = await fetch(`${this.baseUrl}/address/${address}/utxo`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch UTXOs: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async getFeeRate() {
+        const response = await fetch(`${this.baseUrl}/v1/fees/recommended`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch fee rate: ${response.statusText}`);
+        }
+        const fees = await response.json();
+        return fees.halfHourFee; // Return the "medium" priority fee rate
+    }
+    async broadcastTransaction(txHex) {
+        const response = await fetch(`${this.baseUrl}/tx`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "text/plain",
+            },
+            body: txHex,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to broadcast transaction: ${error}`);
+        }
+        return response.text(); // Returns the txid
+    }
+    async getTxOutspends(txid) {
+        const response = await fetch(`${this.baseUrl}/tx/${txid}/outspends`);
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to get transaction outspends: ${error}`);
+        }
+        return response.json();
+    }
+    async getTransactions(address) {
+        const response = await fetch(`${this.baseUrl}/address/${address}/txs`);
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to get transactions: ${error}`);
+        }
+        return response.json();
+    }
+}
+exports.EsploraProvider = EsploraProvider;

package/dist/cjs/script/address.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkAddress = void 0;
+const base_1 = require("@scure/base");
+const btc_signer_1 = require("@scure/btc-signer");
+// ArkAddress is a bech32m encoded address with a custom HRP (ark/tark)
+class ArkAddress {
+    constructor(serverPubKey, tweakedPubKey, hrp) {
+        this.serverPubKey = serverPubKey;
+        this.tweakedPubKey = tweakedPubKey;
+        this.hrp = hrp;
+        if (serverPubKey.length !== 32) {
+            throw new Error("Invalid server public key length");
+        }
+        if (tweakedPubKey.length !== 32) {
+            throw new Error("Invalid tweaked public key length");
+        }
+    }
+    static decode(address) {
+        const decoded = base_1.bech32m.decodeUnsafe(address, 1023);
+        if (!decoded) {
+            throw new Error("Invalid address");
+        }
+        const data = new Uint8Array(base_1.bech32m.fromWords(decoded.words));
+        // First 32 bytes are server pubkey, next 32 bytes are tweaked pubkey
+        if (data.length !== 64) {
+            throw new Error("Invalid data length");
+        }
+        const serverPubKey = data.slice(0, 32);
+        const tweakedPubKey = data.slice(32, 64);
+        return new ArkAddress(serverPubKey, tweakedPubKey, decoded.prefix);
+    }
+    encode() {
+        // Combine server pubkey and tweaked pubkey
+        const data = new Uint8Array(64);
+        data.set(this.serverPubKey, 0);
+        data.set(this.tweakedPubKey, 32);
+        const words = base_1.bech32m.toWords(data);
+        return base_1.bech32m.encode(this.hrp, words, 1023);
+    }
+    get pkScript() {
+        return btc_signer_1.Script.encode(["OP_1", this.tweakedPubKey]);
+    }
+}
+exports.ArkAddress = ArkAddress;

package/dist/cjs/script/base.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VtxoScript = void 0;
+exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
+const payment_1 = require("@scure/btc-signer/payment");
+const utils_1 = require("@scure/btc-signer/utils");
+const address_1 = require("./address");
+const btc_signer_1 = require("@scure/btc-signer");
+const base_1 = require("@scure/base");
+function scriptFromTapLeafScript(leaf) {
+    return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
+}
+class VtxoScript {
+    static decode(scripts) {
+        return new VtxoScript(scripts.map(base_1.hex.decode));
+    }
+    constructor(scripts) {
+        this.scripts = scripts;
+        const tapTree = (0, payment_1.taprootListToTree)(scripts.map((script) => ({ script, leafVersion: payment_1.TAP_LEAF_VERSION })));
+        const payment = (0, payment_1.p2tr)(utils_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
+        if (!payment.tapLeafScript ||
+            payment.tapLeafScript.length !== scripts.length) {
+            throw new Error("invalid scripts");
+        }
+        this.leaves = payment.tapLeafScript;
+        this.tweakedPublicKey = payment.tweakedPubkey;
+    }
+    encode() {
+        return this.scripts.map(base_1.hex.encode);
+    }
+    address(prefix, serverPubKey) {
+        return new address_1.ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
+    }
+    get pkScript() {
+        return btc_signer_1.Script.encode(["OP_1", this.tweakedPublicKey]);
+    }
+    onchainAddress(network) {
+        return (0, payment_1.Address)(network).encode({
+            type: "tr",
+            pubkey: this.tweakedPublicKey,
+        });
+    }
+    findLeaf(scriptHex) {
+        const leaf = this.leaves.find((leaf) => base_1.hex.encode(scriptFromTapLeafScript(leaf)) === scriptHex);
+        if (!leaf) {
+            throw new Error(`leaf '${scriptHex}' not found`);
+        }
+        return leaf;
+    }
+}
+exports.VtxoScript = VtxoScript;

package/dist/cjs/script/default.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultVtxo = void 0;
+const base_1 = require("./base");
+const tapscript_1 = require("./tapscript");
+const base_2 = require("@scure/base");
+// DefaultVtxo is the default implementation of a VtxoScript.
+// it contains 1 forfeit path and 1 exit path.
+// forfeit = (Alice + Server)
+// exit = (Alice) after csvTimelock
+var DefaultVtxo;
+(function (DefaultVtxo) {
+    class Script extends base_1.VtxoScript {
+        constructor(options) {
+            const { pubKey, serverPubKey, csvTimelock = Script.DEFAULT_TIMELOCK, } = options;
+            const forfeitScript = tapscript_1.MultisigTapscript.encode({
+                pubkeys: [pubKey, serverPubKey],
+            }).script;
+            const exitScript = tapscript_1.CSVMultisigTapscript.encode({
+                timelock: csvTimelock,
+                pubkeys: [pubKey],
+            }).script;
+            super([forfeitScript, exitScript]);
+            this.options = options;
+            this.forfeitScript = base_2.hex.encode(forfeitScript);
+            this.exitScript = base_2.hex.encode(exitScript);
+        }
+        forfeit() {
+            return this.findLeaf(this.forfeitScript);
+        }
+        exit() {
+            return this.findLeaf(this.exitScript);
+        }
+    }
+    Script.DEFAULT_TIMELOCK = {
+        value: 144n,
+        type: "blocks",
+    }; // 1 day in blocks
+    DefaultVtxo.Script = Script;
+})(DefaultVtxo || (exports.DefaultVtxo = DefaultVtxo = {}));