@arkade-os/sdk 0.3.0-alpha.8 → 0.3.0

package/dist/esm/{bip322 → intent}/index.js

@@ -1,22 +1,20 @@
-import { OP } from "@scure/btc-signer/script.js";
-import { Transaction, SigHash } from "@scure/btc-signer/transaction.js";
-import { Script } from "@scure/btc-signer/script.js";
-import { ErrMissingData, ErrMissingInputs, ErrMissingWitnessUtxo, } from './errors.js';
+import { OP, Script, SigHash } from "@scure/btc-signer";
 import { schnorr } from "@noble/curves/secp256k1.js";
-import { base64 } from "@scure/base";
+import { Transaction } from '../utils/transaction.js';
 /**
- * BIP-322 signature implementation for Bitcoin message signing.
+ * Intent proof implementation for Bitcoin message signing.
  *
- * BIP-322 defines a standard for signing Bitcoin messages as well as proving
+ * Intent proof defines a standard for signing Bitcoin messages as well as proving
  * ownership of coins. This namespace provides utilities for creating and
- * validating BIP-322.
+ * validating Intent proof.
  *
+ * it is greatly inspired by BIP322.
  * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
  *
  * @example
  * ```typescript
- * // Create a BIP-322 proof
- * const proof = BIP322.create(
+ * // Create a Intent proof
+ * const proof = Intent.create(
  *   "Hello Bitcoin!",
  *   [input],
  *   [output]
@@ -25,65 +23,46 @@ import { base64 } from "@scure/base";
  * // Sign the proof
  * const signedProof = await identity.sign(proof);
  *
- * // Extract the signature
- * const signature = BIP322.signature(signedProof);
- * ```
  */
-export var BIP322;
-(function (BIP322) {
+export var Intent;
+(function (Intent) {
     /**
-     * Creates a new BIP-322 "full" proof of funds unsigned transaction.
+     * Creates a new Intent proof 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 message - The Intent 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
+     * @returns An unsigned Intent proof transaction
      */
     function create(message, inputs, outputs = []) {
         if (inputs.length == 0)
-            throw ErrMissingInputs;
+            throw new Error("intent proof requires at least one input");
         if (!validateInputs(inputs))
-            throw ErrMissingData;
+            throw new Error("invalid inputs");
         if (!validateOutputs(outputs))
-            throw ErrMissingData;
+            throw new Error("invalid outputs");
         // 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 = {}));
+    Intent.create = create;
+})(Intent || (Intent = {}));
 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";
+const TAG_INTENT_PROOF = "ark-intent-proof-message";
 function validateInput(input) {
     if (input.index === undefined)
-        throw ErrMissingData;
+        throw new Error("intent proof input requires index");
     if (input.txid === undefined)
-        throw ErrMissingData;
+        throw new Error("intent proof input requires txid");
     if (input.witnessUtxo === undefined)
-        throw ErrMissingWitnessUtxo;
+        throw new Error("intent proof input requires witness utxo");
     return true;
 }
 function validateInputs(inputs) {
@@ -92,9 +71,9 @@ function validateInputs(inputs) {
 }
 function validateOutput(output) {
     if (output.amount === undefined)
-        throw ErrMissingData;
+        throw new Error("intent proof output requires amount");
     if (output.script === undefined)
-        throw ErrMissingData;
+        throw new Error("intent proof output requires script");
     return true;
 }
 function validateOutputs(outputs) {
@@ -102,13 +81,10 @@ function validateOutputs(outputs) {
     return true;
 }
 // craftToSpendTx creates the initial transaction that will be spent in the proof
-export function craftToSpendTx(message, pkScript) {
+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({
@@ -131,9 +107,6 @@ 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
@@ -148,11 +121,16 @@ function craftToSignTx(toSpend, inputs, outputs) {
         sighashType: SigHash.ALL,
     });
     // add other inputs
-    for (const input of inputs) {
+    for (const [i, input] of inputs.entries()) {
         tx.addInput({
             ...input,
             sighashType: SigHash.ALL,
         });
+        if (input.unknown?.length) {
+            tx.updateInput(i + 1, {
+                unknown: input.unknown,
+            });
+        }
     }
     // add the special OP_RETURN output if no outputs are provided
     if (outputs.length === 0) {
@@ -172,5 +150,5 @@ function craftToSignTx(toSpend, inputs, outputs) {
     return tx;
 }
 function hashMessage(message) {
-    return schnorr.utils.taggedHash(TAG_BIP322, new TextEncoder().encode(message));
+    return schnorr.utils.taggedHash(TAG_INTENT_PROOF, new TextEncoder().encode(message));
 }

package/dist/esm/musig2/index.js

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

package/dist/esm/musig2/nonces.js

@@ -6,3 +6,6 @@ export function generateNonces(publicKey) {
     const nonces = musig.nonceGen(publicKey);
     return { secNonce: nonces.secret, pubNonce: nonces.public };
 }
+export function aggregateNonces(pubNonces) {
+    return musig.nonceAggregate(pubNonces);
+}

package/dist/esm/providers/ark.js

@@ -1,5 +1,6 @@
 import { hex } from "@scure/base";
 import { eventSourceIterator } from './utils.js';
+import { maybeArkError } from './errors.js';
 export var SettlementEventType;
 (function (SettlementEventType) {
     SettlementEventType["BatchStarted"] = "batch_started";
@@ -7,7 +8,7 @@ export var SettlementEventType;
     SettlementEventType["BatchFinalized"] = "batch_finalized";
     SettlementEventType["BatchFailed"] = "batch_failed";
     SettlementEventType["TreeSigningStarted"] = "tree_signing_started";
-    SettlementEventType["TreeNoncesAggregated"] = "tree_nonces_aggregated";
+    SettlementEventType["TreeNonces"] = "tree_nonces";
     SettlementEventType["TreeTx"] = "tree_tx";
     SettlementEventType["TreeSignature"] = "tree_signature";
 })(SettlementEventType || (SettlementEventType = {}));
@@ -28,29 +29,41 @@ export class RestArkProvider {
         const url = `${this.serverUrl}/v1/info`;
         const response = await fetch(url);
         if (!response.ok) {
-            throw new Error(`Failed to get server info: ${response.statusText}`);
+            const errorText = await response.text();
+            handleError(errorText, `Failed to get server info: ${response.statusText}`);
         }
         const fromServer = await response.json();
         return {
-            ...fromServer,
-            vtxoTreeExpiry: BigInt(fromServer.vtxoTreeExpiry ?? 0),
-            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
-            roundInterval: BigInt(fromServer.roundInterval ?? 0),
-            dust: BigInt(fromServer.dust ?? 0),
-            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
-            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
-            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
-            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
             boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
-            checkpointExitClosure: fromServer.checkpointTapscript ?? "",
-            marketHour: "marketHour" in fromServer && fromServer.marketHour != null
+            checkpointTapscript: fromServer.checkpointTapscript ?? "",
+            deprecatedSigners: fromServer.deprecatedSigners?.map((signer) => ({
+                cutoffDate: BigInt(signer.cutoffDate ?? 0),
+                pubkey: signer.pubkey ?? "",
+            })) ?? [],
+            digest: fromServer.digest ?? "",
+            dust: BigInt(fromServer.dust ?? 0),
+            fees: fromServer.fees,
+            forfeitAddress: fromServer.forfeitAddress ?? "",
+            forfeitPubkey: fromServer.forfeitPubkey ?? "",
+            network: fromServer.network ?? "",
+            scheduledSession: "scheduledSession" in fromServer &&
+                fromServer.scheduledSession != null
                 ? {
-                    nextStartTime: BigInt(fromServer.marketHour.nextStartTime ?? 0),
-                    nextEndTime: BigInt(fromServer.marketHour.nextEndTime ?? 0),
-                    period: BigInt(fromServer.marketHour.period ?? 0),
-                    roundInterval: BigInt(fromServer.marketHour.roundInterval ?? 0),
+                    duration: BigInt(fromServer.scheduledSession.duration ?? 0),
+                    nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
+                    nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
+                    period: BigInt(fromServer.scheduledSession.period ?? 0),
                 }
                 : undefined,
+            serviceStatus: fromServer.serviceStatus ?? {},
+            sessionDuration: BigInt(fromServer.sessionDuration ?? 0),
+            signerPubkey: fromServer.signerPubkey ?? "",
+            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
+            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
+            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
+            version: fromServer.version ?? "",
+            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
+            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
         };
     }
     async submitTx(signedArkTx, checkpointTxs) {
@@ -61,22 +74,13 @@ export class RestArkProvider {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                signedArkTx: signedArkTx,
-                checkpointTxs: checkpointTxs,
+                signedArkTx,
+                checkpointTxs,
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            try {
-                const grpcError = JSON.parse(errorText);
-                // gRPC errors usually have a message and code field
-                throw new Error(`Failed to submit virtual transaction: ${grpcError.message || grpcError.error || errorText}`);
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            }
-            catch (_) {
-                // If JSON parse fails, use the raw error text
-                throw new Error(`Failed to submit virtual transaction: ${errorText}`);
-            }
+            handleError(errorText, `Failed to submit virtual transaction: ${errorText}`);
         }
         const data = await response.json();
         return {
@@ -99,7 +103,7 @@ export class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to finalize offchain transaction: ${errorText}`);
+            handleError(errorText, `Failed to finalize offchain transaction: ${errorText}`);
         }
     }
     async registerIntent(intent) {
@@ -111,14 +115,14 @@ export class RestArkProvider {
             },
             body: JSON.stringify({
                 intent: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to register intent: ${errorText}`);
+            handleError(errorText, `Failed to register intent: ${errorText}`);
         }
         const data = await response.json();
         return data.intentId;
@@ -132,14 +136,14 @@ export class RestArkProvider {
             },
             body: JSON.stringify({
                 proof: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to delete intent: ${errorText}`);
+            handleError(errorText, `Failed to delete intent: ${errorText}`);
         }
     }
     async confirmRegistration(intentId) {
@@ -155,7 +159,7 @@ export class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to confirm registration: ${errorText}`);
+            handleError(errorText, `Failed to confirm registration: ${errorText}`);
         }
     }
     async submitTreeNonces(batchId, pubkey, nonces) {
@@ -173,7 +177,7 @@ export class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to submit tree nonces: ${errorText}`);
+            handleError(errorText, `Failed to submit tree nonces: ${errorText}`);
         }
     }
     async submitTreeSignatures(batchId, pubkey, signatures) {
@@ -191,7 +195,7 @@ export class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to submit tree signatures: ${errorText}`);
+            handleError(errorText, `Failed to submit tree signatures: ${errorText}`);
         }
     }
     async submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
@@ -207,7 +211,8 @@ export class RestArkProvider {
             }),
         });
         if (!response.ok) {
-            throw new Error(`Failed to submit forfeit transactions: ${response.statusText}`);
+            const errorText = await response.text();
+            handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
         }
     }
     async *getEventStream(signal, topics) {
@@ -305,6 +310,22 @@ export class RestArkProvider {
             }
         }
     }
+    async getPendingTxs(intent) {
+        const url = `${this.serverUrl}/v1/tx/pending`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ intent }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            handleError(errorText, `Failed to get pending transactions: ${errorText}`);
+        }
+        const data = await response.json();
+        return data.pendingTxs;
+    }
     parseSettlementEvent(data) {
         // Check for BatchStarted event
         if (data.batchStarted) {
@@ -350,10 +371,16 @@ export class RestArkProvider {
         }
         // Check for TreeNoncesAggregated event
         if (data.treeNoncesAggregated) {
+            // skip treeNoncesAggregated event, deprecated
+            return null;
+        }
+        if (data.treeNonces) {
             return {
-                type: SettlementEventType.TreeNoncesAggregated,
-                id: data.treeNoncesAggregated.id,
-                treeNonces: decodeMusig2Nonces(data.treeNoncesAggregated.treeNonces),
+                type: SettlementEventType.TreeNonces,
+                id: data.treeNonces.id,
+                topic: data.treeNonces.topic,
+                txid: data.treeNonces.txid,
+                nonces: decodeMusig2Nonces(data.treeNonces.nonces), // pubkey -> public nonce
             };
         }
         // Check for TreeTx event
@@ -426,17 +453,16 @@ function encodeMusig2Nonces(nonces) {
     for (const [txid, nonce] of nonces) {
         noncesObject[txid] = hex.encode(nonce.pubNonce);
     }
-    return JSON.stringify(noncesObject);
+    return noncesObject;
 }
 function encodeMusig2Signatures(signatures) {
     const sigObject = {};
     for (const [txid, sig] of signatures) {
         sigObject[txid] = hex.encode(sig.encode());
     }
-    return JSON.stringify(sigObject);
+    return sigObject;
 }
-function decodeMusig2Nonces(str) {
-    const noncesObject = JSON.parse(str);
+function decodeMusig2Nonces(noncesObject) {
     return new Map(Object.entries(noncesObject).map(([txid, nonce]) => {
         if (typeof nonce !== "string") {
             throw new Error("invalid nonce");
@@ -478,3 +504,8 @@ function mapVtxo(vtxo) {
         arkTxid: vtxo.arkTxid,
     };
 }
+function handleError(errorText, defaultMessage) {
+    const error = new Error(errorText);
+    const arkError = maybeArkError(error);
+    throw arkError ?? new Error(defaultMessage);
+}

package/dist/esm/providers/errors.js

@@ -0,0 +1,54 @@
+export class ArkError extends Error {
+    constructor(code, message, name, metadata) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.name = name;
+        this.metadata = metadata;
+    }
+}
+/**
+ * Try to convert an error to an ArkError class, returning undefined if the error is not an ArkError
+ * @param error - The error to parse
+ * @returns The parsed ArkError, or undefined if the error is not an ArkError
+ */
+export function maybeArkError(error) {
+    try {
+        if (!(error instanceof Error))
+            return undefined;
+        const decoded = JSON.parse(error.message);
+        if (!("details" in decoded))
+            return undefined;
+        if (!Array.isArray(decoded.details))
+            return undefined;
+        // search for a valid details object with the correct type
+        for (const details of decoded.details) {
+            if (!("@type" in details))
+                continue;
+            const type = details["@type"];
+            if (type !== "type.googleapis.com/ark.v1.ErrorDetails")
+                continue;
+            if (!("code" in details))
+                continue;
+            const code = details.code;
+            if (!("message" in details))
+                continue;
+            const message = details.message;
+            if (!("name" in details))
+                continue;
+            const name = details.name;
+            let metadata;
+            if ("metadata" in details && isMetadata(details.metadata)) {
+                metadata = details.metadata;
+            }
+            return new ArkError(code, message, name, metadata);
+        }
+        return undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function isMetadata(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}