@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/cjs/wallet/utils.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DUST_AMOUNT = void 0;
 exports.extendVirtualCoin = extendVirtualCoin;
 exports.extendCoin = extendCoin;
+exports.extendVtxoFromContract = extendVtxoFromContract;
+exports.getRandomId = getRandomId;
+exports.isValidArkAddress = isValidArkAddress;
+exports.validateRecipients = validateRecipients;
+const __1 = require("..");
+const handlers_1 = require("../contracts/handlers");
+const base_1 = require("@scure/base");
 exports.DUST_AMOUNT = 546; // sats
 function extendVirtualCoin(wallet, vtxo) {
     return {
@@ -20,3 +27,54 @@ function extendCoin(wallet, utxo) {
         tapTree: wallet.boardingTapscript.encode(),
     };
 }
+function extendVtxoFromContract(vtxo, contract) {
+    const handler = handlers_1.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(),
+    };
+}
+function getRandomId() {
+    const randomValue = crypto.getRandomValues(new Uint8Array(16));
+    return base_1.hex.encode(randomValue);
+}
+function isValidArkAddress(address) {
+    try {
+        __1.ArkAddress.decode(address);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function validateRecipients(recipients, dustAmount) {
+    const validatedRecipients = [];
+    for (const recipient of recipients) {
+        let address;
+        try {
+            address = __1.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/cjs/wallet/validation.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrInvalidOffchainOutputAmount = exports.ErrOnchainOutputNotFound = exports.ErrInvalidOnchainOutputAssets = exports.ErrInvalidOnchainOutputAmount = exports.ErrAssetOutputNotFound = exports.ErrAssetGroupNotFound = exports.ErrInvalidAssetOutputAmount = exports.ErrOffchainOutputNotFound = void 0;
+exports.validateBatchRecipients = validateBatchRecipients;
+const utils_js_1 = require("@scure/btc-signer/utils.js");
+const address_1 = require("../script/address");
+const asset_1 = require("../asset");
+const btc_signer_1 = require("@scure/btc-signer");
+const ErrOffchainOutputNotFound = (address) => new Error(`offchain send output not found: ${address}`);
+exports.ErrOffchainOutputNotFound = ErrOffchainOutputNotFound;
+const ErrInvalidAssetOutputAmount = (got, want, assetId) => new Error(`invalid asset output amount for ${assetId}: got ${got}, want ${want}`);
+exports.ErrInvalidAssetOutputAmount = ErrInvalidAssetOutputAmount;
+const ErrAssetGroupNotFound = (assetId) => new Error(`asset group not found in batch leaf: ${assetId}`);
+exports.ErrAssetGroupNotFound = ErrAssetGroupNotFound;
+const ErrAssetOutputNotFound = (assetId, outputIndex) => new Error(`asset output not found in asset group ${assetId} at index ${outputIndex}`);
+exports.ErrAssetOutputNotFound = ErrAssetOutputNotFound;
+const ErrInvalidOnchainOutputAmount = (address) => new Error(`invalid onchain output amount: ${address}`);
+exports.ErrInvalidOnchainOutputAmount = ErrInvalidOnchainOutputAmount;
+const ErrInvalidOnchainOutputAssets = (address) => new Error(`onchain output ${address} cannot have assets`);
+exports.ErrInvalidOnchainOutputAssets = ErrInvalidOnchainOutputAssets;
+const ErrOnchainOutputNotFound = (address) => new Error(`onchain output not found: ${address}`);
+exports.ErrOnchainOutputNotFound = ErrOnchainOutputNotFound;
+const ErrInvalidOffchainOutputAmount = (address) => new Error(`invalid offchain output ${address}, missing amount`);
+exports.ErrInvalidOffchainOutputAmount = ErrInvalidOffchainOutputAmount;
+/**
+ * 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
+ */
+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 = address_1.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 = (0, btc_signer_1.Address)(network).decode(recipient.address);
+    const expectedPkScript = btc_signer_1.OutScript.encode(addr);
+    if (!recipient.amount) {
+        throw (0, exports.ErrInvalidOnchainOutputAmount)(recipient.address);
+    }
+    if (recipient.assets && recipient.assets.length > 0) {
+        throw (0, exports.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 ((0, utils_js_1.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 (0, exports.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 (0, exports.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 (!(0, utils_js_1.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 (0, exports.ErrOffchainOutputNotFound)(recipient.address);
+    }
+}
+function validateAssetOutputs(leafTx, outputIndex, expectedAssets) {
+    const assetPacket = asset_1.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 (0, exports.ErrAssetGroupNotFound)(assetId);
+    }
+    // find the output at the expected index
+    const assetOutput = assetGroup.outputs.find((output) => output.vout === outputIndex);
+    if (!assetOutput) {
+        throw (0, exports.ErrAssetOutputNotFound)(assetId, outputIndex);
+    }
+    const expectedAmountBigInt = BigInt(expectedAmount);
+    if (assetOutput.amount !== expectedAmountBigInt) {
+        throw (0, exports.ErrInvalidAssetOutputAmount)(assetOutput.amount, expectedAmountBigInt, assetId);
+    }
+}

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

@@ -93,6 +93,13 @@ function isVtxoExpiringSoon(vtxo, thresholdMs // in milliseconds
     const { batchExpiry } = vtxo.virtualStatus;
     if (!batchExpiry)
         return false; // it doesn't expire
+    // we use this as a workaround to avoid issue on regtest where expiry date is
+    // expressed in blockheight instead of timestamp. If expiry, as Date, is before 2025,
+    // then we admit it's too small to be a timestamp
+    // TODO: API should return the expiry unit
+    const expireAt = new Date(batchExpiry);
+    if (expireAt.getFullYear() < 2025)
+        return false;
     const now = Date.now();
     if (batchExpiry <= now)
         return false; // already expired
@@ -193,7 +200,7 @@ 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");
         }