@ledgerhq/live-cli 24.40.1-nightly.20260506192049 → 24.40.1

package/lib/{722.js → 550.js}

@@ -6,7 +6,7 @@ const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
       new URL('main.js', document.baseURI).href;
 })();
 ;
-exports.ids = ["722"];
+exports.ids = ["550"];
 exports.modules = {
 "../../libs/ledger-live-common/lib-es/bridge/generic-alpaca/alpaca/local/tezos.js"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 // ESM COMPAT FLAG
@@ -90,6 +90,20 @@ var utils = __webpack_require__("../../node_modules/.pnpm/@taquito+ledger-signer
  * the increased fee component when computing send-max in fallback mode.
  * Chosen to match Taquito’s behavior closely in integration tests.
  */ const OP_SIZE_XTZ_TRANSFER = 154;
+/**
+ * Helper function to map generic staking intents to Tezos operation modes
+ */ function mapIntentTypeToTezosMode(intentType) {
+    switch(intentType){
+        case "stake":
+        case "delegate":
+            return "delegate";
+        case "unstake":
+        case "undelegate":
+            return "undelegate";
+        default:
+            return "send";
+    }
+}
 /**
  * Parse FA1.2 / FA2 token contract + token id from Alpaca `assetReference`
  * (`KT1…` or `KT1…:tokenId` as produced by getBlock / listOperations).
@@ -115,7 +129,7 @@ var utils = __webpack_require__("../../node_modules/.pnpm/@taquito+ledger-signer
 /**
  * Resolves Tezos operation mode from intent type and asset (native XTZ vs token).
  */ function resolveTezosOperationMode(intentType, asset) {
-    const base = intentType;
+    const base = mapIntentTypeToTezosMode(intentType);
     if (base === "send" && parseTezosTokenAsset(asset) !== null) {
         return "send_token";
     }
@@ -309,34 +323,8 @@ async function craftTransaction(account, transaction, publicKey) {
                 });
                 break;
             }
-        case "stake":
-        case "unstake":
-        case "finalize_unstake":
-            {
-                const typeMap = {
-                    stake: "STAKE",
-                    unstake: "UNSTAKE",
-                    finalize_unstake: "FINALIZE_UNSTAKE"
-                };
-                type = typeMap[transaction.type];
-                contents.push({
-                    kind: taquito_rpc_es6/* .OpKind.TRANSACTION */.w9.TRANSACTION,
-                    amount: transaction.type === "finalize_unstake" ? "0" : transaction.amount.toString(),
-                    destination: address,
-                    source: address,
-                    counter: (counter + 1 + contents.length).toString(),
-                    parameters: {
-                        entrypoint: transaction.type,
-                        value: {
-                            prim: "Unit"
-                        }
-                    },
-                    ...transactionFees
-                });
-                break;
-            }
         default:
-            throw new types_errors/* .UnsupportedTransactionMode */.VJ("unsupported mode", {
+            throw new types_errors/* .UnsupportedTransactionMode */.V("unsupported mode", {
                 mode: transaction.type
             });
     }
@@ -435,21 +423,6 @@ async function craftTransaction(account, transaction, publicKey) {
                     source: account.address
                 });
                 break;
-            case "stake":
-                estimate = await tezosToolkit.estimate.stake({
-                    amount: Number(amount),
-                    mutez: true
-                });
-                break;
-            case "unstake":
-                estimate = await tezosToolkit.estimate.unstake({
-                    amount: Number(amount),
-                    mutez: true
-                });
-                break;
-            case "finalize_unstake":
-                estimate = await tezosToolkit.estimate.finalizeUnstake({});
-                break;
             case "send_token":
                 {
                     if (!transaction.contractAddress || transaction.tokenId === undefined) {
@@ -477,7 +450,7 @@ async function craftTransaction(account, transaction, publicKey) {
                     break;
                 }
             default:
-                throw new types_errors/* .UnsupportedTransactionMode */.VJ("unsupported mode", {
+                throw new types_errors/* .UnsupportedTransactionMode */.V("unsupported mode", {
                     mode: transaction.mode
                 });
         }
@@ -627,26 +600,6 @@ const clearUndefined = (obj)=>{
     Object.entries(newObj).forEach(([key, value])=>value === undefined && delete newObj[key]);
     return newObj;
 };
-/**
- * Internal helper shared by `getOperationsTransactions` and `getOperationsOrigination`.
- * Both endpoints accept the same query shape; only the URL path differs.
- */ async function getOperationsByType(type, level, cursor, apiQueryParams = {}) {
-    // "sort.asc": "id" guarantees forward progress for cursor-based paging (offset.cr).
-    // Without an explicit sort the API default may be descending, which would cause the
-    // cursor to go backwards and produce duplicates or an infinite loop.
-    const params = {
-        "level.gte": level,
-        limit: BLOCK_PAGE_SIZE,
-        "sort.asc": "id",
-        ...clearUndefined(apiQueryParams)
-    };
-    if (cursor !== undefined) params["offset.cr"] = cursor;
-    const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
-        url: `${getExplorerUrl()}/v1/operations/${type}`,
-        params
-    });
-    return data;
-}
 const tzkt_api = {
     async getBlockCount () {
         const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
@@ -692,25 +645,6 @@ const tzkt_api = {
         });
         return data;
     },
-    /**
-     * Resolves block hashes for the given levels in a single request.
-     * Uses `/v1/blocks?level.in=...&select.values=level,hash`, which TzKT honours
-     * (unlike `/v1/blocks/{level}?select=...`, where `select` is ignored). Used
-     * for cheap backfill of `block.hash` on operations whose level is known but
-     * whose response omits the block field (e.g. `/accounts/{addr}/operations`
-     * for staking ops). Levels that don't resolve are absent from the result map.
-     */ async getBlockHashesByLevels (levels) {
-        if (levels.length === 0) return new Map();
-        const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
-            url: `${getExplorerUrl()}/v1/blocks`,
-            params: {
-                "level.in": levels.join(","),
-                "select.values": "level,hash",
-                limit: levels.length
-            }
-        });
-        return new Map(data);
-    },
     /**
      * Fetches a single page of `transaction` operations at the given block level.
      * Internal — used by `fetchBlockTransactions` which handles pagination.
@@ -735,13 +669,21 @@ const tzkt_api = {
      * Fetches a list of `transaction` operations after the given level.
      * https://api.tzkt.io/#operation/Operations_GetTransactions
      */ async getOperationsTransactions (level, cursor, apiQueryParams = {}) {
-        return getOperationsByType("transactions", level, cursor, apiQueryParams);
-    },
-    /**
-     * Fetches a list of `originations` operations after the given level.
-     * https://api.tzkt.io/#operation/Operations_GetOriginations
-     */ async getOperationsOrigination (level, cursor, apiQueryParams = {}) {
-        return getOperationsByType("originations", level, cursor, apiQueryParams);
+        // "sort.asc": "id" guarantees forward progress for cursor-based paging (offset.cr).
+        // Without an explicit sort the API default may be descending, which would cause the
+        // cursor to go backwards and produce duplicates or an infinite loop.
+        const params = {
+            "level.gte": level,
+            limit: BLOCK_PAGE_SIZE,
+            "sort.asc": "id",
+            ...clearUndefined(apiQueryParams)
+        };
+        if (cursor !== undefined) params["offset.cr"] = cursor;
+        const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
+            url: `${getExplorerUrl()}/v1/operations/transactions`,
+            params
+        });
+        return data;
     },
     /**
      * Fetches a single page of FA token transfers at the given block level.
@@ -765,10 +707,16 @@ const tzkt_api = {
     /**
      * Fetches the latest FA token transfers since the given level.
      * https://api.tzkt.io/#operation/Tokens_GetTokenTransfers
-     */ async getTokenTransfers (apiQueryParams = {}) {
+     */ async getTokenTransfers (level, cursor, apiQueryParams = {}) {
+        // Same rationale as getBlockTransactionsPage: explicit ascending sort keeps the
+        // offset.cr cursor advancing forward regardless of the API's default ordering.;
         const params = {
+            "level.gte": level,
+            limit: BLOCK_PAGE_SIZE,
+            "sort.asc": "id",
             ...clearUndefined(apiQueryParams)
         };
+        if (cursor !== undefined) params["offset.cr"] = cursor;
         const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
             url: `${getExplorerUrl()}/v1/tokens/transfers`,
             params
@@ -792,75 +740,31 @@ const tzkt_api = {
         });
         return data;
     },
-    /**
-     * Fetches a single page of `staking` operations at the given block level.
-     * Internal — used by `fetchBlockStaking` which handles pagination.
-     * https://api.tzkt.io/#operation/Operations_GetStaking
-     */ async getBlockStakingPage (level, cursor) {
-        const params = {
-            level,
-            limit: BLOCK_PAGE_SIZE,
-            "sort.asc": "id"
-        };
-        if (cursor !== undefined) params["offset.cr"] = cursor;
-        const { data } = await (0,live_network_lib_es/* ["default"] */.A)({
-            url: `${getExplorerUrl()}/v1/operations/staking`,
-            params
-        });
-        return data;
-    },
     /**
      * Fetches FA2 token transfers (tokenId = 0 only) for a given account.
      * This is limited to `token.standard=fa2` and `token.tokenId=0` on the TzKT API.
-     * Translates `query.sort` to TzKT's `sort.asc=id` / `sort.desc=id`.
-     * The lower-level `getTokenTransfers` helper is a generic pass-through and does not pin the sort.
      * https://api.tzkt.io/#operation/Tokens_GetTokenTransfers
      */ async getAccountTokenTransfers (address, query) {
-        const sortKey = query.sort === "Descending" ? "sort.desc" : "sort.asc";
         const params = {
             "anyof.from.to": address,
             "token.tokenId": "0",
-            "token.standard": "fa2",
-            [sortKey]: "id",
-            limit: query.limit,
-            "level.ge": query["level.ge"],
-            "level.lt": query["level.lt"],
-            "level.gt": query["level.gt"],
-            "id.lt": query["id.lt"],
-            "id.gt": query["id.gt"]
+            "token.standard": "fa2"
         };
-        const data = await tzkt_api.getTokenTransfers(clearUndefined(params));
+        const data = await tzkt_api.getTokenTransfers(query["level.ge"], query["lastId"], params);
         const transactionIds = data.map((t)=>t.transactionId).filter((id)=>typeof id === "number");
-        const originationIds = data.map((t)=>t.originationId).filter((id)=>typeof id === "number");
-        if (transactionIds.length === 0 && originationIds.length === 0) {
-            return [];
+        if (transactionIds.length === 0) {
+            return data.map((token)=>({
+                    ...token,
+                    hash: ""
+                }));
         }
-        const transactions = transactionIds.length ? await tzkt_api.getOperationsTransactions(query["level.ge"] || 0, undefined, {
+        const transactions = await tzkt_api.getOperationsTransactions(query["level.ge"] || 0, undefined, {
             "id.in": transactionIds.join(",")
-        }) : [];
-        const originations = originationIds.length ? await tzkt_api.getOperationsOrigination(query["level.ge"] || 0, undefined, {
-            "id.in": originationIds.join(",")
-        }) : [];
-        // Build id -> operation maps once so per-transfer lookups are O(1) instead of O(n).
-        // Keys are widened to `number | undefined` so lookups with a missing id naturally
-        // return `undefined` (no entry is ever stored under the `undefined` key).
-        const transactionsById = new Map(transactions.map((t)=>[
-                t.id,
-                t
-            ]));
-        const originationsById = new Map(originations.map((o)=>[
-                o.id,
-                o
-            ]));
-        return data.map((token)=>{
-            const transaction = transactionsById.get(token.transactionId);
-            const origination = originationsById.get(token.originationId);
-            return {
-                ...token,
-                hash: transaction?.hash ?? origination?.hash ?? "",
-                block: transaction?.block ?? origination?.block ?? ""
-            };
         });
+        return data.map((token)=>({
+                ...token,
+                hash: transactions.find((t)=>t.id === token.transactionId)?.hash ?? ""
+            }));
     },
     /**
      * Fetches FA token balances for a given account.
@@ -972,104 +876,14 @@ const fetchAllTransactions = async (address, lastId)=>{
     }
     return delegations;
 };
-/**
- * Fetches ALL `staking` operations for a given block level, paginating through
- * TzKT's cursor-based pages (`offset.cr`) until exhausted.
- */ const fetchBlockStaking = async (level)=>{
-    const stakingOps = [];
-    let cursor;
-    let maxIteration = lib_es_config/* ["default"].getCoinConfig */.A.getCoinConfig().explorer.maxTxQuery;
-    do {
-        const page = await tzkt_api.getBlockStakingPage(level, cursor);
-        if (page.length === 0) break;
-        stakingOps.push(...page);
-        if (page.length < BLOCK_PAGE_SIZE) break;
-        cursor = page.at(-1).id;
-    }while (--maxIteration > 0);
-    if (maxIteration === 0) {
-        (0,logs_lib_es/* .log */.Rm)("tezos", `fetchBlockStaking: maxTxQuery limit reached at level ${level}, result may be incomplete`);
-    }
-    return stakingOps;
-};
 /* export default */ const tzkt = (tzkt_api); //# sourceMappingURL=tzkt.js.map
 
-;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/logic/getStakes.js
-
-/**
- * Build the staking positions exposed by a Tezos account, per Paris upgrade semantics:
- * - delegation position (when a delegate is set) for the non-staked, delegated amount
- * - active staking position (when `stakedBalance > 0`)
- * - deactivating unstake position (when `unstakedBalance > 0`)
- *
- * Each entry inherits the account `delegate` when set, since on Tezos a staked or unstaked
- * portion is necessarily delegated to the same baker as the rest of the balance.
- */ function buildStakesForAccount(address, account) {
-    const balance = BigInt(account.balance ?? 0);
-    const stakedBalance = BigInt(account.stakedBalance ?? 0);
-    const unstakedBalance = BigInt(account.unstakedBalance ?? 0);
-    const delegateAddress = account.delegate?.address;
-    const stakes = [];
-    if (delegateAddress) {
-        stakes.push({
-            uid: `delegation-${address}`,
-            address,
-            delegate: delegateAddress,
-            state: "active",
-            asset: {
-                type: "native"
-            },
-            amount: balance - stakedBalance
-        });
-    }
-    if (stakedBalance > 0n) {
-        stakes.push({
-            uid: `stake-${address}`,
-            address,
-            ...delegateAddress && {
-                delegate: delegateAddress
-            },
-            state: "active",
-            asset: {
-                type: "native"
-            },
-            amount: stakedBalance
-        });
-    }
-    if (unstakedBalance > 0n) {
-        stakes.push({
-            uid: `unstaking-${address}`,
-            address,
-            ...delegateAddress && {
-                delegate: delegateAddress
-            },
-            state: "deactivating",
-            asset: {
-                type: "native"
-            },
-            amount: unstakedBalance
-        });
-    }
-    return stakes;
-}
-async function getStakes(address, _cursor) {
-    const accountInfo = await tzkt.getAccountByAddress(address);
-    if (accountInfo.type !== "user") return {
-        items: []
-    };
-    return {
-        items: buildStakesForAccount(address, accountInfo)
-    };
-} //# sourceMappingURL=getStakes.js.map
-
 ;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/logic/getBalance.js
 
-
 /**
  * Returns the balances of the given address as an array of Balance objects.
- * The first entry represents the native balance (with value 0n for empty accounts).
- * For delegated/staked accounts, additional native entries are appended carrying each
- * staking position (delegation, active staking, deactivating unstake) per the Paris upgrade.
- * Token balances are appended after.
+ * The first entry represents the native balance (with value 0n for empty accounts),
+ * followed by any token balances associated with the address.
  */ async function getBalance(address) {
     const [apiAccountResult, tokensBalancesResult] = await Promise.allSettled([
         tzkt.getAccountByAddress(address),
@@ -1081,13 +895,16 @@ async function getStakes(address, _cursor) {
     const apiAccount = apiAccountResult.value;
     const tokensBalancesRaw = tokensBalancesResult.status === "fulfilled" ? tokensBalancesResult.value : [];
     const normalized = apiAccount.type === "user" ? BigInt(apiAccount.balance) : 0n;
-    const stakeBalances = apiAccount.type === "user" ? buildStakesForAccount(address, apiAccount).map((stake)=>({
-            value: stake.amount,
-            asset: {
-                type: "native"
-            },
-            stake
-        })) : [];
+    const stake = apiAccount.type === "user" && apiAccount.delegate?.address ? {
+        uid: address,
+        address,
+        delegate: apiAccount.delegate.address,
+        state: "active",
+        asset: {
+            type: "native"
+        },
+        amount: normalized
+    } : undefined;
     const tokensBalance = tokensBalancesRaw.map(({ balance, token })=>{
         const magnitude = Number.parseInt(token.metadata?.decimals || "0", 10);
         const name = token.metadata?.name ?? token.contract.alias ?? "";
@@ -1115,9 +932,11 @@ async function getStakes(address, _cursor) {
             value: normalized,
             asset: {
                 type: "native"
+            },
+            ...stake && {
+                stake
             }
         },
-        ...stakeBalances,
         ...tokensBalance
     ];
 } //# sourceMappingURL=getBalance.js.map
@@ -1129,16 +948,8 @@ var bakers = __webpack_require__("../../libs/coin-modules/coin-tezos/lib-es/netw
 
  //# sourceMappingURL=index.js.map
 
-;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/constants.js
-const STAKING_ACTION_TO_OP_TYPE = {
-    stake: "STAKE",
-    unstake: "UNSTAKE",
-    finalize: "FINALIZE_UNSTAKE"
-}; //# sourceMappingURL=constants.js.map
-
 ;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/logic/getBlock.js
 
-
 const NATIVE_ASSET = {
     type: "native",
     name: "XTZ"
@@ -1273,51 +1084,6 @@ function buildBlockTransactionFromDelegation(op) {
     };
 }
 // ---------------------------------------------------------------------------
-// Staking helpers (Paris adaptive issuance)
-// ---------------------------------------------------------------------------
-function computeStakingFees(op) {
-    return BigInt(op.bakerFee ?? 0) + BigInt(op.storageFee ?? 0) + BigInt(op.allocationFee ?? 0);
-}
-function buildStakingOperations(op) {
-    const senderAddr = op.sender?.address;
-    if (!senderAddr) return [];
-    const operationType = STAKING_ACTION_TO_OP_TYPE[op.action];
-    const bakerAddr = op.baker?.address;
-    return [
-        {
-            type: "other",
-            address: senderAddr,
-            asset: NATIVE_ASSET,
-            amount: 0n,
-            details: {
-                operationType,
-                stakedAmount: BigInt(op.amount),
-                ...bakerAddr && {
-                    delegate: bakerAddr
-                },
-                counter: op.counter,
-                gasLimit: op.gasLimit,
-                storageLimit: op.storageLimit,
-                ledgerOpType: operationType
-            }
-        }
-    ];
-}
-function buildBlockTransactionFromStaking(op) {
-    if (!op.hash) return null;
-    const feesPayer = op.sender?.address;
-    const succeeded = !op.status || op.status === "applied";
-    return {
-        hash: op.hash,
-        failed: !succeeded,
-        fees: computeStakingFees(op),
-        ...feesPayer && {
-            feesPayer
-        },
-        operations: succeeded ? buildStakingOperations(op) : []
-    };
-}
-// ---------------------------------------------------------------------------
 // FA token helpers
 // ---------------------------------------------------------------------------
 /**
@@ -1424,21 +1190,7 @@ function buildBlockTransactionFromStaking(op) {
 // ---------------------------------------------------------------------------
 // Transaction grouping — public orchestrator
 // ---------------------------------------------------------------------------
-function mergeAuxiliaryTx(blockTxByHash, auxTx) {
-    const existing = blockTxByHash.get(auxTx.hash);
-    if (!existing) {
-        blockTxByHash.set(auxTx.hash, auxTx);
-        return;
-    }
-    if (auxTx.failed) {
-        existing.failed = true;
-        existing.operations = [];
-    } else if (!existing.failed && auxTx.operations.length > 0) {
-        existing.operations.push(...auxTx.operations);
-    }
-    existing.fees += auxTx.fees;
-}
-function groupAndMapTransactions(transactions, tokenTransfers, delegations, stakings) {
+function groupAndMapTransactions(transactions, tokenTransfers, delegations) {
     const groups = groupTransactionsByHash(transactions);
     const txIdToHash = new Map();
     for (const tx of transactions){
@@ -1450,11 +1202,19 @@ function groupAndMapTransactions(transactions, tokenTransfers, delegations, stak
     }
     for (const delegation of delegations){
         const delegationTx = buildBlockTransactionFromDelegation(delegation);
-        if (delegationTx) mergeAuxiliaryTx(blockTxByHash, delegationTx);
-    }
-    for (const staking of stakings){
-        const stakingTx = buildBlockTransactionFromStaking(staking);
-        if (stakingTx) mergeAuxiliaryTx(blockTxByHash, stakingTx);
+        if (!delegationTx) continue;
+        const existing = blockTxByHash.get(delegationTx.hash);
+        if (!existing) {
+            blockTxByHash.set(delegationTx.hash, delegationTx);
+            continue;
+        }
+        if (delegationTx.failed) {
+            existing.failed = true;
+            existing.operations = [];
+        } else if (!existing.failed && delegationTx.operations.length > 0) {
+            existing.operations.push(...delegationTx.operations);
+        }
+        existing.fees += delegationTx.fees;
     }
     const standaloneByKey = new Map();
     for (const transfer of tokenTransfers){
@@ -1472,7 +1232,7 @@ function groupAndMapTransactions(transactions, tokenTransfers, delegations, stak
  * Returns the full block at the given Tezos level: metadata + all transactions
  * with their XTZ and FA token balance changes.
  *
- * - Fetches block metadata, native transactions, delegations, FA token transfers, and staking operations in parallel.
+ * - Fetches block metadata, native transactions, delegations, and FA token transfers in parallel.
  * - Also fetches the predecessor block in parallel to populate `BlockInfo.parent`.
  * - Groups operations by hash, aggregates fees, and determines the fee payer.
  * - Appends FA token transfer operations to the owning BlockTransaction when a
@@ -1481,17 +1241,16 @@ function groupAndMapTransactions(transactions, tokenTransfers, delegations, stak
     if (!Number.isSafeInteger(height) || height <= 0) {
         throw new Error(`getBlock: height must be a positive integer, got ${height}`);
     }
-    const [block, parentBlock, transactions, tokenTransfers, delegations, stakings] = await Promise.all([
+    const [block, parentBlock, transactions, tokenTransfers, delegations] = await Promise.all([
         tzkt.getBlockByLevel(height),
         tzkt.getBlockByLevel(height - 1),
         fetchBlockTransactions(height),
         fetchBlockTokenTransfers(height),
-        fetchBlockDelegations(height),
-        fetchBlockStaking(height)
+        fetchBlockDelegations(height)
     ]);
     return {
         info: mapBlockInfo(block, parentBlock),
-        transactions: groupAndMapTransactions(transactions, tokenTransfers, delegations, stakings)
+        transactions: groupAndMapTransactions(transactions, tokenTransfers, delegations)
     };
 } //# sourceMappingURL=getBlock.js.map
 
@@ -1550,203 +1309,26 @@ function isAPIStakingType(op) {
 
 
 
-
-function parseCursor(token) {
-    if (!token) return undefined;
+/** Cursor: native + token transfer last ids. Legacy: JSON number = native only. */ function parseCursor(token) {
+    if (!token) return {};
     try {
         const parsed = JSON.parse(token);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            const o = parsed;
-            if (typeof o.lastLevel === "number" && Number.isFinite(o.lastLevel)) {
-                const cursor = {
-                    lastLevel: o.lastLevel
-                };
-                if (typeof o.nativeLastId === "number" && Number.isFinite(o.nativeLastId)) {
-                    cursor.nativeLastId = o.nativeLastId;
-                }
-                if (typeof o.tokenLastId === "number" && Number.isFinite(o.tokenLastId)) {
-                    cursor.tokenLastId = o.tokenLastId;
-                }
-                return cursor;
-            }
-        }
-    } catch  {
-    // ignore invalid cursor
-    }
-    return undefined;
-}
-function minLevel(items) {
-    if (items.length === 0) return undefined;
-    return Math.min(...items.map((i)=>i.level));
-}
-function maxLevel(items) {
-    if (items.length === 0) return undefined;
-    return Math.max(...items.map((i)=>i.level));
-}
-/** When the API returned a full page, the trailing block level may be incomplete — drop it. */ function trimPartialLastLevel(items, full) {
-    if (!full || items.length === 0) return {
-        trimmed: items
-    };
-    const last = items.at(-1);
-    if (!last) return {
-        trimmed: items
-    };
-    const lastLevel = last.level;
-    const filtered = items.filter((op)=>op.level !== lastLevel);
-    if (filtered.length === 0) {
-        (0,logs_lib_es/* .log */.Rm)("coin:tezos", "listOperations: full page single level — keeping all rows", {
-            lastLevel,
-            count: items.length
-        });
-        return {
-            trimmed: items,
-            intraLevelLastId: last.id
-        };
-    }
-    return {
-        trimmed: filtered
-    };
-}
-function buildNativeOptions(sort, cursor, minHeight) {
-    if (!cursor) {
-        return {
-            sort,
-            "level.ge": minHeight
-        };
-    }
-    const { lastLevel, nativeLastId } = cursor;
-    if (sort === "Descending") {
-        if (nativeLastId !== undefined) {
-            return {
-                sort,
-                "level.ge": minHeight,
-                "level.lt": lastLevel + 1,
-                lastId: nativeLastId
-            };
-        }
-        return {
-            sort,
-            "level.ge": minHeight,
-            "level.lt": lastLevel
-        };
-    }
-    if (nativeLastId !== undefined) {
-        return {
-            sort,
-            "level.ge": Math.max(minHeight, lastLevel),
-            lastId: nativeLastId
+        if (typeof parsed === "number") return {
+            nativeLastId: parsed
         };
-    }
-    return {
-        sort,
-        "level.ge": Math.max(minHeight, lastLevel + 1)
-    };
-}
-function buildTokenOptions(sort, cursor, minHeight) {
-    if (!cursor) {
-        return {
-            sort,
-            "level.ge": minHeight
-        };
-    }
-    const { lastLevel, tokenLastId } = cursor;
-    if (sort === "Descending") {
-        if (tokenLastId !== undefined) {
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const output = parsed;
+            const nativeLastId = typeof output.nativeLastId === "number" ? output.nativeLastId : undefined;
+            const tokenLastId = typeof output.tokenLastId === "number" ? output.tokenLastId : undefined;
             return {
-                sort,
-                "level.ge": minHeight,
-                "level.lt": lastLevel + 1,
-                "id.lt": tokenLastId
+                nativeLastId,
+                tokenLastId
             };
         }
-        return {
-            sort,
-            "level.ge": minHeight,
-            "level.lt": lastLevel
-        };
-    }
-    if (tokenLastId !== undefined) {
-        return {
-            sort,
-            "level.ge": Math.max(minHeight, lastLevel),
-            "id.gt": tokenLastId
-        };
-    }
-    return {
-        sort,
-        "level.ge": Math.max(minHeight, lastLevel + 1)
-    };
-}
-function computeBoundary(nativeTrim, tokenTrim, sort) {
-    if (sort === "Descending") {
-        const mn = minLevel(nativeTrim);
-        const mt = minLevel(tokenTrim);
-        if (mn === undefined && mt === undefined) return undefined;
-        if (mn === undefined) return mt;
-        if (mt === undefined) return mn;
-        return Math.max(mn, mt);
-    }
-    const xn = maxLevel(nativeTrim);
-    const xt = maxLevel(tokenTrim);
-    if (xn === undefined && xt === undefined) return undefined;
-    if (xn === undefined) return xt;
-    if (xt === undefined) return xn;
-    return Math.min(xn, xt);
-}
-function alignToBoundary(items, boundary, sort) {
-    if (sort === "Descending") {
-        return items.filter((op)=>op.level >= boundary);
-    }
-    return items.filter((op)=>op.level <= boundary);
-}
-function clampPage(raw, limit) {
-    if (limit === undefined) {
-        return {
-            sliced: raw,
-            full: false
-        };
-    }
-    return {
-        sliced: raw.slice(0, limit),
-        full: raw.length >= limit
-    };
-}
-function buildParentMap(ops) {
-    const parentMap = new Map();
-    for (const op of ops){
-        if (isAPITransactionType(op) && op.id !== null) {
-            parentMap.set(op.id, op);
-        }
-    }
-    return parentMap;
-}
-function keepNativeOp(op, address) {
-    if (!(isAPITransactionType(op) || isAPIDelegationType(op) || isAPIRevealType(op) || isAPIStakingType(op))) {
-        return false;
-    }
-    if (op.status !== "applied" && isAPITransactionType(op)) {
-        const isIn = op.target?.address === address;
-        if (isIn) {
-            return false;
-        }
+    } catch  {
+    // ignore invalid cursor
     }
-    return true;
-}
-function convertNativeOps(ops, address, stakingBlockHashes) {
-    return ops.filter((op)=>keepNativeOp(op, address)).map((op)=>convertOperation(address, op, stakingBlockHashes));
-}
-function convertTokenOps(transfers, parentMap, address) {
-    return transfers.map((transfer)=>convertTokenOperation(address, transfer, transfer.transactionId ? parentMap.get(transfer.transactionId) : undefined));
-}
-function computeNextToken(boundary, nativeFull, tokenFull, hasResults, nativeIntraLastId, tokenIntraLastId) {
-    const shouldEmitNext = boundary !== undefined && (nativeFull || tokenFull) && hasResults;
-    if (!shouldEmitNext) return "";
-    const payload = {
-        lastLevel: boundary
-    };
-    if (nativeIntraLastId !== undefined) payload.nativeLastId = nativeIntraLastId;
-    if (tokenIntraLastId !== undefined) payload.tokenLastId = tokenIntraLastId;
-    return JSON.stringify(payload);
+    return {};
 }
 /**
  * Returns list of "Transfer", "Delegate" and "Undelegate" Operations associated to an account.
@@ -1760,31 +1342,53 @@ function computeNextToken(boundary, nativeFull, tokenFull, hasResults, nativeInt
  * @param token a token to be used for pagination
  * @returns a list of operations is descending (newest first) order and a token to be used for pagination
  */ async function listOperations(address, { token, limit, sort, minHeight }) {
-    const cursor = parseCursor(token);
+    const { nativeLastId, tokenLastId } = parseCursor(token);
     const nativeOptions = {
         limit,
-        ...buildNativeOptions(sort, cursor, minHeight)
+        sort,
+        "level.ge": minHeight,
+        ...nativeLastId ? {
+            lastId: nativeLastId
+        } : {}
     };
     const tokenOptions = {
         limit,
-        ...buildTokenOptions(sort, cursor, minHeight)
+        sort,
+        "level.ge": minHeight,
+        ...tokenLastId ? {
+            lastId: tokenLastId
+        } : {}
     };
-    const [nativeOpsRaw, tokenTransfersRaw] = await Promise.all([
+    const [nativeOps, tokenTransfers] = await Promise.all([
         tzkt.getAccountOperations(address, nativeOptions),
         tzkt.getAccountTokenTransfers(address, tokenOptions)
     ]);
-    const nativePage = clampPage(nativeOpsRaw, limit);
-    const tokenPage = clampPage(tokenTransfersRaw, limit);
-    const nativeTrimmed = trimPartialLastLevel(nativePage.sliced, nativePage.full);
-    const tokenTrimmed = trimPartialLastLevel(tokenPage.sliced, tokenPage.full);
-    const boundary = computeBoundary(nativeTrimmed.trimmed, tokenTrimmed.trimmed, sort);
-    const nativeAligned = boundary === undefined ? nativeTrimmed.trimmed : alignToBoundary(nativeTrimmed.trimmed, boundary, sort);
-    const tokenAligned = boundary === undefined ? tokenTrimmed.trimmed : alignToBoundary(tokenTrimmed.trimmed, boundary, sort);
-    const stakingBlockHashes = await fetchMissingStakingBlockHashes(nativeAligned);
-    const parentMap = buildParentMap(nativeAligned);
-    const nextToken = computeNextToken(boundary, nativePage.full, tokenPage.full, nativeAligned.length > 0 || tokenAligned.length > 0, nativeTrimmed.intraLevelLastId, tokenTrimmed.intraLevelLastId);
-    const filteredNativeOps = convertNativeOps(nativeAligned, address, stakingBlockHashes);
-    const tokenConverted = convertTokenOps(tokenAligned, parentMap, address);
+    // Apply limit after fetching since tzkt API might not respect the limit parameter
+    const limitedNativeOps = limit ? nativeOps.slice(0, limit) : nativeOps;
+    const limitedTokenTransfers = limit ? tokenTransfers.slice(0, limit) : tokenTransfers;
+    const parentMap = new Map();
+    for (const op of nativeOps){
+        if (isAPITransactionType(op) && op.id !== null) {
+            parentMap.set(op.id, op);
+        }
+    }
+    const lastNativeOp = limitedNativeOps.at(-1);
+    const lastTokenOp = limitedTokenTransfers.at(-1);
+    const nextToken = lastNativeOp || lastTokenOp ? JSON.stringify({
+        nativeLastId: lastNativeOp?.id,
+        tokenLastId: lastTokenOp?.id
+    }) : "";
+    const filteredNativeOps = limitedNativeOps.filter((op)=>isAPITransactionType(op) || isAPIDelegationType(op) || isAPIRevealType(op)).filter((op)=>{
+        const hasFailed = op.status !== "applied";
+        if (hasFailed && isAPITransactionType(op)) {
+            const isIn = op.target?.address === address;
+            if (isIn) {
+                return false;
+            }
+        }
+        return true;
+    }).map((op)=>convertOperation(address, op)).flat();
+    const tokenConverted = limitedTokenTransfers.map((transfer)=>convertTokenOperation(address, transfer, transfer.transactionId ? parentMap.get(transfer.transactionId) : undefined));
     const sortedOperations = [
         ...filteredNativeOps,
         ...tokenConverted
@@ -1795,110 +1399,63 @@ function computeNextToken(boundary, nativeFull, tokenFull, hasResults, nativeInt
     ];
 }
 /**
- * TzKT omits `block` on staking ops returned by /accounts/{addr}/operations.
- * Returns a level → block-hash map covering exactly those ops, so the caller
- * can populate `tx.block.hash` without mutating the API response. Network
- * failures are swallowed: callers fall back to `""` for levels not in the map.
- */ async function fetchMissingStakingBlockHashes(ops) {
-    const missingLevels = new Set();
-    for (const op of ops){
-        if (isAPIStakingType(op) && !op.block) missingLevels.add(op.level);
-    }
-    if (missingLevels.size === 0) return new Map();
-    try {
-        return await tzkt.getBlockHashesByLevels([
-            ...missingLevels
-        ]);
-    } catch (err) {
-        (0,logs_lib_es/* .log */.Rm)("coin:tezos", "fetchMissingStakingBlockHashes: skipped on fetch error", {
-            reason: String(err)
-        });
-        return new Map();
-    }
-}
-function resolveBlockHash(operation, stakingBlockHashes) {
-    const fromOp = typeof operation.block === "string" ? operation.block : operation.block?.hash;
-    return fromOp ?? stakingBlockHashes.get(operation.level) ?? "";
-}
-function resolveTargetAddress(operation) {
-    if (isAPITransactionType(operation)) return operation.target?.address;
-    if (isAPIDelegationType(operation)) {
-        return operation.newDelegate?.address || operation.prevDelegate?.address;
-    }
-    if (isAPIStakingType(operation)) return operation.baker?.address;
-    return undefined;
-}
-// finalize_unstake's protocol sender is the gas payer (anyone may call it),
-// not the staker; map staking ops from the staker's perspective so the op
-// stays visible in their wallet.
-function resolveStakingAddresses(op) {
-    const stakerAddr = op.staker?.address ?? op.sender?.address;
-    const bakerAddr = op.baker?.address;
-    const stakerArr = stakerAddr ? [
-        stakerAddr
-    ] : [];
-    const bakerArr = bakerAddr ? [
-        bakerAddr
-    ] : [];
-    if (op.action === "finalize") return {
-        senders: bakerArr,
-        recipients: stakerArr
-    };
-    return {
-        senders: stakerArr,
-        recipients: bakerArr
-    };
-}
-function resolveNormalizedType(operation, address, targetAddress, amount) {
-    if (isAPIDelegationType(operation)) {
-        return operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
-    }
-    if (isAPIStakingType(operation)) return STAKING_ACTION_TO_OP_TYPE[operation.action];
-    if (isAPIRevealType(operation)) return "REVEAL";
-    if (!isAPITransactionType(operation)) {
-        (0,logs_lib_es/* .log */.Rm)("coin:tezos", "(logic/operations): Unknown operation type, defaulting to OUT");
-        return "OUT";
-    }
-    const isOut = operation.sender?.address === address;
-    const isIn = targetAddress === address;
-    if (isOut && isIn || amount === 0n) return "FEES";
-    if (isOut) return "OUT";
-    if (isIn) return "IN";
-    return "OUT";
-}
-function getLedgerOpType(operation, normalizedType) {
+ * Helper function to get the ledgerOpType for an operation
+ */ function getLedgerOpType(operation, normalizedType) {
     if (isAPIDelegationType(operation)) {
         return operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
     } else if (isAPIRevealType(operation)) {
         return "REVEAL";
-    } else if (isAPIStakingType(operation)) {
-        return STAKING_ACTION_TO_OP_TYPE[operation.action];
     } else if (normalizedType === "FEES") {
         return "FEES";
     }
     return undefined;
 }
-function convertOperation(address, operation, stakingBlockHashes) {
+function convertOperation(address, operation) {
     const { hash, sender, id } = operation;
     // For transactions, the initiator (if present) is the fee payer (internal/sub-operations triggered by contracts).
-    // Otherwise, the sender is the fee payer. For delegation/reveal/staking there is no initiator; sender is the fee payer.
+    // Otherwise, the sender is the fee payer. For delegation/reveal there is no initiator; sender is the fee payer.
     const feesPayer = isAPITransactionType(operation) ? operation.initiator?.address ?? sender?.address : sender?.address;
-    const targetAddress = resolveTargetAddress(operation);
-    // reveal has no target by design; staking resolves senders/recipients separately.
-    if (!targetAddress && !isAPIRevealType(operation) && !isAPIStakingType(operation)) {
+    let targetAddress = undefined;
+    if (isAPITransactionType(operation)) {
+        targetAddress = operation?.target?.address;
+    } else if (isAPIDelegationType(operation)) {
+        // delegate and undelegate has the type, but hold the address in different fields
+        targetAddress = operation?.newDelegate?.address || operation?.prevDelegate?.address;
+    }
+    const recipients = targetAddress ? [
+        targetAddress
+    ] : [];
+    if (!targetAddress) {
         (0,logs_lib_es/* .log */.Rm)("coin:tezos", "(logic/operations): No target address found for operation", operation);
     }
-    const { senders, recipients } = isAPIStakingType(operation) ? resolveStakingAddresses(operation) : {
-        senders: sender?.address ? [
-            sender.address
-        ] : [],
-        recipients: targetAddress ? [
-            targetAddress
-        ] : []
-    };
+    const senders = sender?.address ? [
+        sender.address
+    ] : [];
     const amount = isAPIRevealType(operation) || isAPIDelegationType(operation) ? 0n : BigInt(operation.amount);
     const fee = BigInt(operation.storageFee ?? 0) + BigInt(operation.bakerFee ?? 0) + BigInt(operation.allocationFee ?? 0);
-    const normalizedType = resolveNormalizedType(operation, address, targetAddress, amount);
+    // Determine operation type inline
+    let normalizedType;
+    if (isAPIDelegationType(operation)) {
+        normalizedType = operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
+    } else if (isAPITransactionType(operation)) {
+        const isOut = sender?.address === address;
+        const isIn = targetAddress === address;
+        if (isOut && isIn || amount === 0n) {
+            normalizedType = "FEES";
+        } else if (isOut) {
+            normalizedType = "OUT";
+        } else if (isIn) {
+            normalizedType = "IN";
+        } else {
+            normalizedType = "OUT"; // fallback
+        }
+    } else if (isAPIRevealType(operation)) {
+        normalizedType = "REVEAL";
+    } else {
+        // fallback for unknown types
+        (0,logs_lib_es/* .log */.Rm)("coin:tezos", "(logic/operations): Unknown operation type, defaulting to OUT");
+        normalizedType = "OUT";
+    }
     // Tezos uses "applied" for every success operation (something else=failed )
     const hasFailed = operation.status && operation.status !== "applied";
     return {
@@ -1915,7 +1472,7 @@ function convertOperation(address, operation, stakingBlockHashes) {
                 feesPayer
             } : {},
             block: {
-                hash: resolveBlockHash(operation, stakingBlockHashes),
+                hash: operation.block,
                 height: operation.level,
                 time: new Date(operation.timestamp)
             },
@@ -1973,7 +1530,7 @@ function convertTokenOperation(address, transfer, parent) {
                 feesPayer
             } : {},
             block: {
-                hash: transfer.block ?? parent?.block ?? "",
+                hash: parent?.block ?? "",
                 height: transfer.level,
                 time: new Date(transfer.timestamp)
             },
@@ -2006,25 +1563,6 @@ function convertTokenOperation(address, transfer, parent) {
 
 
 
-function resolveValidationOperationMode(intent) {
-    switch(intent.type){
-        case "stake":
-        case "unstake":
-        case "finalize_unstake":
-            return intent.type;
-        default:
-            return resolveTezosOperationMode(intent.type, intent.asset);
-    }
-}
-function validateStrictlyPositiveAmount(amount) {
-    if (amount === 0n) {
-        return new lib_es/* .AmountRequired */.qA();
-    }
-    if (amount < 0n) {
-        return new lib_es/* .NotEnoughBalance */.cC();
-    }
-    return undefined;
-}
 /**
  * Validates basic recipient and amount for send transactions
  */ function validateBasicSendParams(intent) {
@@ -2053,38 +1591,14 @@ function validateStrictlyPositiveAmount(amount) {
  */ function validateTransactionConstraints(intent, senderInfo) {
     const errors = {};
     // send max not allowed on delegated accounts (must undelegate acc first); native XTZ only
-    if (intent.type === "send" && intent.useAllAmount && resolveValidationOperationMode(intent) === "send" && senderInfo.delegate?.address) {
+    if (intent.type === "send" && intent.useAllAmount && resolveTezosOperationMode(intent.type, intent.asset) === "send" && senderInfo.delegate?.address) {
         errors.amount = new lib_es/* .RecommendUndelegation */.Ql();
     }
+    // stake requires non-zero balance
     if (intent.type === "stake") {
-        if (!senderInfo.delegate?.address) {
-            errors.amount = new types_errors/* .MustDelegateBeforeStaking */.$V();
-            return errors;
-        }
-        const amountError = validateStrictlyPositiveAmount(intent.amount);
-        if (amountError) {
-            errors.amount = amountError;
-        }
-    }
-    if (intent.type === "unstake") {
-        const stakedBalance = BigInt(senderInfo.stakedBalance ?? 0);
-        if (stakedBalance <= 0n) {
-            errors.amount = new lib_es/* .NotEnoughBalance */.cC();
-            return errors;
-        }
-        const amountError = validateStrictlyPositiveAmount(intent.amount);
-        if (amountError) {
-            errors.amount = amountError;
-            return errors;
-        }
-        if (intent.amount > stakedBalance) {
-            errors.amount = new lib_es/* .NotEnoughBalance */.cC();
-        }
-    }
-    if (intent.type === "finalize_unstake") {
-        const unstakedFinalizable = BigInt(senderInfo.unstakedFinalizable ?? 0);
-        if (unstakedFinalizable <= 0n) {
-            errors.amount = new lib_es/* .NotEnoughBalance */.cC();
+        const balance = BigInt(senderInfo.balance || "0");
+        if (balance === 0n) {
+            errors.amount = new lib_es/* .NotEnoughBalanceToDelegate */.s$();
         }
     }
     return errors;
@@ -2099,12 +1613,8 @@ function validateStrictlyPositiveAmount(amount) {
         } else {
             errors.amount = new lib_es/* .NotEnoughBalance */.cC();
         }
-    } else if (taquitoError.endsWith("staking.too_much_unstaked")) {
-        errors.amount = new lib_es/* .NotEnoughBalance */.cC();
-    } else if (taquitoError.endsWith("contract.must_be_delegated_to_stake")) {
-        errors.amount = new types_errors/* .MustDelegateBeforeStaking */.$V();
     } else if (taquitoError.endsWith("delegate.unchanged") && intentType === "stake") {
-        errors.recipient = new types_errors/* .InvalidAddressBecauseAlreadyDelegated */.f1();
+        errors.recipient = new types_errors/* .InvalidAddressBecauseAlreadyDelegated */.f();
     } else if (taquitoError.includes("empty_implicit_contract")) {
         errors.amount = new lib_es/* .NotEnoughBalanceToDelegate */.s$();
     } else if (taquitoError.includes("script_rejected")) {
@@ -2127,19 +1637,7 @@ function calculateNativeSendMaxAmountForUser(balance, estimatedFees, estimatedAm
  * Calculates final amounts based on transaction type
  * @param tokenBalanceForSendMax When set, FA2 send-max: full token amount; fees are paid in XTZ only
  */ function calculateAmounts(intent, senderInfo, estimatedFees, estimatedAmount, tokenBalanceForSendMax) {
-    if (intent.type === "stake") {
-        return {
-            amount: intent.amount,
-            totalSpent: intent.amount + estimatedFees
-        };
-    }
-    if (intent.type === "unstake") {
-        return {
-            amount: intent.amount,
-            totalSpent: estimatedFees
-        };
-    }
-    if (intent.type === "finalize_unstake") {
+    if (intent.type === "stake" || intent.type === "unstake") {
         return {
             amount: 0n,
             totalSpent: estimatedFees
@@ -2178,7 +1676,7 @@ async function estimateFeesForIntent(intent, senderInfo) {
             errors: {}
         };
     }
-    const tezosMode = resolveValidationOperationMode(intent);
+    const tezosMode = resolveTezosOperationMode(intent.type, intent.asset);
     const tokenInfo = tezosMode === "send_token" ? parseTezosTokenAsset(intent.asset) : undefined;
     const estimation = await estimateFees({
         account: {
@@ -2190,9 +1688,7 @@ async function estimateFeesForIntent(intent, senderInfo) {
         transaction: {
             mode: tezosMode,
             recipient: intent.recipient,
-            // finalize_unstake is a parameter-less operation; normalize amount to 0n so
-            // fee estimation and the returned validation amount stay consistent.
-            amount: intent.type === "finalize_unstake" ? 0n : intent.amount,
+            amount: intent.amount,
             useAllAmount: !!intent.useAllAmount,
             ...tokenInfo && {
                 contractAddress: tokenInfo.contractAddress,
@@ -2286,6 +1782,30 @@ async function validateIntent(intent) {
     };
 } //# sourceMappingURL=validateIntent.js.map
 
+;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/logic/getStakes.js
+
+async function getStakes(address, _cursor) {
+    // tezos exposes a single staking position via delegation when a delegate is set
+    const accountInfo = await tzkt.getAccountByAddress(address);
+    if (accountInfo.type !== "user" || !accountInfo.delegate?.address) return {
+        items: []
+    };
+    return {
+        items: [
+            {
+                uid: address,
+                address,
+                delegate: accountInfo.delegate.address,
+                state: "active",
+                asset: {
+                    type: "native"
+                },
+                amount: BigInt(accountInfo.balance ?? 0)
+            }
+        ]
+    };
+} //# sourceMappingURL=getStakes.js.map
+
 ;// CONCATENATED MODULE: ../../libs/coin-modules/coin-tezos/lib-es/logic/index.js
 
 
@@ -2327,18 +1847,6 @@ function createApi(config) {
             }
         }));
     return {
-        computeIntentType: (transaction)=>{
-            switch(transaction.mode){
-                case "delegate":
-                case "undelegate":
-                case "stake":
-                case "unstake":
-                case "finalize_unstake":
-                    return transaction.mode;
-                default:
-                    return "send";
-            }
-        },
         broadcast: broadcast,
         combine: combine,
         craftTransaction: craft,
@@ -2373,8 +1881,7 @@ function isTezosTransactionType(type) {
         "delegate",
         "undelegate",
         "stake",
-        "unstake",
-        "finalize_unstake"
+        "unstake"
     ].includes(type);
 }
 async function craft(transactionIntent, customFees) {
@@ -2389,10 +1896,10 @@ async function craft(transactionIntent, customFees) {
         storageLimit: estimation.parameters?.storageLimit?.toString()
     };
     const tezosMode = resolveTezosOperationMode(transactionIntent.type, transactionIntent.asset);
-    const mappedType = tezosMode === "send_token" ? "send_token" : transactionIntent.type;
+    const mappedType = tezosMode === "send_token" ? "send_token" : mapIntentTypeToTezosMode(transactionIntent.type);
     const tokenCraftInfo = tezosMode === "send_token" ? parseTezosTokenAsset(transactionIntent.asset) : undefined;
     // Guard: send max is incompatible with delegated accounts (native XTZ only)
-    let amountToUse = tezosMode === "finalize_unstake" ? 0n : transactionIntent.amount;
+    let amountToUse = transactionIntent.amount;
     if (tezosMode === "send" && transactionIntent.useAllAmount) {
         const senderInfo = await tzkt.getAccountByAddress(transactionIntent.sender);
         if (senderInfo.type === "user" && senderInfo.delegate?.address) {
@@ -2512,7 +2019,7 @@ async function api_estimate(transactionIntent) {
     const transaction = {
         mode: tezosModeForEstimate,
         recipient: transactionIntent.recipient,
-        amount: tezosModeForEstimate === "finalize_unstake" ? 0n : transactionIntent.amount,
+        amount: transactionIntent.amount,
         useAllAmount: !!transactionIntent.useAllAmount,
         ...tokenEstimationInfo && {
             contractAddress: tokenEstimationInfo.contractAddress,