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

package/dist/cjs/wallet/wallet.js

@@ -38,8 +38,8 @@ exports.waitForIncomingFunds = waitForIncomingFunds;
 const base_1 = require("@scure/base");
 const bip68 = __importStar(require("bip68"));
 const payment_js_1 = require("@scure/btc-signer/payment.js");
-const transaction_js_1 = require("@scure/btc-signer/transaction.js");
-const psbt_js_1 = require("@scure/btc-signer/psbt.js");
+const btc_signer_1 = require("@scure/btc-signer");
+const utils_js_1 = require("@scure/btc-signer/utils.js");
 const transactionHistory_1 = require("../utils/transactionHistory");
 const address_1 = require("../script/address");
 const default_1 = require("../script/default");
@@ -49,14 +49,15 @@ const ark_1 = require("../providers/ark");
 const forfeit_1 = require("../forfeit");
 const validation_1 = require("../tree/validation");
 const _1 = require(".");
-const utils_js_1 = require("@scure/btc-signer/utils.js");
 const base_2 = require("../script/base");
 const tapscript_1 = require("../script/tapscript");
 const arkTransaction_1 = require("../utils/arkTransaction");
+const vtxo_manager_1 = require("./vtxo-manager");
 const arknote_1 = require("../arknote");
-const bip322_1 = require("../bip322");
+const intent_1 = require("../intent");
 const indexer_1 = require("../providers/indexer");
 const txTree_1 = require("../tree/txTree");
+const unknownFields_1 = require("../utils/unknownFields");
 const inMemory_1 = require("../storage/inMemory");
 const walletRepository_1 = require("../repositories/walletRepository");
 const contractRepository_1 = require("../repositories/contractRepository");
@@ -95,7 +96,7 @@ const utils_1 = require("./utils");
  * ```
  */
 class Wallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount, walletRepository, contractRepository) {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig) {
         this.identity = identity;
         this.network = network;
         this.networkName = networkName;
@@ -107,9 +108,15 @@ class Wallet {
         this.boardingTapscript = boardingTapscript;
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
+        this.forfeitPubkey = forfeitPubkey;
         this.dustAmount = dustAmount;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
+        this.renewalConfig = {
+            enabled: renewalConfig?.enabled ?? false,
+            ...vtxo_manager_1.DEFAULT_RENEWAL_CONFIG,
+            ...renewalConfig,
+        };
     }
     static async create(config) {
         const pubkey = await config.identity.xOnlyPublicKey();
@@ -139,6 +146,7 @@ class Wallet {
         const esploraUrl = config.esploraUrl || onchain_1.ESPLORA_URL[info.network];
         // Use provided onchainProvider instance or create a new one
         const onchainProvider = config.onchainProvider || new onchain_1.EsploraProvider(esploraUrl);
+        // Generate timelocks
         const exitTimelock = {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
@@ -164,21 +172,22 @@ class Wallet {
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
         let serverUnrollScript;
         try {
-            const raw = base_1.hex.decode(info.checkpointExitClosure);
+            const raw = base_1.hex.decode(info.checkpointTapscript);
             serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(raw);
         }
         catch (e) {
-            throw new Error("Invalid checkpointExitClosure from server");
+            throw new Error("Invalid checkpointTapscript from server");
         }
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
-        const forfeitAddress = (0, payment_js_1.Address)(network).decode(info.forfeitAddress);
-        const forfeitOutputScript = payment_js_1.OutScript.encode(forfeitAddress);
+        const forfeitPubkey = base_1.hex.decode(info.forfeitPubkey).slice(1);
+        const forfeitAddress = (0, btc_signer_1.Address)(network).decode(info.forfeitAddress);
+        const forfeitOutputScript = btc_signer_1.OutScript.encode(forfeitAddress);
         // Set up storage and repositories
         const storage = config.storage || new inMemory_1.InMemoryStorageAdapter();
         const walletRepository = new walletRepository_1.WalletRepositoryImpl(storage);
         const contractRepository = new contractRepository_1.ContractRepositoryImpl(storage);
-        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust, walletRepository, contractRepository);
+        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, info.dust, walletRepository, contractRepository, config.renewalConfig);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
@@ -418,7 +427,7 @@ class Wallet {
         // TODO persist final virtual tx and checkpoints to repository
         // sign the checkpoints
         const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
-            const tx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(c));
+            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(c));
             const signedCheckpoint = await this.identity.sign(tx);
             return base_1.base64.encode(signedCheckpoint.toPSBT());
         }));
@@ -476,8 +485,8 @@ class Wallet {
             }
             catch {
                 // onchain
-                const addr = (0, payment_js_1.Address)(this.network).decode(output.address);
-                script = payment_js_1.OutScript.encode(addr);
+                const addr = (0, btc_signer_1.Address)(this.network).decode(output.address);
+                script = btc_signer_1.OutScript.encode(addr);
                 onchainOutputIndexes.push(index);
             }
             outputs.push({
@@ -490,7 +499,7 @@ class Wallet {
         const signingPublicKeys = [];
         if (hasOffchainOutputs) {
             session = this.identity.signerSession();
-            signingPublicKeys.push(base_1.hex.encode(session.getPublicKey()));
+            signingPublicKeys.push(base_1.hex.encode(await session.getPublicKey()));
         }
         const [intent, deleteIntent] = await Promise.all([
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
@@ -529,7 +538,7 @@ class Wallet {
                         if (step !== undefined) {
                             continue;
                         }
-                        const res = await this.handleBatchStartedEvent(event, intentId, this.arkServerPublicKey, this.forfeitOutputScript);
+                        const res = await this.handleBatchStartedEvent(event, intentId, this.forfeitPubkey, this.forfeitOutputScript);
                         if (!res.skip) {
                             step = event.type;
                             sweepTapTreeRoot = res.sweepTapTreeRoot;
@@ -714,10 +723,10 @@ class Wallet {
         };
         return stopFunc;
     }
-    async handleBatchStartedEvent(event, intentId, serverPubKey, forfeitOutputScript) {
+    async handleBatchStartedEvent(event, intentId, forfeitPubKey, forfeitOutputScript) {
         const utf8IntentId = new TextEncoder().encode(intentId);
         const intentIdHash = (0, utils_js_1.sha256)(utf8IntentId);
-        const intentIdHashStr = base_1.hex.encode(new Uint8Array(intentIdHash));
+        const intentIdHashStr = base_1.hex.encode(intentIdHash);
         let skip = true;
         // check if our intent ID hash matches any in the event
         for (const idHash of event.intentIdHashes) {
@@ -737,7 +746,7 @@ class Wallet {
                 value: event.batchExpiry,
                 type: event.batchExpiry >= 512n ? "seconds" : "blocks",
             },
-            pubkeys: [serverPubKey],
+            pubkeys: [forfeitPubKey],
         }).script;
         const sweepTapTreeRoot = (0, payment_js_1.tapLeafHash)(sweepTapscript);
         return {
@@ -750,7 +759,7 @@ class Wallet {
     // validates the vtxo tree, creates a signing session and generates the musig2 nonces
     async handleSettlementSigningEvent(event, sweepTapTreeRoot, session, vtxoGraph) {
         // validate the unsigned vtxo tree
-        const commitmentTx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
+        const commitmentTx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
         (0, validation_1.validateVtxoTxGraph)(vtxoGraph, commitmentTx, sweepTapTreeRoot);
         // TODO check if our registered outputs are in the vtxo tree
         const sharedOutput = commitmentTx.getOutput(0);
@@ -758,18 +767,21 @@ class Wallet {
             throw new Error("Shared output not found");
         }
         session.init(vtxoGraph, sweepTapTreeRoot, sharedOutput.amount);
-        await this.arkProvider.submitTreeNonces(event.id, base_1.hex.encode(session.getPublicKey()), session.getNonces());
+        const pubkey = base_1.hex.encode(await session.getPublicKey());
+        const nonces = await session.getNonces();
+        await this.arkProvider.submitTreeNonces(event.id, pubkey, nonces);
     }
     async handleSettlementSigningNoncesGeneratedEvent(event, session) {
         session.setAggregatedNonces(event.treeNonces);
-        const signatures = session.sign();
-        await this.arkProvider.submitTreeSignatures(event.id, base_1.hex.encode(session.getPublicKey()), signatures);
+        const signatures = await session.sign();
+        const pubkey = base_1.hex.encode(await session.getPublicKey());
+        await this.arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
     }
     async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
         // the signed forfeits transactions to submit
         const signedForfeits = [];
         const vtxos = await this.getVirtualCoins();
-        let settlementPsbt = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
+        let settlementPsbt = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
         let hasBoardingUtxos = false;
         let connectorIndex = 0;
         const connectorsLeaves = connectorsGraph?.leaves() || [];
@@ -811,7 +823,7 @@ class Wallet {
                 throw new Error("not enough connectors received");
             }
             const connectorLeaf = connectorsLeaves[connectorIndex];
-            const connectorTxId = base_1.hex.encode((0, utils_js_1.sha256x2)(connectorLeaf.toBytes(true)).reverse());
+            const connectorTxId = connectorLeaf.id;
             const connectorOutput = connectorLeaf.getOutput(0);
             if (!connectorOutput) {
                 throw new Error("connector output not found");
@@ -830,7 +842,7 @@ class Wallet {
                         amount: BigInt(vtxo.value),
                         script: base_2.VtxoScript.decode(input.tapTree).pkScript,
                     },
-                    sighashType: transaction_js_1.SigHash.DEFAULT,
+                    sighashType: btc_signer_1.SigHash.DEFAULT,
                     tapLeafScript: [input.forfeitTapLeafScript],
                 },
                 {
@@ -852,112 +864,69 @@ class Wallet {
                 : undefined);
         }
     }
-    async makeRegisterIntentSignature(bip322Inputs, outputs, onchainOutputsIndexes, cosignerPubKeys) {
+    async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
         const nowSeconds = Math.floor(Date.now() / 1000);
-        const { inputs, inputTapTrees, finalizer } = this.prepareBIP322Inputs(bip322Inputs);
+        const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "register",
-            input_tap_trees: inputTapTrees,
             onchain_output_indexes: onchainOutputsIndexes,
             valid_at: nowSeconds,
             expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
             cosigners_public_keys: cosignerPubKeys,
         };
         const encodedMessage = JSON.stringify(message, null, 0);
-        const signature = await this.makeBIP322Signature(encodedMessage, inputs, finalizer, outputs);
+        const proof = intent_1.Intent.create(encodedMessage, inputs, outputs);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base_1.base64.encode(signedProof.toPSBT()),
             message: encodedMessage,
         };
     }
-    async makeDeleteIntentSignature(bip322Inputs) {
+    async makeDeleteIntentSignature(coins) {
         const nowSeconds = Math.floor(Date.now() / 1000);
-        const { inputs, finalizer } = this.prepareBIP322Inputs(bip322Inputs);
+        const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "delete",
             expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
         };
         const encodedMessage = JSON.stringify(message, null, 0);
-        const signature = await this.makeBIP322Signature(encodedMessage, inputs, finalizer);
+        const proof = intent_1.Intent.create(encodedMessage, inputs, []);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base_1.base64.encode(signedProof.toPSBT()),
             message: encodedMessage,
         };
     }
-    prepareBIP322Inputs(bip322Inputs) {
+    prepareIntentProofInputs(coins) {
         const inputs = [];
-        const inputTapTrees = [];
-        const inputExtraWitnesses = [];
-        for (const bip322Input of bip322Inputs) {
-            const vtxoScript = base_2.VtxoScript.decode(bip322Input.tapTree);
-            const sequence = getSequence(bip322Input);
+        for (const input of coins) {
+            const vtxoScript = base_2.VtxoScript.decode(input.tapTree);
+            const sequence = getSequence(input);
+            const unknown = [unknownFields_1.VtxoTaprootTree.encode(input.tapTree)];
+            if (input.extraWitness) {
+                unknown.push(unknownFields_1.ConditionWitness.encode(input.extraWitness));
+            }
             inputs.push({
-                txid: base_1.hex.decode(bip322Input.txid),
-                index: bip322Input.vout,
+                txid: base_1.hex.decode(input.txid),
+                index: input.vout,
                 witnessUtxo: {
-                    amount: BigInt(bip322Input.value),
+                    amount: BigInt(input.value),
                     script: vtxoScript.pkScript,
                 },
                 sequence,
-                tapLeafScript: [bip322Input.intentTapLeafScript],
+                tapLeafScript: [input.intentTapLeafScript],
+                unknown,
             });
-            inputTapTrees.push(base_1.hex.encode(bip322Input.tapTree));
-            inputExtraWitnesses.push(bip322Input.extraWitness || []);
         }
-        return {
-            inputs,
-            inputTapTrees,
-            finalizer: finalizeWithExtraWitnesses(inputExtraWitnesses),
-        };
-    }
-    async makeBIP322Signature(message, inputs, finalizer, outputs) {
-        const proof = bip322_1.BIP322.create(message, inputs, outputs);
-        const signedProof = await this.identity.sign(proof);
-        return bip322_1.BIP322.signature(signedProof, finalizer);
+        return inputs;
     }
 }
 exports.Wallet = Wallet;
 Wallet.MIN_FEE_RATE = 1; // sats/vbyte
-function finalizeWithExtraWitnesses(inputExtraWitnesses) {
-    return function (tx) {
-        for (let i = 0; i < tx.inputsLength; i++) {
-            try {
-                tx.finalizeIdx(i);
-            }
-            catch (e) {
-                // handle empty witness error
-                if (e instanceof Error &&
-                    e.message.includes("finalize/taproot: empty witness")) {
-                    const tapLeaves = tx.getInput(i).tapLeafScript;
-                    if (!tapLeaves || tapLeaves.length <= 0)
-                        throw e;
-                    const [cb, s] = tapLeaves[0];
-                    const script = s.slice(0, -1);
-                    tx.updateInput(i, {
-                        finalScriptWitness: [
-                            script,
-                            psbt_js_1.TaprootControlBlock.encode(cb),
-                        ],
-                    });
-                }
-            }
-            const finalScriptWitness = tx.getInput(i).finalScriptWitness;
-            if (!finalScriptWitness)
-                throw new Error("input not finalized");
-            // input 0 and 1 spend the same pkscript
-            const extra = inputExtraWitnesses[i === 0 ? 0 : i - 1];
-            if (extra && extra.length > 0) {
-                tx.updateInput(i, {
-                    finalScriptWitness: [...extra, ...finalScriptWitness],
-                });
-            }
-        }
-    };
-}
-function getSequence(bip322Input) {
+function getSequence(coin) {
     let sequence = undefined;
     try {
-        const scriptWithLeafVersion = bip322Input.intentTapLeafScript[1];
+        const scriptWithLeafVersion = coin.intentTapLeafScript[1];
         const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
         const params = tapscript_1.CSVMultisigTapscript.decode(script).params;
         sequence = bip68.encode(params.timelock.type === "blocks"

package/dist/esm/arknote/index.js

@@ -1,7 +1,7 @@
 import { base58, hex } from "@scure/base";
-import { VtxoScript } from '../script/base.js';
 import { sha256 } from "@scure/btc-signer/utils.js";
-import { Script } from "@scure/btc-signer/script.js";
+import { Script } from "@scure/btc-signer";
+import { VtxoScript } from '../script/base.js';
 /**
  * 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

package/dist/esm/forfeit.js

@@ -1,9 +1,12 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
+import { Transaction } from "@scure/btc-signer";
 import { P2A } from './utils/anchor.js';
 export function buildForfeitTx(inputs, forfeitPkScript, txLocktime) {
     const tx = new Transaction({
         version: 3,
         lockTime: txLocktime,
+        allowUnknownOutputs: true,
+        allowUnknown: true,
+        allowUnknownInputs: true,
     });
     let amount = 0n;
     for (const input of inputs) {

package/dist/esm/identity/singleKey.js

@@ -1,8 +1,8 @@
-import { pubECDSA, pubSchnorr, randomPrivateKeyBytes, sha256, } from "@scure/btc-signer/utils.js";
-import { hex } from "@scure/base";
+import { pubECDSA, pubSchnorr, randomPrivateKeyBytes, } from "@scure/btc-signer/utils.js";
 import { SigHash } from "@scure/btc-signer/transaction.js";
+import { hex } from "@scure/base";
 import { TreeSignerSession } from '../tree/signingSession.js';
-import { schnorr } from "@noble/secp256k1";
+import { schnorr, sign } from "@noble/secp256k1";
 const ZERO_32 = new Uint8Array(32).fill(0);
 const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
 /**
@@ -79,8 +79,9 @@ export class SingleKey {
     signerSession() {
         return TreeSignerSession.random();
     }
-    async signMessage(message) {
-        const msgBytes = new TextEncoder().encode(message);
-        return schnorr.sign(sha256(msgBytes), this.key);
+    async signMessage(message, signatureType = "schnorr") {
+        if (signatureType === "ecdsa")
+            return sign(message, this.key, { prehash: false });
+        return schnorr.sign(message, this.key);
     }
 }

package/dist/esm/index.js

@@ -8,6 +8,7 @@ import { TxType, } from './wallet/index.js';
 import { Wallet, waitForIncomingFunds } from './wallet/wallet.js';
 import { TxTree } from './tree/txTree.js';
 import { Ramps } from './wallet/ramps.js';
+import { VtxoManager } from './wallet/vtxo-manager.js';
 import { ServiceWorkerWallet } from './wallet/serviceWorker/wallet.js';
 import { OnchainWallet } from './wallet/onchain.js';
 import { setupServiceWorker } from './wallet/serviceWorker/utils.js';
@@ -17,9 +18,9 @@ import { Response } from './wallet/serviceWorker/response.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 { hasBoardingTxExpired, buildOffchainTx, } from './utils/arkTransaction.js';
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
-import { BIP322 } from './bip322/index.js';
+import { Intent } from './intent/index.js';
 import { ArkNote } from './arknote/index.js';
 import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
@@ -29,7 +30,7 @@ import { WalletRepositoryImpl } from './repositories/walletRepository.js';
 import { ContractRepositoryImpl } from './repositories/contractRepository.js';
 export { 
 // Wallets
-Wallet, SingleKey, OnchainWallet, Ramps, 
+Wallet, SingleKey, OnchainWallet, Ramps, VtxoManager, 
 // Providers
 ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, 
 // Script-related
@@ -43,15 +44,15 @@ decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTa
 // Ark PSBT fields
 ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
 // Utils
-buildOffchainTx, waitForIncomingFunds, hasBoardingTxExpired, 
+buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, 
 // Arknote
 ArkNote, 
 // Network
 networks, 
 // Repositories
 WalletRepositoryImpl, ContractRepositoryImpl, 
-// BIP322
-BIP322, 
+// Intent proof
+Intent, 
 // TxTree
 TxTree, 
 // Anchor

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

@@ -1,22 +1,19 @@
-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, Transaction, Script, SigHash } from "@scure/btc-signer";
 import { schnorr } from "@noble/curves/secp256k1.js";
-import { base64 } from "@scure/base";
 /**
- * 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 +22,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 +70,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,7 +80,7 @@ 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,
@@ -148,11 +126,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 +155,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));
 }