@arkade-os/sdk 0.3.9 → 0.3.11

package/dist/cjs/wallet/ramps.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ramps = void 0;
+const arkfee_1 = require("../arkfee");
+const btc_signer_1 = require("@scure/btc-signer");
+const base_1 = require("@scure/base");
+const networks_1 = require("../networks");
+const address_1 = require("../script/address");
 /**
  * Ramps is a class wrapping IWallet.settle method to provide a more convenient interface for onboarding and offboarding operations.
  *
@@ -18,22 +23,51 @@ class Ramps {
     /**
      * Onboard boarding utxos.
      *
+     * @param feeInfo - The fee info to deduct from the onboard amount.
      * @param boardingUtxos - The boarding utxos to onboard. If not provided, all boarding utxos will be used.
      * @param amount - The amount to onboard. If not provided, the total amount of boarding utxos will be onboarded.
      * @param eventCallback - The callback to receive settlement events. optional.
      */
-    async onboard(boardingUtxos, amount, eventCallback) {
+    async onboard(feeInfo, boardingUtxos, amount, eventCallback) {
         boardingUtxos = boardingUtxos ?? (await this.wallet.getBoardingUtxos());
-        const totalAmount = boardingUtxos.reduce((acc, coin) => acc + BigInt(coin.value), 0n);
+        // Calculate input fees and filter out utxos where fee >= value
+        const estimator = new arkfee_1.Estimator(feeInfo?.intentFee ?? {});
+        const filteredBoardingUtxos = [];
+        let totalAmount = 0n;
+        for (const utxo of boardingUtxos) {
+            const inputFee = estimator.evalOnchainInput({
+                amount: BigInt(utxo.value),
+            });
+            if (inputFee.satoshis >= utxo.value) {
+                // skip if fees are greater than or equal to the utxo value
+                continue;
+            }
+            filteredBoardingUtxos.push(utxo);
+            totalAmount += BigInt(utxo.value) - BigInt(inputFee.satoshis);
+        }
+        if (filteredBoardingUtxos.length === 0) {
+            throw new Error("No boarding utxos available after deducting fees");
+        }
         let change = 0n;
         if (amount) {
             if (amount > totalAmount) {
-                throw new Error("Amount is greater than total amount of boarding utxos");
+                throw new Error("Amount is greater than total amount of boarding utxos after fees");
             }
             change = totalAmount - amount;
         }
         amount = amount ?? totalAmount;
+        // Calculate offchain output fee using Estimator
         const offchainAddress = await this.wallet.getAddress();
+        const offchainAddr = address_1.ArkAddress.decode(offchainAddress);
+        const offchainScript = base_1.hex.encode(offchainAddr.pkScript);
+        const outputFee = estimator.evalOffchainOutput({
+            amount,
+            script: offchainScript,
+        });
+        if (BigInt(outputFee.satoshis) > amount) {
+            throw new Error(`can't deduct fees from onboard amount (${outputFee.satoshis} > ${amount})`);
+        }
+        amount -= BigInt(outputFee.satoshis);
         const outputs = [
             {
                 address: offchainAddress,
@@ -48,7 +82,7 @@ class Ramps {
             });
         }
         return this.wallet.settle({
-            inputs: boardingUtxos,
+            inputs: filteredBoardingUtxos,
             outputs,
         }, eventCallback);
     }
@@ -65,20 +99,71 @@ class Ramps {
             withRecoverable: true,
             withUnrolled: false,
         });
-        const totalAmount = vtxos.reduce((acc, coin) => acc + BigInt(coin.value), 0n);
+        // Calculate input fees and filter out vtxos where fee >= value
+        const estimator = new arkfee_1.Estimator(feeInfo?.intentFee ?? {});
+        const filteredVtxos = [];
+        let totalAmount = 0n;
+        for (const vtxo of vtxos) {
+            const inputFee = estimator.evalOffchainInput({
+                amount: BigInt(vtxo.value),
+                type: vtxo.virtualStatus.state === "swept"
+                    ? "recoverable"
+                    : "vtxo",
+                weight: 0,
+                birth: vtxo.createdAt,
+                expiry: vtxo.virtualStatus.batchExpiry
+                    ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
+                    : undefined,
+            });
+            if (inputFee.satoshis >= vtxo.value) {
+                // skip if fees are greater than or equal to the vtxo value
+                continue;
+            }
+            filteredVtxos.push(vtxo);
+            totalAmount += BigInt(vtxo.value) - BigInt(inputFee.satoshis);
+        }
+        if (filteredVtxos.length === 0) {
+            throw new Error("No vtxos available after deducting fees");
+        }
         let change = 0n;
         if (amount) {
             if (amount > totalAmount) {
-                throw new Error("Amount is greater than total amount of vtxos");
+                throw new Error("Amount is greater than total amount of vtxos after fees");
             }
             change = totalAmount - amount;
         }
         amount = amount ?? totalAmount;
-        const fees = feeInfo.intentFee.onchainOutput;
-        if (fees > amount) {
-            throw new Error(`can't deduct fees from offboard amount (${fees} > ${amount})`);
+        const networkNames = [
+            "bitcoin",
+            "regtest",
+            "testnet",
+            "signet",
+            "mutinynet",
+        ];
+        let destinationScript;
+        for (const networkName of networkNames) {
+            try {
+                const network = networks_1.networks[networkName];
+                const addr = (0, btc_signer_1.Address)(network).decode(destinationAddress);
+                destinationScript = btc_signer_1.OutScript.encode(addr);
+                break;
+            }
+            catch {
+                // Try next network
+                continue;
+            }
+        }
+        if (!destinationScript) {
+            throw new Error(`Failed to decode destination address: ${destinationAddress}`);
+        }
+        const outputFee = estimator.evalOnchainOutput({
+            amount,
+            script: base_1.hex.encode(destinationScript),
+        });
+        if (BigInt(outputFee.satoshis) > amount) {
+            throw new Error(`can't deduct fees from offboard amount (${outputFee.satoshis} > ${amount})`);
         }
-        amount -= fees;
+        amount -= BigInt(outputFee.satoshis);
         const outputs = [
             {
                 address: destinationAddress,
@@ -93,7 +178,7 @@ class Ramps {
             });
         }
         return this.wallet.settle({
-            inputs: vtxos,
+            inputs: filteredVtxos,
             outputs,
         }, eventCallback);
     }

package/dist/cjs/wallet/serviceWorker/worker.js

@@ -8,7 +8,6 @@ const wallet_1 = require("../wallet");
 const request_1 = require("./request");
 const response_1 = require("./response");
 const ark_1 = require("../../providers/ark");
-const transactionHistory_1 = require("../../utils/transactionHistory");
 const indexer_1 = require("../../providers/indexer");
 const base_1 = require("@scure/base");
 const indexedDB_1 = require("../../storage/indexedDB");
@@ -43,8 +42,8 @@ class ReadonlyHandler {
     getBoardingAddress() {
         return this.wallet.getBoardingAddress();
     }
-    getBoardingTxs() {
-        return this.wallet.getBoardingTxs();
+    getTransactionHistory() {
+        return this.wallet.getTransactionHistory();
     }
     async handleReload(_) {
         const pending = await this.wallet.fetchPendingTxs();
@@ -130,32 +129,6 @@ class Worker {
         const address = await this.handler.getBoardingAddress();
         return await this.walletRepository.getUtxos(address);
     }
-    async getTransactionHistory() {
-        if (!this.handler)
-            return [];
-        let txs = [];
-        try {
-            const { boardingTxs, commitmentsToIgnore: roundsToIgnore } = await this.handler.getBoardingTxs();
-            const { spendable, spent } = await this.getAllVtxos();
-            // convert VTXOs to offchain transactions
-            const offchainTxs = (0, transactionHistory_1.vtxosToTxs)(spendable, spent, roundsToIgnore);
-            txs = [...boardingTxs, ...offchainTxs];
-            // sort transactions by creation time in descending order (newest first)
-            txs.sort(
-            // place createdAt = 0 (unconfirmed txs) first, then descending
-            (a, b) => {
-                if (a.createdAt === 0)
-                    return -1;
-                if (b.createdAt === 0)
-                    return 1;
-                return b.createdAt - a.createdAt;
-            });
-        }
-        catch (error) {
-            console.error("Error getting transaction history:", error);
-        }
-        return txs;
-    }
     async start(withServiceWorkerUpdate = true) {
         self.addEventListener("message", async (event) => {
             await this.handleMessage(event);
@@ -215,7 +188,7 @@ class Worker {
         const coins = await this.handler.onchainProvider.getCoins(boardingAddress);
         await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => (0, utils_1.extendCoin)(this.handler, utxo)));
         // Get transaction history to cache boarding txs
-        const txs = await this.getTransactionHistory();
+        const txs = await this.handler.getTransactionHistory();
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
         // unsubscribe previous subscription if any
@@ -564,7 +537,7 @@ class Worker {
             return;
         }
         try {
-            const txs = await this.getTransactionHistory();
+            const txs = await this.handler.getTransactionHistory();
             event.source?.postMessage(response_1.Response.transactionHistory(message.id, txs));
         }
         catch (error) {

package/dist/cjs/wallet/wallet.js

@@ -41,7 +41,6 @@ const bip68 = __importStar(require("bip68"));
 const payment_js_1 = require("@scure/btc-signer/payment.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");
 const networks_1 = require("../networks");
@@ -64,6 +63,8 @@ const contractRepository_1 = require("../repositories/contractRepository");
 const utils_1 = require("./utils");
 const errors_1 = require("../providers/errors");
 const batch_1 = require("./batch");
+const arkfee_1 = require("../arkfee");
+const transactionHistory_1 = require("../utils/transactionHistory");
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -267,30 +268,7 @@ class ReadonlyWallet {
             scripts: [base_1.hex.encode(this.offchainTapscript.pkScript)],
         });
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
-        const spendableVtxos = [];
-        const spentVtxos = [];
-        for (const vtxo of response.vtxos) {
-            if ((0, _1.isSpendable)(vtxo)) {
-                spendableVtxos.push(vtxo);
-            }
-            else {
-                spentVtxos.push(vtxo);
-            }
-        }
-        // convert VTXOs to offchain transactions
-        const offchainTxs = (0, transactionHistory_1.vtxosToTxs)(spendableVtxos, spentVtxos, commitmentsToIgnore);
-        const txs = [...boardingTxs, ...offchainTxs];
-        // sort transactions by creation time in descending order (newest first)
-        txs.sort(
-        // place createdAt = 0 (unconfirmed txs) first, then descending
-        (a, b) => {
-            if (a.createdAt === 0)
-                return -1;
-            if (b.createdAt === 0)
-                return 1;
-            return b.createdAt - a.createdAt;
-        });
-        return txs;
+        return (0, transactionHistory_1.buildTransactionHistory)(response.vtxos, boardingTxs, commitmentsToIgnore);
     }
     async getBoardingTxs() {
         const utxos = [];
@@ -550,7 +528,23 @@ class Wallet extends ReadonlyWallet {
         const virtualCoins = await this.getVirtualCoins({
             withRecoverable: false,
         });
-        const selected = selectVirtualCoins(virtualCoins, params.amount);
+        let selected;
+        if (params.selectedVtxos) {
+            const selectedVtxoSum = params.selectedVtxos
+                .map((v) => v.value)
+                .reduce((a, b) => a + b, 0);
+            if (selectedVtxoSum < params.amount) {
+                throw new Error("Selected VTXOs do not cover specified amount");
+            }
+            const changeAmount = selectedVtxoSum - params.amount;
+            selected = {
+                inputs: params.selectedVtxos,
+                changeAmount: BigInt(changeAmount),
+            };
+        }
+        else {
+            selected = selectVirtualCoins(virtualCoins, params.amount);
+        }
         const selectedLeaf = this.offchainTapscript.forfeit();
         if (!selectedLeaf) {
             throw new Error("Selected leaf not found");
@@ -680,25 +674,64 @@ class Wallet extends ReadonlyWallet {
         // if no params are provided, use all non expired boarding utxos and offchain vtxos as inputs
         // and send all to the offchain address
         if (!params) {
+            const { fees } = await this.arkProvider.getInfo();
+            const estimator = new arkfee_1.Estimator(fees.intentFee);
             let amount = 0;
             const exitScript = tapscript_1.CSVMultisigTapscript.decode(base_1.hex.decode(this.boardingTapscript.exitScript));
             const boardingTimelock = exitScript.params.timelock;
             const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !(0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock));
-            amount += boardingUtxos.reduce((sum, input) => sum + input.value, 0);
+            const filteredBoardingUtxos = [];
+            for (const utxo of boardingUtxos) {
+                const inputFee = estimator.evalOnchainInput({
+                    amount: BigInt(utxo.value),
+                });
+                if (inputFee.value >= utxo.value) {
+                    // skip if fees are greater than the utxo value
+                    continue;
+                }
+                filteredBoardingUtxos.push(utxo);
+                amount += utxo.value - inputFee.satoshis;
+            }
             const vtxos = await this.getVtxos({ withRecoverable: true });
-            amount += vtxos.reduce((sum, input) => sum + input.value, 0);
-            const inputs = [...boardingUtxos, ...vtxos];
+            const filteredVtxos = [];
+            for (const vtxo of vtxos) {
+                const inputFee = estimator.evalOffchainInput({
+                    amount: BigInt(vtxo.value),
+                    type: vtxo.virtualStatus.state === "swept"
+                        ? "recoverable"
+                        : "vtxo",
+                    weight: 0,
+                    birth: vtxo.createdAt,
+                    expiry: vtxo.virtualStatus.batchExpiry
+                        ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
+                        : new Date(),
+                });
+                if (inputFee.value >= vtxo.value) {
+                    // skip if fees are greater than the vtxo value
+                    continue;
+                }
+                filteredVtxos.push(vtxo);
+                amount += vtxo.value - inputFee.satoshis;
+            }
+            const inputs = [...filteredBoardingUtxos, ...filteredVtxos];
             if (inputs.length === 0) {
                 throw new Error("No inputs found");
             }
+            const output = {
+                address: await this.getAddress(),
+                amount: BigInt(amount),
+            };
+            const outputFee = estimator.evalOffchainOutput({
+                amount: output.amount,
+                script: base_1.hex.encode(address_1.ArkAddress.decode(output.address).pkScript),
+            });
+            output.amount -= BigInt(outputFee.satoshis);
+            if (output.amount <= this.dustAmount) {
+                throw new Error("Output amount is below dust limit");
+            }
             params = {
                 inputs,
-                outputs: [
-                    {
-                        address: await this.getAddress(),
-                        amount: BigInt(amount),
-                    },
-                ],
+                outputs: [output],
             };
         }
         const onchainOutputIndexes = [];

package/dist/esm/arkfee/celenv.js

@@ -0,0 +1,40 @@
+import { Environment } from "@marcbachmann/cel-js";
+/**
+ * Variable names used in CEL expressions
+ */
+export const AmountVariableName = "amount";
+export const ExpiryVariableName = "expiry";
+export const BirthVariableName = "birth";
+export const WeightVariableName = "weight";
+export const InputTypeVariableName = "inputType";
+export const OutputScriptVariableName = "script";
+const nowFunction = {
+    signature: "now(): double",
+    implementation: () => Math.floor(Date.now() / 1000),
+};
+/**
+ * IntentOutputEnv is the CEL environment for output fee calculation
+ * Variables: amount, script
+ */
+export const IntentOutputEnv = new Environment()
+    .registerVariable(AmountVariableName, "double")
+    .registerVariable(OutputScriptVariableName, "string")
+    .registerFunction(nowFunction.signature, nowFunction.implementation);
+/**
+ * IntentOffchainInputEnv is the CEL environment for offchain input fee calculation
+ * Variables: amount, expiry, birth, weight, inputType
+ */
+export const IntentOffchainInputEnv = new Environment()
+    .registerVariable(AmountVariableName, "double")
+    .registerVariable(ExpiryVariableName, "double")
+    .registerVariable(BirthVariableName, "double")
+    .registerVariable(WeightVariableName, "double")
+    .registerVariable(InputTypeVariableName, "string")
+    .registerFunction(nowFunction.signature, nowFunction.implementation);
+/**
+ * IntentOnchainInputEnv is the CEL environment for onchain input fee calculation
+ * Variables: amount
+ */
+export const IntentOnchainInputEnv = new Environment()
+    .registerVariable(AmountVariableName, "double")
+    .registerFunction(nowFunction.signature, nowFunction.implementation);

package/dist/esm/arkfee/estimator.js

@@ -0,0 +1,139 @@
+import { IntentOffchainInputEnv, IntentOnchainInputEnv, IntentOutputEnv, } from "./celenv.js";
+import { FeeAmount, } from "./types.js";
+/**
+ * Estimator evaluates CEL expressions to calculate fees for Ark intents
+ */
+export class Estimator {
+    /**
+     * Creates a new Estimator with the given config
+     * @param config - Configuration containing CEL programs for fee calculation
+     */
+    constructor(config) {
+        this.config = config;
+        this.intentOffchainInput = config.offchainInput
+            ? parseProgram(config.offchainInput, IntentOffchainInputEnv)
+            : undefined;
+        this.intentOnchainInput = config.onchainInput
+            ? parseProgram(config.onchainInput, IntentOnchainInputEnv)
+            : undefined;
+        this.intentOffchainOutput = config.offchainOutput
+            ? parseProgram(config.offchainOutput, IntentOutputEnv)
+            : undefined;
+        this.intentOnchainOutput = config.onchainOutput
+            ? parseProgram(config.onchainOutput, IntentOutputEnv)
+            : undefined;
+    }
+    /**
+     * Evaluates the fee for a given vtxo input
+     * @param input - The offchain input to evaluate
+     * @returns The fee amount for this input
+     */
+    evalOffchainInput(input) {
+        if (!this.intentOffchainInput) {
+            return FeeAmount.ZERO;
+        }
+        const args = inputToArgs(input);
+        return new FeeAmount(this.intentOffchainInput.program(args));
+    }
+    /**
+     * Evaluates the fee for a given boarding input
+     * @param input - The onchain input to evaluate
+     * @returns The fee amount for this input
+     */
+    evalOnchainInput(input) {
+        if (!this.intentOnchainInput) {
+            return FeeAmount.ZERO;
+        }
+        const args = {
+            amount: Number(input.amount),
+        };
+        return new FeeAmount(this.intentOnchainInput.program(args));
+    }
+    /**
+     * Evaluates the fee for a given vtxo output
+     * @param output - The output to evaluate
+     * @returns The fee amount for this output
+     */
+    evalOffchainOutput(output) {
+        if (!this.intentOffchainOutput) {
+            return FeeAmount.ZERO;
+        }
+        const args = outputToArgs(output);
+        return new FeeAmount(this.intentOffchainOutput.program(args));
+    }
+    /**
+     * Evaluates the fee for a given collaborative exit output
+     * @param output - The output to evaluate
+     * @returns The fee amount for this output
+     */
+    evalOnchainOutput(output) {
+        if (!this.intentOnchainOutput) {
+            return FeeAmount.ZERO;
+        }
+        const args = outputToArgs(output);
+        return new FeeAmount(this.intentOnchainOutput.program(args));
+    }
+    /**
+     * Evaluates the fee for a given set of inputs and outputs
+     * @param offchainInputs - Array of offchain inputs to evaluate
+     * @param onchainInputs - Array of onchain inputs to evaluate
+     * @param offchainOutputs - Array of offchain outputs to evaluate
+     * @param onchainOutputs - Array of onchain outputs to evaluate
+     * @returns The total fee amount
+     */
+    eval(offchainInputs, onchainInputs, offchainOutputs, onchainOutputs) {
+        let fee = FeeAmount.ZERO;
+        for (const input of offchainInputs) {
+            fee = fee.add(this.evalOffchainInput(input));
+        }
+        for (const input of onchainInputs) {
+            fee = fee.add(this.evalOnchainInput(input));
+        }
+        for (const output of offchainOutputs) {
+            fee = fee.add(this.evalOffchainOutput(output));
+        }
+        for (const output of onchainOutputs) {
+            fee = fee.add(this.evalOnchainOutput(output));
+        }
+        return fee;
+    }
+}
+function inputToArgs(input) {
+    const args = {
+        amount: Number(input.amount),
+        inputType: input.type,
+        weight: input.weight,
+    };
+    if (input.expiry) {
+        args.expiry = Math.floor(input.expiry.getTime() / 1000);
+    }
+    if (input.birth) {
+        args.birth = Math.floor(input.birth.getTime() / 1000);
+    }
+    return args;
+}
+function outputToArgs(output) {
+    return {
+        amount: Number(output.amount),
+        script: output.script,
+    };
+}
+/**
+ * Parses a CEL program and validates its return type
+ * @param text - The CEL program text to parse
+ * @param env - The CEL environment to use
+ * @returns parsed and validated program
+ */
+function parseProgram(text, env) {
+    const program = env.parse(text);
+    // Type check the program
+    const checkResult = program.check();
+    if (!checkResult.valid) {
+        throw new Error(`type check failed: ${checkResult.error?.message ?? "unknown error"}`);
+    }
+    // Verify return type is double
+    if (checkResult.type !== "double") {
+        throw new Error(`expected return type double, got ${checkResult.type}`);
+    }
+    return { program, text };
+}

package/dist/esm/arkfee/index.js

@@ -0,0 +1 @@
+export { Estimator } from './estimator.js';

package/dist/esm/arkfee/types.js

@@ -0,0 +1,21 @@
+/**
+ * FeeAmount is a wrapper around a number that represents a fee amount in satoshis floating point.
+ * @param value - The fee amount in floating point.
+ * @method satoshis - Returns the fee amount in satoshis as a integer.
+ * @example
+ * const fee = new FeeAmount(1.23456789);
+ * console.log(fee.value); // 1.23456789
+ * console.log(fee.satoshis); // 2
+ */
+export class FeeAmount {
+    constructor(value) {
+        this.value = value;
+    }
+    get satoshis() {
+        return this.value ? Math.ceil(this.value) : 0;
+    }
+    add(other) {
+        return new FeeAmount(this.value + other.value);
+    }
+}
+FeeAmount.ZERO = new FeeAmount(0);

package/dist/esm/index.js

@@ -32,6 +32,7 @@ import { ContractRepositoryImpl } from './repositories/contractRepository.js';
 import { ArkError, maybeArkError } from './providers/errors.js';
 import { validateVtxoTxGraph, validateConnectorsTxGraph, } from './tree/validation.js';
 import { buildForfeitTx } from './forfeit.js';
+export * from './arkfee/index.js';
 export { 
 // Wallets
 Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, OnchainWallet, Ramps, VtxoManager, 

package/dist/esm/intent/index.js

@@ -54,6 +54,27 @@ export var Intent;
         return craftToSignTx(toSpend, inputs, outputs);
     }
     Intent.create = create;
+    function fee(proof) {
+        let sumOfInputs = 0n;
+        for (let i = 0; i < proof.inputsLength; i++) {
+            const input = proof.getInput(i);
+            if (input.witnessUtxo === undefined)
+                throw new Error("intent proof input requires witness utxo");
+            sumOfInputs += input.witnessUtxo.amount;
+        }
+        let sumOfOutputs = 0n;
+        for (let i = 0; i < proof.outputsLength; i++) {
+            const output = proof.getOutput(i);
+            if (output.amount === undefined)
+                throw new Error("intent proof output requires amount");
+            sumOfOutputs += output.amount;
+        }
+        if (sumOfOutputs > sumOfInputs) {
+            throw new Error(`intent proof output amount is greater than input amount: ${sumOfOutputs} > ${sumOfInputs}`);
+        }
+        return Number(sumOfInputs - sumOfOutputs);
+    }
+    Intent.fee = fee;
     function encodeMessage(message) {
         switch (message.type) {
             case "register":

package/dist/esm/providers/ark.js

@@ -44,11 +44,7 @@ export class RestArkProvider {
             digest: fromServer.digest ?? "",
             dust: BigInt(fromServer.dust ?? 0),
             fees: {
-                intentFee: {
-                    ...fromServer.fees?.intentFee,
-                    onchainInput: BigInt(fromServer.fees?.intentFee?.onchainInput ?? 0),
-                    onchainOutput: BigInt(fromServer.fees?.intentFee?.onchainOutput ?? 0),
-                },
+                intentFee: fromServer.fees?.intentFee ?? {},
                 txFeeRate: fromServer?.fees?.txFeeRate ?? "",
             },
             forfeitAddress: fromServer.forfeitAddress ?? "",
@@ -61,6 +57,7 @@ export class RestArkProvider {
                     nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
                     nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
                     period: BigInt(fromServer.scheduledSession.period ?? 0),
+                    fees: fromServer.scheduledSession.fees ?? {},
                 }
                 : undefined,
             serviceStatus: fromServer.serviceStatus ?? {},

package/dist/esm/providers/indexer.js

@@ -338,6 +338,7 @@ function convertVtxo(vtxo) {
         value: Number(vtxo.amount),
         status: {
             confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
+            isLeaf: !vtxo.isPreconfirmed,
         },
         virtualStatus: {
             state: vtxo.isSwept