@arkade-os/sdk 0.3.12 → 0.4.0-next.0

package/dist/esm/wallet/unroll.js

@@ -5,6 +5,7 @@ import { VtxoScript } from '../script/base.js';
 import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
 import { Wallet } from './wallet.js';
 import { Transaction } from '../utils/transaction.js';
+import { DUST_AMOUNT } from './utils.js';
 export var Unroll;
 (function (Unroll) {
     let StepType;
@@ -200,7 +201,7 @@ export var Unroll;
         for (const input of inputs) {
             tx.addInput(input);
         }
-        txWeightEstimator.addP2TROutput();
+        txWeightEstimator.addOutputAddress(outputAddress, wallet.network);
         let feeRate = await wallet.onchainProvider.getFeeRate();
         if (!feeRate || feeRate < Wallet.MIN_FEE_RATE) {
             feeRate = Wallet.MIN_FEE_RATE;
@@ -209,7 +210,11 @@ export var Unroll;
         if (feeAmount > totalAmount) {
             throw new Error("fee amount is greater than the total amount");
         }
-        tx.addOutputAddress(outputAddress, totalAmount - feeAmount);
+        const sendAmount = totalAmount - feeAmount;
+        if (sendAmount < BigInt(DUST_AMOUNT)) {
+            throw new Error("send amount is less than dust amount");
+        }
+        tx.addOutputAddress(outputAddress, sendAmount);
         const signedTx = await wallet.identity.sign(tx);
         signedTx.finalize();
         await wallet.onchainProvider.broadcastTransaction(signedTx.hex);

package/dist/esm/wallet/utils.js

@@ -1,3 +1,7 @@
+import { ArkAddress, } from '../index.js';
+import { contractHandlers } from '../contracts/handlers/index.js';
+import { hex } from "@scure/base";
+export const DUST_AMOUNT = 546; // sats
 export function extendVirtualCoin(wallet, vtxo) {
     return {
         ...vtxo,
@@ -14,3 +18,54 @@ export function extendCoin(wallet, utxo) {
         tapTree: wallet.boardingTapscript.encode(),
     };
 }
+export function extendVtxoFromContract(vtxo, contract) {
+    const handler = contractHandlers.get(contract.type);
+    if (!handler) {
+        throw new Error(`No handler for contract type '${contract.type}'`);
+    }
+    const script = handler.createScript(contract.params);
+    return {
+        ...vtxo,
+        forfeitTapLeafScript: script.forfeit(),
+        intentTapLeafScript: script.forfeit(),
+        tapTree: script.encode(),
+    };
+}
+export function getRandomId() {
+    const randomValue = crypto.getRandomValues(new Uint8Array(16));
+    return hex.encode(randomValue);
+}
+export function isValidArkAddress(address) {
+    try {
+        ArkAddress.decode(address);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function validateRecipients(recipients, dustAmount) {
+    const validatedRecipients = [];
+    for (const recipient of recipients) {
+        let address;
+        try {
+            address = ArkAddress.decode(recipient.address);
+        }
+        catch (e) {
+            throw new Error(`Invalid Ark address: ${recipient.address}`);
+        }
+        const amount = recipient.amount || dustAmount;
+        if (amount <= 0) {
+            throw new Error("Amount must be positive");
+        }
+        validatedRecipients.push({
+            address: recipient.address,
+            assets: recipient.assets ?? [],
+            amount,
+            script: amount < dustAmount
+                ? address.subdustPkScript
+                : address.pkScript,
+        });
+    }
+    return validatedRecipients;
+}

package/dist/esm/wallet/validation.js

@@ -0,0 +1,139 @@
+import { equalBytes } from "@scure/btc-signer/utils.js";
+import { ArkAddress } from '../script/address.js';
+import { Packet } from '../asset/index.js';
+import { Address, OutScript } from "@scure/btc-signer";
+export const ErrOffchainOutputNotFound = (address) => new Error(`offchain send output not found: ${address}`);
+export const ErrInvalidAssetOutputAmount = (got, want, assetId) => new Error(`invalid asset output amount for ${assetId}: got ${got}, want ${want}`);
+export const ErrAssetGroupNotFound = (assetId) => new Error(`asset group not found in batch leaf: ${assetId}`);
+export const ErrAssetOutputNotFound = (assetId, outputIndex) => new Error(`asset output not found in asset group ${assetId} at index ${outputIndex}`);
+export const ErrInvalidOnchainOutputAmount = (address) => new Error(`invalid onchain output amount: ${address}`);
+export const ErrInvalidOnchainOutputAssets = (address) => new Error(`onchain output ${address} cannot have assets`);
+export const ErrOnchainOutputNotFound = (address) => new Error(`onchain output not found: ${address}`);
+export const ErrInvalidOffchainOutputAmount = (address) => new Error(`invalid offchain output ${address}, missing amount`);
+/**
+ * Validates both offchain and onchain recipients.
+ * Offchain recipients are checked against vtxo tree leaves for correct amounts and assets.
+ * Onchain recipients are validated against the round transaction outputs (amounts and scripts)
+ * via validateOnchainRecipient.
+ *
+ * @param commitmentTx - The commitment transaction to validate against
+ * @param vtxoTreeLeaves - The vtxo tree leaves to validate against
+ * @param recipients - The expected recipients to validate (both offchain and onchain)
+ * @param network - Network for decoding onchain addresses (e.g. mainnet, testnet)
+ * @throws {Error} if a recipient is not present or invalid in the vtxo tree or commitment tx
+ */
+export function validateBatchRecipients(commitmentTx, vtxoTreeLeaves, recipients, network) {
+    // usedOutputs is used to track which outputs are validated to handle
+    // duplicate recipients in the list
+    const usedOutputs = new Set();
+    const usedOnchainOutputs = new Set();
+    for (const recipient of recipients) {
+        let arkAddress;
+        try {
+            arkAddress = ArkAddress.decode(recipient.address);
+        }
+        catch {
+            validateOnchainRecipient(commitmentTx, recipient, network, usedOnchainOutputs);
+            continue;
+        }
+        validateOffchainRecipient(vtxoTreeLeaves, arkAddress, recipient, usedOutputs);
+    }
+}
+// validateOnchainRecipient verifies the given recipient is present in the commitment tx outputs list
+function validateOnchainRecipient(commitmentTx, recipient, network, usedOutputs) {
+    const addr = Address(network).decode(recipient.address);
+    const expectedPkScript = OutScript.encode(addr);
+    if (!recipient.amount) {
+        throw ErrInvalidOnchainOutputAmount(recipient.address);
+    }
+    if (recipient.assets && recipient.assets.length > 0) {
+        throw ErrInvalidOnchainOutputAssets(recipient.address);
+    }
+    for (let i = 0; i < commitmentTx.outputsLength; i++) {
+        if (usedOutputs.has(i)) {
+            continue;
+        }
+        const output = commitmentTx.getOutput(i);
+        if (!output?.script || output.script.length === 0) {
+            continue;
+        }
+        if (equalBytes(output.script, expectedPkScript)) {
+            if (output.amount !== BigInt(recipient.amount)) {
+                continue; // if amount does not match, continue
+            }
+            // we found the right output, recipient is valid, return
+            usedOutputs.add(i);
+            return;
+        }
+    }
+    // if we get here, the recipient is not present in the commitment tx outputs list
+    throw ErrOnchainOutputNotFound(recipient.address);
+}
+// validate the offchain recipient is present in one of the leaf output
+// also verify the asset packet is here, and point the same output index
+function validateOffchainRecipient(leaves, arkAddress, recipient, usedOutputs // leafIndex:outputIndex
+) {
+    const expectedPkScript = arkAddress.pkScript;
+    if (!recipient.amount) {
+        throw ErrInvalidOffchainOutputAmount(recipient.address);
+    }
+    const expectedAmount = BigInt(recipient.amount);
+    let found = false;
+    for (let leafIdx = 0; leafIdx < leaves.length; leafIdx++) {
+        const leaf = leaves[leafIdx];
+        for (let outputIndex = 0; outputIndex < leaf.outputsLength; outputIndex++) {
+            const output = leaf.getOutput(outputIndex);
+            if (!output?.script || output.script.length === 0) {
+                continue;
+            }
+            if (!equalBytes(output.script, expectedPkScript)) {
+                continue;
+            }
+            if (output.amount !== expectedAmount) {
+                continue;
+            }
+            const key = `${leafIdx}:${outputIndex}`;
+            if (usedOutputs.has(key)) {
+                continue;
+            }
+            usedOutputs.add(key);
+            found = true;
+            // if assets, validate the asset packet
+            if (recipient.assets && recipient.assets.length > 0) {
+                validateAssetOutputs(leaf, outputIndex, recipient.assets);
+            }
+            break;
+        }
+        if (found) {
+            break;
+        }
+    }
+    if (!found) {
+        throw ErrOffchainOutputNotFound(recipient.address);
+    }
+}
+function validateAssetOutputs(leafTx, outputIndex, expectedAssets) {
+    const assetPacket = Packet.fromTx(leafTx);
+    for (const { assetId, amount } of expectedAssets) {
+        validateAssetGroupOutput(assetPacket, outputIndex, assetId, amount);
+    }
+}
+function validateAssetGroupOutput(packet, outputIndex, assetId, expectedAmount) {
+    const assetGroup = packet.groups.find((group) => {
+        if (group.isIssuance())
+            return false;
+        return group.assetId.toString() === assetId;
+    });
+    if (!assetGroup) {
+        throw ErrAssetGroupNotFound(assetId);
+    }
+    // find the output at the expected index
+    const assetOutput = assetGroup.outputs.find((output) => output.vout === outputIndex);
+    if (!assetOutput) {
+        throw ErrAssetOutputNotFound(assetId, outputIndex);
+    }
+    const expectedAmountBigInt = BigInt(expectedAmount);
+    if (assetOutput.amount !== expectedAmountBigInt) {
+        throw ErrInvalidAssetOutputAmount(assetOutput.amount, expectedAmountBigInt, assetId);
+    }
+}

package/dist/esm/wallet/vtxo-manager.js

@@ -188,7 +188,7 @@ export class VtxoManager {
         // Get dust amount from wallet
         const dustAmount = getDustAmount(this.wallet);
         // Filter recoverable VTXOs and handle subdust logic
-        const { vtxosToRecover, includesSubdust, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount);
+        const { vtxosToRecover, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount);
         if (vtxosToRecover.length === 0) {
             throw new Error("No recoverable VTXOs found");
         }