@ledgerhq/live-common 34.53.0-nightly.20251115023630 → 34.53.0-nightly.20251118023800

package/lib/wallet-api/react.js

@@ -3,24 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useDisclaimerRaw = exports.useRecentlyUsed = exports.useCacheBustedLiveApps = exports.useLocalLiveApp = exports.useCategories = exports.ExchangeType = exports.useWalletAPIServer = exports.useConfig = exports.usePermission = exports.useGetAccountIds = exports.useManifestCurrencies = exports.useWalletAPICurrencies = exports.useWalletAPIAccounts = exports.safeGetRefValue = void 0;
+exports.useDisclaimerRaw = exports.useRecentlyUsed = exports.useCacheBustedLiveApps = exports.useLocalLiveApp = exports.useCategories = exports.ExchangeType = exports.useWalletAPIServer = exports.useConfig = exports.usePermission = exports.useDAppManifestCurrencyIds = exports.useSetWalletAPIAccounts = exports.safeGetRefValue = void 0;
 const react_1 = require("react");
+const react_redux_1 = require("react-redux");
 const semver_1 = __importDefault(require("semver"));
 const date_fns_1 = require("date-fns");
-const react_2 = require("@ledgerhq/wallet-api-server/lib/react");
-const rxjs_1 = require("rxjs");
+const wallet_api_server_1 = require("@ledgerhq/wallet-api-server");
 const operators_1 = require("rxjs/operators");
+const live_env_1 = require("@ledgerhq/live-env");
+const errors_1 = require("@ledgerhq/errors");
+const api_1 = require("@ledgerhq/cryptoassets/cal-client/state-manager/api");
 const converters_1 = require("./converters");
 const helpers_1 = require("./helpers");
 const account_1 = require("../account");
 const currencies_1 = require("../currencies");
-const index_1 = require("../bridge/crypto-assets/index");
+const crypto_assets_1 = require("../bridge/crypto-assets");
 const logic_1 = require("./logic");
 const bridge_1 = require("../bridge");
-const live_env_1 = require("@ledgerhq/live-env");
 const openTransportAsSubject_1 = __importDefault(require("../hw/openTransportAsSubject"));
-const errors_1 = require("@ledgerhq/errors");
 const constants_1 = require("./constants");
+const useCurrenciesUnderFeatureFlag_1 = require("../modularDrawer/hooks/useCurrenciesUnderFeatureFlag");
 function safeGetRefValue(ref) {
     if (!ref.current) {
         throw new Error("Ref objects doesn't have a current value");
@@ -28,62 +30,25 @@ function safeGetRefValue(ref) {
     return ref.current;
 }
 exports.safeGetRefValue = safeGetRefValue;
-function useWalletAPIAccounts(walletState, accounts) {
-    return (0, react_1.useMemo)(() => {
-        return accounts.map(account => {
-            const parentAccount = (0, account_1.getParentAccount)(account, accounts);
-            return (0, converters_1.accountToWalletAPIAccount)(walletState, account, parentAccount);
+function useSetWalletAPIAccounts(accounts) {
+    (0, react_1.useEffect)(() => {
+        accounts.forEach(account => {
+            (0, converters_1.setWalletApiIdForAccountId)(account.id);
         });
-    }, [walletState, accounts]);
+    }, [accounts]);
 }
-exports.useWalletAPIAccounts = useWalletAPIAccounts;
-function useWalletAPICurrencies() {
-    return (0, react_1.useMemo)(() => {
-        return (0, currencies_1.listCurrencies)(true).reduce((filtered, currency) => {
-            if ((0, helpers_1.isWalletAPISupportedCurrency)(currency)) {
-                filtered.push((0, converters_1.currencyToWalletAPICurrency)(currency));
-            }
-            return filtered;
-        }, []);
-    }, []);
-}
-exports.useWalletAPICurrencies = useWalletAPICurrencies;
-function useManifestCurrencies(manifest) {
+exports.useSetWalletAPIAccounts = useSetWalletAPIAccounts;
+function useDAppManifestCurrencyIds(manifest) {
     return (0, react_1.useMemo)(() => {
         return (manifest.dapp?.networks.map(network => {
-            return (0, currencies_1.getCryptoCurrencyById)(network.currency);
+            return network.currency;
         }) ?? []);
     }, [manifest.dapp?.networks]);
 }
-exports.useManifestCurrencies = useManifestCurrencies;
-function useGetAccountIds(accounts$) {
-    const [accounts, setAccounts] = (0, react_1.useState)([]);
-    (0, react_1.useEffect)(() => {
-        if (!accounts$) {
-            return undefined;
-        }
-        const subscription = accounts$.subscribe(walletAccounts => {
-            setAccounts(walletAccounts);
-        });
-        return () => {
-            subscription.unsubscribe();
-        };
-    }, [accounts$]);
-    return (0, react_1.useMemo)(() => {
-        if (!accounts$) {
-            return undefined;
-        }
-        return accounts.reduce((accountIds, account) => {
-            accountIds.set((0, converters_1.getAccountIdFromWalletAccountId)(account.id), true);
-            return accountIds;
-        }, new Map());
-    }, [accounts, accounts$]);
-}
-exports.useGetAccountIds = useGetAccountIds;
+exports.useDAppManifestCurrencyIds = useDAppManifestCurrencyIds;
 function usePermission(manifest) {
     return (0, react_1.useMemo)(() => ({
-        currencyIds: manifest.currencies === "*" ? ["**"] : manifest.currencies,
-        methodIds: manifest.permissions, // TODO remove when using the correct manifest type
+        methodIds: manifest.permissions,
     }), [manifest]);
 }
 exports.usePermission = usePermission;
@@ -102,7 +67,7 @@ function useConfig({ appId, userId, tracking, wallet, mevProtected, }) {
         tracking,
         wallet,
         mevProtected,
-    }), [appId, tracking, userId, wallet]);
+    }), [appId, mevProtected, tracking, userId, wallet]);
 }
 exports.useConfig = useConfig;
 function useDeviceTransport({ manifest, tracking }) {
@@ -153,73 +118,257 @@ function useDeviceTransport({ manifest, tracking }) {
     return (0, react_1.useMemo)(() => ({ ref, subscribe, close, exchange }), [close, exchange, subscribe]);
 }
 function useWalletAPIServer({ walletState, manifest, accounts, tracking, config, webviewHook, uiHook: { "account.request": uiAccountRequest, "account.receive": uiAccountReceive, "message.sign": uiMessageSign, "storage.get": uiStorageGet, "storage.set": uiStorageSet, "transaction.sign": uiTxSign, "transaction.signRaw": uiTxSignRaw, "transaction.broadcast": uiTxBroadcast, "device.transport": uiDeviceTransport, "device.select": uiDeviceSelect, "exchange.start": uiExchangeStart, "exchange.complete": uiExchangeComplete, }, customHandlers, }) {
+    const dispatch = (0, react_redux_1.useDispatch)();
+    const { deactivatedCurrencyIds } = (0, useCurrenciesUnderFeatureFlag_1.useCurrenciesUnderFeatureFlag)();
     const permission = usePermission(manifest);
     const transport = useTransport(webviewHook.postMessage);
     const [widgetLoaded, setWidgetLoaded] = (0, react_1.useState)(false);
-    const walletAPIAccounts = useWalletAPIAccounts(walletState, accounts);
-    const walletAPICurrencies = useWalletAPICurrencies();
-    const { server, onMessage } = (0, react_2.useWalletAPIServer)({
+    // We need to set the wallet API account IDs mapping upfront
+    // If we don't want the map to be empty when requesting an account
+    useSetWalletAPIAccounts(accounts);
+    const { server, onMessage } = (0, wallet_api_server_1.useWalletAPIServer)({
         transport,
         config,
-        accounts: walletAPIAccounts,
-        currencies: walletAPICurrencies,
         permission,
         customHandlers,
     });
     (0, react_1.useEffect)(() => {
         tracking.load(manifest);
     }, [tracking, manifest]);
+    // TODO: refactor each handler into its own logic function for clarity
+    (0, react_1.useEffect)(() => {
+        server.setHandler("currency.list", async ({ currencyIds }) => {
+            tracking.currencyListRequested(manifest);
+            try {
+                // 1. Parse manifest currency patterns to determine what to include
+                const manifestCurrencyIds = manifest.currencies === "*" ? ["**"] : manifest.currencies;
+                // 2. Apply query filter early - intersect with manifest patterns
+                const queryCurrencyIdsSet = currencyIds ? new Set(currencyIds) : undefined;
+                let effectiveCurrencyIds = manifestCurrencyIds;
+                if (queryCurrencyIdsSet) {
+                    // If we have a query filter, narrow down what we need to fetch
+                    effectiveCurrencyIds = manifestCurrencyIds.flatMap(manifestId => {
+                        if (manifestId === "**") {
+                            // Query can ask for anything, so use the query list
+                            return [...queryCurrencyIdsSet];
+                        }
+                        else if (manifestId.endsWith("/**")) {
+                            // Pattern like "ethereum/**" - keep tokens from query that match this family
+                            const family = manifestId.slice(0, -3);
+                            return [...queryCurrencyIdsSet].filter(qId => qId.startsWith(`${family}/`));
+                        }
+                        else if (queryCurrencyIdsSet.has(manifestId)) {
+                            // Specific currency/token that's in the query
+                            return [manifestId];
+                        }
+                        // Not in query, skip it
+                        return [];
+                    });
+                }
+                // 3. Parse effective currency IDs to determine what to fetch
+                const includeAllCurrencies = effectiveCurrencyIds.includes("**");
+                const specificCurrencies = new Set();
+                const tokenFamilies = new Set();
+                const specificTokenIds = new Set();
+                for (const id of effectiveCurrencyIds) {
+                    if (id === "**") {
+                        // Already handled above
+                        continue;
+                    }
+                    else if (id.endsWith("/**")) {
+                        // Pattern like "ethereum/**" or "solana/**" - include tokens for this family
+                        const family = id.slice(0, -3);
+                        tokenFamilies.add(family);
+                    }
+                    else if (id.includes("/")) {
+                        // Specific token ID like "ethereum/erc20/usd__coin"
+                        specificTokenIds.add(id);
+                    }
+                    else {
+                        // Specific currency like "bitcoin" or "ethereum"
+                        specificCurrencies.add(id);
+                    }
+                }
+                // 4. Gather all supported parent currencies
+                const allCurrencies = (0, currencies_1.listSupportedCurrencies)().reduce((acc, c) => {
+                    if ((0, helpers_1.isWalletAPISupportedCurrency)(c) && !deactivatedCurrencyIds.has(c.id))
+                        acc.push((0, converters_1.currencyToWalletAPICurrency)(c));
+                    return acc;
+                }, []);
+                // 5. Determine which currencies to include based on patterns
+                let includedCurrencies = [];
+                if (includeAllCurrencies) {
+                    includedCurrencies = allCurrencies;
+                }
+                else {
+                    includedCurrencies = allCurrencies.filter(c => specificCurrencies.has(c.id));
+                }
+                // 6. Fetch specific tokens by ID if any
+                const specificTokens = [];
+                if (specificTokenIds.size > 0) {
+                    const tokenPromises = [...specificTokenIds].map(async (tokenId) => {
+                        const token = await (0, crypto_assets_1.getCryptoAssetsStore)().findTokenById(tokenId);
+                        return token ? (0, converters_1.currencyToWalletAPICurrency)(token) : null;
+                    });
+                    const resolvedTokens = await Promise.all(tokenPromises);
+                    specificTokens.push(...resolvedTokens.filter((t) => t !== null));
+                }
+                // 7. Determine which token families to fetch (only if not already fetched as specific tokens)
+                const familiesToFetch = new Set();
+                if (includeAllCurrencies) {
+                    // Fetch tokens for all currency families
+                    allCurrencies.forEach(c => {
+                        if (c.type === "CryptoCurrency")
+                            familiesToFetch.add(c.family);
+                    });
+                }
+                else if (tokenFamilies.size > 0) {
+                    // Only fetch tokens for families explicitly marked with /**
+                    tokenFamilies.forEach(family => familiesToFetch.add(family));
+                }
+                // 8. Fetch tokens for relevant families
+                const fetchAllPagesForFamily = async (family) => {
+                    const args = { networkFamily: family, pageSize: 1000 };
+                    let hasNextPage = true;
+                    let data;
+                    while (hasNextPage) {
+                        const querySub = dispatch(api_1.endpoints.getTokensData.initiate(args, data ? { direction: "forward" } : undefined));
+                        try {
+                            const result = await querySub;
+                            data = result.data;
+                            hasNextPage = result.hasNextPage;
+                            if (result.error)
+                                throw result.error;
+                        }
+                        finally {
+                            querySub.unsubscribe();
+                        }
+                    }
+                    return (data?.pages ?? []).flatMap(p => p.tokens);
+                };
+                const tokensByFamily = await Promise.all([...familiesToFetch].map(f => fetchAllPagesForFamily(f)));
+                // 9. Combine all results (no additional filter needed since we pre-filtered)
+                const result = tokensByFamily.reduce((acc, tokens) => [...acc, ...tokens.map(t => (0, converters_1.currencyToWalletAPICurrency)(t))], [...includedCurrencies, ...specificTokens]);
+                tracking.currencyListSuccess(manifest);
+                return result;
+            }
+            catch (err) {
+                tracking.currencyListFail(manifest);
+                throw err;
+            }
+        });
+    }, [walletState, manifest, server, tracking, dispatch, deactivatedCurrencyIds]);
+    (0, react_1.useEffect)(() => {
+        server.setHandler("account.list", ({ currencyIds }) => {
+            tracking.accountListRequested(manifest);
+            try {
+                // 1. Parse manifest currency patterns to determine what to include
+                const manifestCurrencyIds = manifest.currencies === "*" ? ["**"] : manifest.currencies;
+                // 2. Apply query filter early - intersect with manifest patterns
+                const queryCurrencyIdsSet = currencyIds ? new Set(currencyIds) : undefined;
+                let effectiveCurrencyIds = manifestCurrencyIds;
+                if (queryCurrencyIdsSet) {
+                    // If we have a query filter, narrow down what we need to check
+                    effectiveCurrencyIds = manifestCurrencyIds.flatMap(manifestId => {
+                        if (manifestId === "**") {
+                            // Query can ask for anything, so use the query list
+                            return [...queryCurrencyIdsSet];
+                        }
+                        else if (manifestId.endsWith("/**")) {
+                            // Pattern like "ethereum/**" - keep tokens from query that match this family
+                            const family = manifestId.slice(0, -3);
+                            return [...queryCurrencyIdsSet].filter(qId => qId.startsWith(`${family}/`));
+                        }
+                        else if (queryCurrencyIdsSet.has(manifestId)) {
+                            // Specific currency/token that's in the query
+                            return [manifestId];
+                        }
+                        // Not in query, skip it
+                        return [];
+                    });
+                }
+                // 3. Build a set of allowed currency IDs based on effective patterns
+                const allowedCurrencyIds = new Set();
+                const includeAllCurrencies = effectiveCurrencyIds.includes("**");
+                const tokenFamilyPrefixes = new Set();
+                for (const id of effectiveCurrencyIds) {
+                    if (id === "**") {
+                        // Will match all currencies
+                        continue;
+                    }
+                    else if (id.endsWith("/**")) {
+                        // Pattern like "ethereum/**" - store prefix for matching
+                        const family = id.slice(0, -3);
+                        tokenFamilyPrefixes.add(family);
+                    }
+                    else {
+                        // Specific currency/token ID
+                        allowedCurrencyIds.add(id);
+                    }
+                }
+                // 4. Filter accounts based on effective currency IDs
+                const wapiAccounts = accounts.reduce((acc, account) => {
+                    const parentAccount = (0, account_1.getParentAccount)(account, accounts);
+                    const accountCurrencyId = account.type === "TokenAccount" ? account.token.id : account.currency.id;
+                    const parentCurrencyId = account.type === "TokenAccount" ? account.token.parentCurrency.id : account.currency.id;
+                    // Check if account currency ID matches the effective patterns
+                    const isAllowed = includeAllCurrencies ||
+                        allowedCurrencyIds.has(accountCurrencyId) ||
+                        tokenFamilyPrefixes.has(parentCurrencyId);
+                    if (isAllowed) {
+                        acc.push((0, converters_1.accountToWalletAPIAccount)(walletState, account, parentAccount));
+                    }
+                    return acc;
+                }, []);
+                tracking.accountListSuccess(manifest);
+                return wapiAccounts;
+            }
+            catch (err) {
+                tracking.accountListFail(manifest);
+                throw err;
+            }
+        });
+    }, [walletState, manifest, server, tracking, uiAccountRequest, accounts]);
     (0, react_1.useEffect)(() => {
         if (!uiAccountRequest)
             return;
-        server.setHandler("account.request", async ({ accounts$, currencies$, drawerConfiguration, areCurrenciesFiltered, useCase }) => {
+        server.setHandler("account.request", async ({ currencyIds, drawerConfiguration, areCurrenciesFiltered, useCase }) => {
             tracking.requestAccountRequested(manifest);
-            const currencies = await (0, rxjs_1.firstValueFrom)(currencies$);
             return new Promise((resolve, reject) => {
-                (async () => {
-                    try {
-                        // handle no curencies selected case
-                        const currencyList = [];
-                        for (const { id } of currencies) {
-                            const currency = (0, currencies_1.findCryptoCurrencyById)(id) || (await (0, index_1.getCryptoAssetsStore)().findTokenById(id));
-                            if (currency) {
-                                currencyList.push(currency);
-                            }
-                        }
-                        let done = false;
-                        uiAccountRequest({
-                            accounts$,
-                            currencies: currencyList,
-                            drawerConfiguration,
-                            areCurrenciesFiltered,
-                            useCase,
-                            onSuccess: (account, parentAccount) => {
-                                if (done)
-                                    return;
-                                done = true;
-                                tracking.requestAccountSuccess(manifest);
-                                resolve((0, converters_1.accountToWalletAPIAccount)(walletState, account, parentAccount));
-                            },
-                            onCancel: () => {
-                                if (done)
-                                    return;
-                                done = true;
-                                tracking.requestAccountFail(manifest);
-                                reject(new Error("Canceled by user"));
-                            },
-                        });
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                })();
+                let done = false;
+                try {
+                    uiAccountRequest({
+                        currencyIds,
+                        drawerConfiguration,
+                        areCurrenciesFiltered,
+                        useCase,
+                        onSuccess: (account, parentAccount) => {
+                            if (done)
+                                return;
+                            done = true;
+                            tracking.requestAccountSuccess(manifest);
+                            resolve((0, converters_1.accountToWalletAPIAccount)(walletState, account, parentAccount));
+                        },
+                        onCancel: () => {
+                            if (done)
+                                return;
+                            done = true;
+                            tracking.requestAccountFail(manifest);
+                            reject(new Error("Canceled by user"));
+                        },
+                    });
+                }
+                catch (error) {
+                    tracking.requestAccountFail(manifest);
+                    reject(error);
+                }
             });
         });
     }, [walletState, manifest, server, tracking, uiAccountRequest]);
     (0, react_1.useEffect)(() => {
         if (!uiAccountReceive)
             return;
-        server.setHandler("account.receive", ({ account, tokenCurrency }) => (0, logic_1.receiveOnAccountLogic)(walletState, { manifest, accounts, tracking }, account.id, (account, parentAccount, accountAddress) => new Promise((resolve, reject) => {
+        server.setHandler("account.receive", ({ accountId, tokenCurrency }) => (0, logic_1.receiveOnAccountLogic)(walletState, { manifest, accounts, tracking }, accountId, (account, parentAccount, accountAddress) => new Promise((resolve, reject) => {
             let done = false;
             return uiAccountReceive({
                 account,
@@ -252,7 +401,7 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
     (0, react_1.useEffect)(() => {
         if (!uiMessageSign)
             return;
-        server.setHandler("message.sign", ({ account, message, options }) => (0, logic_1.signMessageLogic)({ manifest, accounts, tracking }, account.id, message.toString("hex"), (account, message) => new Promise((resolve, reject) => {
+        server.setHandler("message.sign", ({ accountId, message, options }) => (0, logic_1.signMessageLogic)({ manifest, accounts, tracking }, accountId, message.toString("hex"), (account, message) => new Promise((resolve, reject) => {
             let done = false;
             return uiMessageSign({
                 account,
@@ -297,31 +446,38 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
     (0, react_1.useEffect)(() => {
         if (!uiTxSign)
             return;
-        server.setHandler("transaction.sign", async ({ account, tokenCurrency, transaction, options }) => {
-            const signedOperation = await (0, logic_1.signTransactionLogic)({ manifest, accounts, tracking }, account.id, transaction, (account, parentAccount, signFlowInfos) => new Promise((resolve, reject) => {
-                let done = false;
-                return uiTxSign({
-                    account,
-                    parentAccount,
-                    signFlowInfos,
-                    options,
-                    onSuccess: signedOperation => {
-                        if (done)
-                            return;
-                        done = true;
-                        tracking.signTransactionSuccess(manifest);
-                        resolve(signedOperation);
-                    },
-                    onError: error => {
-                        if (done)
-                            return;
-                        done = true;
-                        tracking.signTransactionFail(manifest);
-                        reject(error);
-                    },
+        server.setHandler("transaction.sign", async ({ accountId, tokenCurrency, transaction, options }) => {
+            let currency;
+            const signedOperation = await (0, logic_1.signTransactionLogic)({ manifest, accounts, tracking }, accountId, transaction, (account, parentAccount, signFlowInfos) => {
+                currency =
+                    account.type === "TokenAccount"
+                        ? account.token.parentCurrency.id
+                        : account.currency.id;
+                return new Promise((resolve, reject) => {
+                    let done = false;
+                    return uiTxSign({
+                        account,
+                        parentAccount,
+                        signFlowInfos,
+                        options,
+                        onSuccess: signedOperation => {
+                            if (done)
+                                return;
+                            done = true;
+                            tracking.signTransactionSuccess(manifest);
+                            resolve(signedOperation);
+                        },
+                        onError: error => {
+                            if (done)
+                                return;
+                            done = true;
+                            tracking.signTransactionFail(manifest);
+                            reject(error);
+                        },
+                    });
                 });
-            }), tokenCurrency);
-            return account.currency === "solana"
+            }, tokenCurrency);
+            return currency === "solana"
                 ? Buffer.from(signedOperation.signature, "hex")
                 : Buffer.from(signedOperation.signature);
         });
@@ -329,8 +485,8 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
     (0, react_1.useEffect)(() => {
         if (!uiTxSignRaw)
             return;
-        server.setHandler("transaction.signRaw", async ({ account, transaction, broadcast, options }) => {
-            const signedOperation = await (0, logic_1.signRawTransactionLogic)({ manifest, accounts, tracking }, account.id, transaction, (account, parentAccount, tx) => new Promise((resolve, reject) => {
+        server.setHandler("transaction.signRaw", async ({ accountId, transaction, broadcast, options }) => {
+            const signedOperation = await (0, logic_1.signRawTransactionLogic)({ manifest, accounts, tracking }, accountId, transaction, (account, parentAccount, tx) => new Promise((resolve, reject) => {
                 let done = false;
                 return uiTxSignRaw({
                     account,
@@ -355,7 +511,7 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
             }));
             let hash;
             if (broadcast) {
-                hash = await (0, logic_1.broadcastTransactionLogic)({ manifest, accounts, tracking }, account.id, signedOperation, async (account, parentAccount, signedOperation) => {
+                hash = await (0, logic_1.broadcastTransactionLogic)({ manifest, accounts, tracking }, accountId, signedOperation, async (account, parentAccount, signedOperation) => {
                     const bridge = (0, bridge_1.getAccountBridge)(account, parentAccount);
                     const mainAccount = (0, account_1.getMainAccount)(account, parentAccount);
                     let optimisticOperation = signedOperation.operation;
@@ -387,9 +543,9 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
     (0, react_1.useEffect)(() => {
         if (!uiTxSign)
             return;
-        server.setHandler("transaction.signAndBroadcast", async ({ account, tokenCurrency, transaction, options }) => {
+        server.setHandler("transaction.signAndBroadcast", async ({ accountId, tokenCurrency, transaction, options }) => {
             const sponsored = transaction.family === "ethereum" && transaction.sponsored;
-            const signedTransaction = await (0, logic_1.signTransactionLogic)({ manifest, accounts, tracking }, account.id, transaction, (account, parentAccount, signFlowInfos) => new Promise((resolve, reject) => {
+            const signedTransaction = await (0, logic_1.signTransactionLogic)({ manifest, accounts, tracking }, accountId, transaction, (account, parentAccount, signFlowInfos) => new Promise((resolve, reject) => {
                 let done = false;
                 return uiTxSign({
                     account,
@@ -412,7 +568,7 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
                     },
                 });
             }), tokenCurrency);
-            return (0, logic_1.broadcastTransactionLogic)({ manifest, accounts, tracking }, account.id, signedTransaction, async (account, parentAccount, signedOperation) => {
+            return (0, logic_1.broadcastTransactionLogic)({ manifest, accounts, tracking }, accountId, signedTransaction, async (account, parentAccount, signedOperation) => {
                 const bridge = (0, bridge_1.getAccountBridge)(account, parentAccount);
                 const mainAccount = (0, account_1.getMainAccount)(account, parentAccount);
                 let optimisticOperation = signedOperation.operation;
@@ -618,8 +774,8 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
             // retrofit of the exchange params to fit the old platform spec
             const request = {
                 provider: params.provider,
-                fromAccountId: params.fromAccount.id,
-                toAccountId: params.exchangeType === "SWAP" ? params.toAccount.id : undefined,
+                fromAccountId: params.fromAccountId,
+                toAccountId: params.exchangeType === "SWAP" ? params.toAccountId : undefined,
                 transaction: params.transaction,
                 binaryPayload: params.binaryPayload.toString("hex"),
                 signature: params.signature.toString("hex"),
@@ -652,7 +808,7 @@ function useWalletAPIServer({ walletState, manifest, accounts, tracking, config,
         });
     }, [uiExchangeComplete, accounts, manifest, server, tracking]);
     return {
-        widgetLoaded,
+        widgetLoaded: widgetLoaded,
         onMessage,
         onLoad,
         onReload,
@@ -776,9 +932,9 @@ function useRecentlyUsed(manifests, [recentlyUsedManifestsDb, setState]) {
                 ...res,
                 usedAt: calculateTimeDiff(recentlyUsed.usedAt),
             }
-            : res;
+            : undefined;
     })
-        .filter(manifest => manifest !== undefined), [recentlyUsedManifestsDb, manifests]);
+        .filter((manifest) => manifest !== undefined), [recentlyUsedManifestsDb, manifests]);
     const append = (0, react_1.useCallback)((manifest) => {
         setState(state => {
             const index = state.recentlyUsed.findIndex(({ id }) => id === manifest.id);