@keplr-wallet/background 0.12.312 → 0.13.0

package/build/tx-executor/service.js

@@ -0,0 +1,715 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundTxExecutorService = void 0;
+const chains_1 = require("../chains");
+const router_1 = require("@keplr-wallet/router");
+const types_1 = require("./types");
+const mobx_1 = require("mobx");
+const types_2 = require("@keplr-wallet/types");
+const transactions_1 = require("@ethersproject/transactions");
+const cosmos_1 = require("@keplr-wallet/cosmos");
+const tx_1 = require("@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx");
+const cosmos_2 = require("./utils/cosmos");
+const evm_1 = require("./utils/evm");
+class BackgroundTxExecutorService {
+    constructor(kvStore, chainsService, keyRingCosmosService, keyRingEthereumService, backgroundTxService, backgroundTxEthereumService, analyticsService, recentSendHistoryService, subscriber) {
+        this.kvStore = kvStore;
+        this.chainsService = chainsService;
+        this.keyRingCosmosService = keyRingCosmosService;
+        this.keyRingEthereumService = keyRingEthereumService;
+        this.backgroundTxService = backgroundTxService;
+        this.backgroundTxEthereumService = backgroundTxEthereumService;
+        this.analyticsService = analyticsService;
+        this.recentSendHistoryService = recentSendHistoryService;
+        this.subscriber = subscriber;
+        this.recentTxExecutionSeq = 0;
+        // Key: id (sequence, it should be increased by 1 for each)
+        this.recentTxExecutionMap = new Map();
+        (0, mobx_1.makeObservable)(this);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recentTxExecutionSeqSaved = yield this.kvStore.get("recentTxExecutionSeq");
+            if (recentTxExecutionSeqSaved) {
+                (0, mobx_1.runInAction)(() => {
+                    this.recentTxExecutionSeq = recentTxExecutionSeqSaved;
+                });
+            }
+            (0, mobx_1.autorun)(() => {
+                const js = (0, mobx_1.toJS)(this.recentTxExecutionSeq);
+                this.kvStore.set("recentTxExecutionSeq", js);
+            });
+            const recentTxExecutionMapSaved = yield this.kvStore.get("recentSerializedTxExecutionMap");
+            if (recentTxExecutionMapSaved) {
+                (0, mobx_1.runInAction)(() => {
+                    const entries = Object.entries(recentTxExecutionMapSaved);
+                    const sorted = entries
+                        .map(([key, value]) => [key, JSON.parse(value)])
+                        .sort(([, a], [, b]) => parseInt(a.id) - parseInt(b.id));
+                    for (const [key, execution] of sorted) {
+                        this.recentTxExecutionMap.set(key, execution);
+                    }
+                    this.cleanupOldExecutions();
+                });
+            }
+            (0, mobx_1.autorun)(() => {
+                const js = (0, mobx_1.toJS)(this.recentTxExecutionMap);
+                const serialized = {};
+                for (const [key, value] of js) {
+                    // only persist executions that are BLOCKED
+                    if (value.status === types_1.TxExecutionStatus.BLOCKED) {
+                        serialized[key] = JSON.stringify(value);
+                    }
+                }
+                this.kvStore
+                    .set("recentSerializedTxExecutionMap", serialized)
+                    .catch((e) => {
+                    console.error("[TxExecutor] kvStore save failed:", e);
+                });
+            });
+            this.subscriber.subscribe((event) => this.handleTxExecutionEvent(event));
+        });
+    }
+    handleTxExecutionEvent(event) {
+        if (event.type === "remove") {
+            this.removeTxExecution(event.executionId);
+            return;
+        }
+        const { executionId, executableChainIds } = event;
+        const execution = this.getTxExecution(executionId);
+        if (!execution) {
+            return;
+        }
+        const newExecutableChainIds = executableChainIds.filter((chainId) => !execution.executableChainIds.includes(chainId));
+        if (newExecutableChainIds.length === 0) {
+            return;
+        }
+        // update the executable chain ids
+        execution.executableChainIds = Array.from(new Set([...execution.executableChainIds, ...newExecutableChainIds]));
+        // if there is a pending tx that is executable, force display the swap v2 history
+        if (execution.type === types_1.TxExecutionType.SWAP_V2 &&
+            execution.historyId != null) {
+            const hasExecutableTx = execution.txs.some((tx) => (tx.status === types_1.BackgroundTxStatus.PENDING ||
+                tx.status === types_1.BackgroundTxStatus.BLOCKED) &&
+                execution.executableChainIds.includes(tx.chainId));
+            if (hasExecutableTx) {
+                this.recentSendHistoryService.showSwapV2History(execution.historyId);
+            }
+        }
+    }
+    recordAndExecuteTxs(env, vaultId, type, txs, executableChainIds, historyData, historyTxIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!env.isInternalMsg) {
+                throw new router_1.KeplrError("direct-tx-executor", 101, "Not internal message");
+            }
+            const keyInfo = this.keyRingCosmosService.keyRingService.getKeyInfo(vaultId);
+            if (!keyInfo) {
+                throw new router_1.KeplrError("direct-tx-executor", 120, "Key info not found");
+            }
+            // If any of the transactions are not executable or the key is hardware wallet,
+            // auto sign is disabled.
+            const preventAutoSign = txs.some((tx) => !executableChainIds.includes(tx.chainId)) ||
+                keyInfo.type === "ledger" ||
+                keyInfo.type === "keystone";
+            /**
+             * If preventAutoSign is true, at least one executable transaction must already be signed.
+             * For example, in an EVM bundle (like ERC20 approve + swap) where simulation is not possible,
+             * the UI might execute 'approve' (tx[0]) first and set its txHash, then sign the swap (tx[1]).
+             * Both tx[0] and tx[1] are executable, but tx[0] has already been executed and doesn't need to be signed again.
+             * So, ensure that at least one executable tx is already signed before proceeding.
+             */
+            if (preventAutoSign) {
+                const executableTxs = txs.filter((tx) => executableChainIds.includes(tx.chainId));
+                if (executableTxs.length === 0) {
+                    throw new router_1.KeplrError("direct-tx-executor", 122, "No executable txs");
+                }
+                if (executableTxs.every((tx) => tx.signedTx == null)) {
+                    throw new router_1.KeplrError("direct-tx-executor", 123, "No signed txs found with preventAutoSign");
+                }
+            }
+            const id = (0, mobx_1.runInAction)(() => {
+                return (this.recentTxExecutionSeq++).toString();
+            });
+            const execution = Object.assign({ id, status: types_1.TxExecutionStatus.PENDING, vaultId: vaultId, txs, txIndex: -1, executableChainIds: executableChainIds, timestamp: Date.now(), type,
+                preventAutoSign,
+                historyTxIndex }, (type !== types_1.TxExecutionType.UNDEFINED ? { historyData } : {}));
+            (0, mobx_1.runInAction)(() => {
+                this.recentTxExecutionMap.set(id, execution);
+            });
+            return yield this.executeTxs(id);
+        });
+    }
+    /**
+     * Execute blocked transactions by execution id and transaction index
+     */
+    resumeTx(env, id, txIndex, signedTx, ibcSwapData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!env.isInternalMsg) {
+                throw new router_1.KeplrError("direct-tx-executor", 101, "Not internal message");
+            }
+            return yield this.executeTxs(id, {
+                txIndex,
+                signedTx,
+                ibcSwapData,
+            });
+        });
+    }
+    executeTxs(id, options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const execution = this.getTxExecution(id);
+            if (!execution) {
+                throw new router_1.KeplrError("direct-tx-executor", 121, "Execution not found");
+            }
+            if (execution.status === types_1.TxExecutionStatus.PROCESSING) {
+                throw new router_1.KeplrError("direct-tx-executor", 130, "Execution is already processing");
+            }
+            // Only pending or blocked executions can be executed
+            const needExecute = execution.status === types_1.TxExecutionStatus.PENDING ||
+                execution.status === types_1.TxExecutionStatus.BLOCKED;
+            if (!needExecute) {
+                return {
+                    status: execution.status,
+                };
+            }
+            const keyInfo = this.keyRingCosmosService.keyRingService.getKeyInfo(execution.vaultId);
+            if (!keyInfo) {
+                throw new router_1.KeplrError("direct-tx-executor", 120, "Key info not found");
+            }
+            const executionStartIndex = Math.min((_a = options === null || options === void 0 ? void 0 : options.txIndex) !== null && _a !== void 0 ? _a : (execution.txIndex < 0 ? 0 : execution.txIndex), execution.txs.length - 1);
+            (0, mobx_1.runInAction)(() => {
+                execution.status = types_1.TxExecutionStatus.PROCESSING;
+            });
+            for (let i = executionStartIndex; i < execution.txs.length; i++) {
+                const currentTx = execution.txs[i];
+                const providedSignedTx = (options === null || options === void 0 ? void 0 : options.txIndex) != null && i === options.txIndex
+                    ? options.signedTx
+                    : undefined;
+                const result = yield this.executePendingTx(execution.vaultId, currentTx, execution.executableChainIds, (_b = execution.preventAutoSign) !== null && _b !== void 0 ? _b : false, providedSignedTx);
+                // update the tx status and related fields
+                (0, mobx_1.runInAction)(() => {
+                    execution.txIndex = i;
+                    currentTx.status = result.status;
+                    if (result.txHash != null) {
+                        currentTx.txHash = result.txHash;
+                    }
+                    if (result.error != null) {
+                        currentTx.error = result.error;
+                    }
+                    currentTx.signedTx = undefined;
+                });
+                switch (result.status) {
+                    case types_1.BackgroundTxStatus.CONFIRMED: {
+                        if (providedSignedTx) {
+                            // 외부에서 제공된 signed tx로 실행한 경우 (= multi tx 재개 케이스)
+                            //
+                            // 이번에 처리된 트랜잭션이 multi tx swap의 마지막 트랜잭션이라고 optimistically 가정하고,
+                            // 추가적인 히스토리 데이터를 기록해야 한다.
+                            //
+                            // [배경]
+                            // Skip에서 기본적으로 smart relay 기능을 활성화해 놓았으므로,
+                            // multi tx swap이 필요한 경우는 다음과 같다:
+                            //   - A 체인에서 브릿지, 메시징 프로토콜, 또는 IBC Eureka를 통해 B 체인으로 자산을 전송
+                            //   - B 체인에서 사용자 주소로 릴리즈되는 자산이 wrapped asset이거나 IBC swap이 필요한 asset
+                            //
+                            // [마지막 트랜잭션의 유형]
+                            // 따라서 multi tx swap의 마지막 트랜잭션은 아래 두 가지 중 하나라고 가정할 수 있다:
+                            //   1. Wrapped asset → Native asset 변환 트랜잭션 (EVM)
+                            //   2. IBC swap이 필요한 asset의 IBC swap 트랜잭션 (Cosmos)
+                            //
+                            // [트랜잭션 타입별 처리]
+                            //   1. EVM: txHash를 additionalTrackingData에 저장 → debug_traceTransaction으로 추적
+                            //   2. Cosmos: 외부에서 IBC swap data를 받아 additionalTrackingData에 저장 → IBC swap tracking
+                            if (execution.type === types_1.TxExecutionType.SWAP_V2 &&
+                                execution.historyId != null) {
+                                const currentTx = execution.txs[i];
+                                switch (currentTx.type) {
+                                    case types_1.BackgroundTxType.EVM: {
+                                        if (result.txHash != null) {
+                                            this.recentSendHistoryService.setSwapV2AdditionalTrackingData(execution.historyId, {
+                                                type: "evm",
+                                                chainId: currentTx.chainId,
+                                                txHash: result.txHash,
+                                            });
+                                        }
+                                        break;
+                                    }
+                                    case types_1.BackgroundTxType.COSMOS: {
+                                        const ibcSwapData = options === null || options === void 0 ? void 0 : options.ibcSwapData;
+                                        if (ibcSwapData != null && result.txHash != null) {
+                                            this.recentSendHistoryService.setSwapV2AdditionalTrackingData(execution.historyId, { type: "cosmos-ibc", ibcSwapData, txHash: result.txHash });
+                                        }
+                                        break;
+                                    }
+                                    default: {
+                                        // noop
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        continue;
+                    }
+                    case types_1.BackgroundTxStatus.FAILED: {
+                        this.recordSwapV2HistoryErrorIfNeeded(execution, (_c = result.error) !== null && _c !== void 0 ? _c : `${i + 1}th transaction failed`);
+                        this.removeTxExecution(id);
+                        return {
+                            status: types_1.TxExecutionStatus.FAILED,
+                            error: result.error,
+                        };
+                    }
+                    case types_1.BackgroundTxStatus.BLOCKED: {
+                        /**
+                         * If the tx is BLOCKED, it means multiple transactions are required
+                         * to be executed on different chains.
+                         *
+                         * - The execution should be stopped here,
+                         * - Record the history if needed,
+                         * - The execution should be resumed later when the condition is met.
+                         */
+                        (0, mobx_1.runInAction)(() => {
+                            execution.status = types_1.TxExecutionStatus.BLOCKED;
+                            this.recordHistoryIfNeeded(execution);
+                            // no need to keep the history data anymore
+                            delete execution.historyData;
+                        });
+                        return {
+                            status: types_1.TxExecutionStatus.BLOCKED,
+                        };
+                    }
+                    default: {
+                        throw new router_1.KeplrError("direct-tx-executor", 131, "Unexpected tx status: " + result.status);
+                    }
+                }
+            }
+            this.recordHistoryIfNeeded(execution);
+            this.clearSwapV2HistoryBackgroundExecutionIdIfNeeded(execution);
+            this.removeTxExecution(id);
+            return {
+                status: types_1.TxExecutionStatus.COMPLETED,
+            };
+        });
+    }
+    /**
+     * Execute a pending transaction without modifying observable state.
+     * Returns the result which should be applied by the caller using runInAction.
+     * This reduces autorun trigger count by batching state updates.
+     */
+    executePendingTx(vaultId, tx, executableChainIds, preventAutoSign, providedSignedTx) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = tx.status;
+            let signedTx = (_a = tx.signedTx) !== null && _a !== void 0 ? _a : providedSignedTx;
+            let txHash = tx.txHash;
+            let error;
+            // Already in final state
+            if (status === types_1.BackgroundTxStatus.CONFIRMED ||
+                status === types_1.BackgroundTxStatus.FAILED) {
+                return { status, txHash, error };
+            }
+            // Check if blocked
+            const isBlocked = !executableChainIds.includes(tx.chainId);
+            if (isBlocked) {
+                return { status: types_1.BackgroundTxStatus.BLOCKED, txHash, error };
+            }
+            // If preventAutoSign and not signed, block
+            if (preventAutoSign && signedTx == null) {
+                return { status: types_1.BackgroundTxStatus.BLOCKED, txHash, error };
+            }
+            // if not signed, sign the tx
+            if (signedTx == null) {
+                try {
+                    const signResult = yield this.signTx(vaultId, tx);
+                    signedTx = signResult;
+                }
+                catch (e) {
+                    console.error(`[TxExecutor] tx signing failed:`, e);
+                    return {
+                        status: types_1.BackgroundTxStatus.FAILED,
+                        txHash,
+                        error: (_b = e.message) !== null && _b !== void 0 ? _b : "Transaction signing failed",
+                    };
+                }
+            }
+            // if tx hash is not set, broadcast the tx
+            if (txHash == null) {
+                try {
+                    const txWithSignedTx = Object.assign(Object.assign({}, tx), { signedTx });
+                    const broadcastResult = yield this.broadcastTx(txWithSignedTx);
+                    txHash = broadcastResult;
+                }
+                catch (e) {
+                    console.error(`[TxExecutor] tx broadcast failed:`, e);
+                    return {
+                        status: types_1.BackgroundTxStatus.FAILED,
+                        txHash,
+                        error: (_c = e.message) !== null && _c !== void 0 ? _c : "Transaction broadcasting failed",
+                    };
+                }
+            }
+            // trace the tx
+            try {
+                const txWithHash = Object.assign(Object.assign({}, tx), { txHash });
+                const confirmed = yield this.traceTx(txWithHash);
+                if (confirmed) {
+                    return { status: types_1.BackgroundTxStatus.CONFIRMED, txHash };
+                }
+                return {
+                    status: types_1.BackgroundTxStatus.FAILED,
+                    txHash,
+                    error: "Transaction confirmation failed",
+                };
+            }
+            catch (e) {
+                console.error(`[TxExecutor] tx trace failed:`, e);
+                return {
+                    status: types_1.BackgroundTxStatus.FAILED,
+                    txHash,
+                    error: (_d = e.message) !== null && _d !== void 0 ? _d : "Transaction confirmation failed",
+                };
+            }
+        });
+    }
+    signTx(vaultId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (tx.type) {
+                case types_1.BackgroundTxType.EVM: {
+                    return this.signEvmTx(vaultId, tx);
+                }
+                case types_1.BackgroundTxType.COSMOS: {
+                    return this.signCosmosTx(vaultId, tx);
+                }
+                default: {
+                    throw new router_1.KeplrError("direct-tx-executor", 143, "Unknown tx type");
+                }
+            }
+        });
+    }
+    signEvmTx(vaultId, tx) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyInfo = yield this.keyRingCosmosService.getKey(vaultId, tx.chainId);
+            const isHardware = keyInfo.isNanoLedger || keyInfo.isKeystone;
+            const signer = keyInfo.ethereumHexAddress;
+            // For hardware wallets, the signedTx must be provided externally when calling resumeTx or recordAndExecuteTxs.
+            if (isHardware) {
+                throw new router_1.KeplrError("direct-tx-executor", 140, "Hardware wallet signing should be triggered from user interaction");
+            }
+            const origin = typeof browser !== "undefined"
+                ? new URL(browser.runtime.getURL("/")).origin
+                : "extension";
+            const chainInfo = this.chainsService.getChainInfoOrThrow(tx.chainId);
+            const evmInfo = chains_1.ChainsService.getEVMInfo(chainInfo);
+            if (!evmInfo) {
+                throw new router_1.KeplrError("direct-tx-executor", 142, "Not EVM chain");
+            }
+            const unsignedTx = yield (0, evm_1.fillUnsignedEVMTx)(origin, evmInfo, signer, tx.txData, (_a = tx.feeType) !== null && _a !== void 0 ? _a : "average");
+            const result = yield this.keyRingEthereumService.signEthereumPreAuthorized(vaultId, tx.chainId, signer, Buffer.from(JSON.stringify(unsignedTx)), types_2.EthSignType.TRANSACTION);
+            const signedTxData = JSON.parse(Buffer.from(result.signingData).toString());
+            const isEIP1559 = !!signedTxData.maxFeePerGas || !!signedTxData.maxPriorityFeePerGas;
+            if (isEIP1559) {
+                signedTxData.type = transactions_1.TransactionTypes.eip1559;
+            }
+            delete signedTxData.from;
+            return (0, transactions_1.serialize)(signedTxData, result.signature);
+        });
+    }
+    signCosmosTx(vaultId, tx) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyInfo = yield this.keyRingCosmosService.getKey(vaultId, tx.chainId);
+            const isHardware = keyInfo.isNanoLedger || keyInfo.isKeystone;
+            const signer = keyInfo.bech32Address;
+            // For hardware wallets, the signedTx must be provided externally when calling resumeTx or recordAndExecuteTxs.
+            if (isHardware) {
+                throw new router_1.KeplrError("direct-tx-executor", 140, "Hardware wallet signing should be triggered from user interaction");
+            }
+            const origin = typeof browser !== "undefined"
+                ? new URL(browser.runtime.getURL("/")).origin
+                : "extension";
+            const chainInfo = this.chainsService.getChainInfoOrThrow(tx.chainId);
+            const aminoMsgs = (_a = tx.txData.aminoMsgs) !== null && _a !== void 0 ? _a : [];
+            const protoMsgs = tx.txData.protoMsgs;
+            const pseudoFee = {
+                amount: [
+                    {
+                        denom: chainInfo.currencies[0].coinMinimalDenom,
+                        amount: "1",
+                    },
+                ],
+                gas: "100000",
+            };
+            const memo = (_b = tx.txData.memo) !== null && _b !== void 0 ? _b : "";
+            const isDirectSign = aminoMsgs.length === 0;
+            if (protoMsgs.length === 0) {
+                throw new Error("There is no msg to send");
+            }
+            if (!isDirectSign && aminoMsgs.length !== protoMsgs.length) {
+                throw new Error("The length of aminoMsgs and protoMsgs are different");
+            }
+            const account = yield cosmos_1.BaseAccount.fetchFromRest(chainInfo.rest, signer, true);
+            let fee = tx.txData.fee; // use provided fee if exists
+            if (fee == null) {
+                const { gasUsed } = yield (0, cosmos_2.simulateCosmosTx)(signer, chainInfo, protoMsgs, pseudoFee, memo);
+                const feeCurrency = (_c = chainInfo.feeCurrencies.find((currency) => currency.coinMinimalDenom === tx.feeCurrencyDenom)) !== null && _c !== void 0 ? _c : chainInfo.currencies[0];
+                const { gasPrice } = yield (0, cosmos_2.getCosmosGasPrice)(chainInfo, (_d = tx.feeType) !== null && _d !== void 0 ? _d : "average", feeCurrency);
+                fee = (0, cosmos_2.calculateCosmosStdFee)(feeCurrency, gasUsed, gasPrice, chainInfo.features);
+            }
+            if (isDirectSign) {
+                const { signDoc, bodyBytes, authInfoBytes } = (0, cosmos_2.prepareSignDocForDirectSigning)({
+                    chainInfo,
+                    accountNumber: account.getAccountNumber().toString(),
+                    sequence: account.getSequence().toString(),
+                    protoMsgs,
+                    fee,
+                    memo,
+                    pubKey: keyInfo.pubKey,
+                });
+                const { signature } = yield this.keyRingCosmosService.signDirectPreAuthorized(origin, vaultId, tx.chainId, signer, signDoc);
+                const signedTx = tx_1.TxRaw.encode({
+                    bodyBytes,
+                    authInfoBytes,
+                    signatures: [Buffer.from(signature.signature, "base64")],
+                }).finish();
+                return Buffer.from(signedTx).toString("base64");
+            }
+            else {
+                const signDoc = (0, cosmos_2.prepareSignDocForAminoSigning)({
+                    chainInfo,
+                    accountNumber: account.getAccountNumber().toString(),
+                    sequence: account.getSequence().toString(),
+                    aminoMsgs: (_e = tx.txData.aminoMsgs) !== null && _e !== void 0 ? _e : [],
+                    fee,
+                    memo,
+                    eip712Signing: false,
+                    signer,
+                });
+                const signResponse = yield this.keyRingCosmosService.signAminoPreAuthorized(origin, vaultId, tx.chainId, signer, signDoc);
+                const signedTx = (0, cosmos_2.buildSignedTxFromAminoSignResponse)({
+                    protoMsgs,
+                    signResponse,
+                    chainInfo,
+                    eip712Signing: false,
+                });
+                return Buffer.from(signedTx.tx).toString("base64");
+            }
+        });
+    }
+    broadcastTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (tx.type) {
+                case types_1.BackgroundTxType.EVM: {
+                    return this.broadcastEvmTx(tx);
+                }
+                case types_1.BackgroundTxType.COSMOS: {
+                    return this.broadcastCosmosTx(tx);
+                }
+                default: {
+                    throw new router_1.KeplrError("direct-tx-executor", 143, "Unknown tx type");
+                }
+            }
+        });
+    }
+    broadcastEvmTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // assume the signed tx is valid if exists
+            if (!tx.signedTx) {
+                throw new router_1.KeplrError("direct-tx-executor", 132, "Signed tx not found");
+            }
+            const origin = typeof browser !== "undefined"
+                ? new URL(browser.runtime.getURL("/")).origin
+                : "extension";
+            const signedTxBytes = Buffer.from(tx.signedTx.replace("0x", ""), "hex");
+            const txHash = yield this.backgroundTxEthereumService.sendEthereumTx(origin, tx.chainId, signedTxBytes, {
+                silent: true,
+                skipTracingTxResult: true,
+            });
+            return txHash;
+        });
+    }
+    broadcastCosmosTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!tx.signedTx) {
+                throw new router_1.KeplrError("direct-tx-executor", 132, "Signed tx not found");
+            }
+            const signedTxBytes = Buffer.from(tx.signedTx, "base64");
+            // broadcast the tx
+            const txHash = yield this.backgroundTxService.sendTx(tx.chainId, signedTxBytes, "sync", {
+                silent: true,
+                skipTracingTxResult: true,
+            });
+            return Buffer.from(txHash).toString("hex");
+        });
+    }
+    traceTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (tx.type) {
+                case types_1.BackgroundTxType.EVM: {
+                    return this.traceEvmTx(tx);
+                }
+                case types_1.BackgroundTxType.COSMOS: {
+                    return this.traceCosmosTx(tx);
+                }
+                default: {
+                    throw new router_1.KeplrError("direct-tx-executor", 143, "Unknown tx type");
+                }
+            }
+        });
+    }
+    traceEvmTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!tx.txHash) {
+                throw new router_1.KeplrError("direct-tx-executor", 133, "Tx hash not found");
+            }
+            const origin = typeof browser !== "undefined"
+                ? new URL(browser.runtime.getURL("/")).origin
+                : "extension";
+            const txReceipt = yield this.backgroundTxEthereumService.getEthereumTxReceipt(origin, tx.chainId, tx.txHash);
+            if (!txReceipt) {
+                return false;
+            }
+            return txReceipt.status === types_2.EthTxStatus.Success;
+        });
+    }
+    traceCosmosTx(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!tx.txHash) {
+                throw new router_1.KeplrError("direct-tx-executor", 133, "Tx hash not found");
+            }
+            const txResult = yield this.backgroundTxService.traceTx(tx.chainId, tx.txHash);
+            if (!txResult) {
+                return false;
+            }
+            // Tendermint/CometBFT omits the code field when tx is successful (code=0)
+            // If code is present and non-zero, it's a failure
+            if (txResult.code != null && txResult.code !== 0) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Find the index of the most recent confirmed transaction with executable chain ids.
+     * Returns -1 if not found.
+     */
+    findHistoryTxIndex(execution) {
+        if (execution.historyTxIndex != null) {
+            return execution.historyTxIndex;
+        }
+        for (let i = execution.txs.length - 1; i >= 0; i--) {
+            const tx = execution.txs[i];
+            if (execution.executableChainIds.includes(tx.chainId) &&
+                tx.status === types_1.BackgroundTxStatus.CONFIRMED) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    recordHistoryIfNeeded(execution) {
+        switch (execution.type) {
+            case types_1.TxExecutionType.SWAP_V2: {
+                if (execution.historyId != null || execution.historyData == null) {
+                    return;
+                }
+                const historyTxIndex = this.findHistoryTxIndex(execution);
+                if (historyTxIndex < 0) {
+                    return;
+                }
+                const tx = execution.txs[historyTxIndex];
+                if (!tx || tx.txHash == null) {
+                    return;
+                }
+                const historyData = execution.historyData;
+                const backgroundExecutionId = execution.txs.some((tx) => tx.status === types_1.BackgroundTxStatus.BLOCKED)
+                    ? execution.id
+                    : undefined;
+                const id = this.recentSendHistoryService.recordTxWithSwapV2(historyData.fromChainId, historyData.toChainId, historyData.provider, historyData.destinationAsset, historyData.simpleRoute, historyData.sender, historyData.recipient, historyData.amount, historyData.notificationInfo, historyData.routeDurationSeconds, tx.txHash, historyData.isOnlyUseBridge, backgroundExecutionId);
+                execution.historyId = id;
+                break;
+            }
+            default: {
+                return;
+            }
+        }
+    }
+    getRecentTxExecutions() {
+        return Array.from(this.recentTxExecutionMap.values());
+    }
+    getTxExecution(id) {
+        const execution = this.recentTxExecutionMap.get(id);
+        if (!execution) {
+            return undefined;
+        }
+        return execution;
+    }
+    removeTxExecution(id) {
+        this.recentTxExecutionMap.delete(id);
+    }
+    cleanupOldExecutions() {
+        const completedStatuses = [
+            types_1.TxExecutionStatus.COMPLETED,
+            types_1.TxExecutionStatus.FAILED,
+        ];
+        const idsToDelete = [];
+        for (const [id, execution] of this.recentTxExecutionMap) {
+            // 비정상 종료된 PROCESSING 상태 → FAILED 처리
+            // (브라우저 종료, 시스템 재부팅, 익스텐션 업데이트 등)
+            if (execution.status === types_1.TxExecutionStatus.PROCESSING) {
+                execution.status = types_1.TxExecutionStatus.FAILED;
+            }
+            if (completedStatuses.includes(execution.status)) {
+                idsToDelete.push(id);
+            }
+        }
+        for (const id of idsToDelete) {
+            this.recentTxExecutionMap.delete(id);
+        }
+    }
+    recordSwapV2HistoryErrorIfNeeded(execution, error) {
+        if (execution.type === types_1.TxExecutionType.SWAP_V2 &&
+            execution.historyId != null) {
+            this.recentSendHistoryService.setSwapV2HistoryError(execution.historyId, error);
+        }
+    }
+    clearSwapV2HistoryBackgroundExecutionIdIfNeeded(execution) {
+        if (execution.type === types_1.TxExecutionType.SWAP_V2 &&
+            execution.historyId != null) {
+            this.recentSendHistoryService.clearSwapV2HistoryBackgroundExecutionId(execution.historyId);
+        }
+    }
+}
+__decorate([
+    mobx_1.observable
+], BackgroundTxExecutorService.prototype, "recentTxExecutionSeq", void 0);
+__decorate([
+    mobx_1.observable
+], BackgroundTxExecutorService.prototype, "recentTxExecutionMap", void 0);
+__decorate([
+    mobx_1.action
+], BackgroundTxExecutorService.prototype, "handleTxExecutionEvent", null);
+__decorate([
+    mobx_1.action
+], BackgroundTxExecutorService.prototype, "recordHistoryIfNeeded", null);
+__decorate([
+    mobx_1.action
+], BackgroundTxExecutorService.prototype, "removeTxExecution", null);
+__decorate([
+    mobx_1.action
+], BackgroundTxExecutorService.prototype, "cleanupOldExecutions", null);
+exports.BackgroundTxExecutorService = BackgroundTxExecutorService;
+//# sourceMappingURL=service.js.map