@ledgerhq/live-common 27.0.0 → 27.0.1-next.0

package/src/platform/logic.ts

@@ -1,4 +1,289 @@
+import {
+  Account,
+  AccountLike,
+  Operation,
+  SignedOperation,
+  TransactionCommon,
+} from "@ledgerhq/types-live";
+
+import {
+  accountToPlatformAccount,
+  getPlatformTransactionSignFlowInfos,
+} from "./converters";
+import {
+  RawPlatformTransaction,
+  RawPlatformSignedTransaction,
+} from "./rawTypes";
+import {
+  deserializePlatformTransaction,
+  deserializePlatformSignedTransaction,
+} from "./serializers";
+import type { TrackFunction } from "./tracking";
+import { AppManifest } from "./types";
+import { isTokenAccount, getMainAccount, isAccount } from "../account/index";
+import { getAccountBridge } from "../bridge/index";
+import { Transaction } from "../generated/types";
+import { MessageData } from "../hw/signMessage/types";
+import { prepareMessageToSign } from "../hw/signMessage/index";
+
 export function translateContent(content: any, locale = "en"): string {
   if (!content || typeof content !== "object") return content;
   return content[locale] || content.en;
 }
+
+export type WebPlatformContext = {
+  manifest: AppManifest;
+  accounts: AccountLike[];
+  tracking: Record<string, TrackFunction>;
+};
+
+function getParentAccount(
+  account: AccountLike,
+  fromAccounts: AccountLike[]
+): Account | null {
+  return isTokenAccount(account)
+    ? (fromAccounts.find((a) => a.id === account.parentId) as Account)
+    : null;
+}
+
+export function receiveOnAccountLogic(
+  { manifest, accounts, tracking }: WebPlatformContext,
+  accountId: string,
+  uiNavigation: (
+    account: AccountLike,
+    parentAccount: Account | null,
+    accountAddress: string
+  ) => Promise<string>
+): Promise<string> {
+  tracking.platformReceiveRequested(manifest);
+
+  const account = accounts.find((account) => account.id === accountId);
+
+  if (!account) {
+    tracking.platformReceiveFail(manifest);
+    return Promise.reject(new Error("Account required"));
+  }
+
+  const parentAccount = getParentAccount(account, accounts);
+  const accountAddress = accountToPlatformAccount(
+    account,
+    parentAccount ?? undefined //FIXME-STP
+  ).address;
+
+  return uiNavigation(account, parentAccount, accountAddress);
+}
+
+export function signTransactionLogic(
+  { manifest, accounts, tracking }: WebPlatformContext,
+  accountId: string,
+  transaction: RawPlatformTransaction,
+  uiNavigation: (
+    account: AccountLike,
+    parentAccount: Account | null,
+    signFlowInfos: {
+      canEditFees: boolean;
+      hasFeesProvided: boolean;
+      liveTx: Partial<Transaction>;
+    }
+  ) => Promise<RawPlatformSignedTransaction>
+): Promise<RawPlatformSignedTransaction> {
+  tracking.platformSignTransactionRequested(manifest);
+
+  if (!transaction) {
+    tracking.platformSignTransactionFail(manifest);
+    return Promise.reject(new Error("Transaction required"));
+  }
+
+  const platformTransaction = deserializePlatformTransaction(transaction);
+  const account = accounts.find((account) => account.id === accountId);
+
+  if (!account) {
+    tracking.platformSignTransactionFail(manifest);
+    return Promise.reject(new Error("Account required"));
+  }
+
+  const parentAccount = getParentAccount(account, accounts);
+
+  if (
+    (isTokenAccount(account)
+      ? parentAccount?.currency.family
+      : account.currency.family) !== platformTransaction.family
+  ) {
+    return Promise.reject(
+      new Error("Transaction family not matching account currency family")
+    );
+  }
+
+  const { canEditFees, liveTx, hasFeesProvided } =
+    getPlatformTransactionSignFlowInfos(platformTransaction);
+
+  return uiNavigation(account, parentAccount, {
+    canEditFees,
+    liveTx,
+    hasFeesProvided,
+  });
+}
+
+export function broadcastTransactionLogic(
+  { manifest, accounts, tracking }: WebPlatformContext,
+  accountId: string,
+  signedTransaction: RawPlatformSignedTransaction,
+  uiNavigation: (
+    account: AccountLike,
+    parentAccount: Account | null,
+    signedOperation: SignedOperation
+  ) => Promise<string>
+): Promise<string> {
+  if (!signedTransaction) {
+    tracking.platformBroadcastFail(manifest);
+    return Promise.reject(new Error("Transaction required"));
+  }
+
+  const account = accounts.find((account) => account.id === accountId);
+  if (!account) {
+    tracking.platformBroadcastFail(manifest);
+    return Promise.reject(new Error("Account required"));
+  }
+
+  const parentAccount = getParentAccount(account, accounts);
+
+  const signedOperation = deserializePlatformSignedTransaction(
+    signedTransaction,
+    accountId
+  );
+
+  return uiNavigation(account, parentAccount, signedOperation);
+}
+
+export type CompleteExchangeRequest = {
+  provider: string;
+  fromAccountId: string;
+  toAccountId: string;
+  transaction: RawPlatformTransaction;
+  binaryPayload: string;
+  signature: string;
+  feesStrategy: string;
+  exchangeType: number;
+};
+export type CompleteExchangeUiRequest = {
+  provider: string;
+  exchange: {
+    fromAccount: AccountLike;
+    fromParentAccount: Account | null;
+    toAccount?: AccountLike;
+    toParentAccount: Account | null;
+  };
+  transaction: TransactionCommon;
+  binaryPayload: string;
+  signature: string;
+  feesStrategy: string;
+  exchangeType: number;
+};
+export function completeExchangeLogic(
+  { manifest, accounts, tracking }: WebPlatformContext,
+  {
+    provider,
+    fromAccountId,
+    toAccountId,
+    transaction,
+    binaryPayload,
+    signature,
+    feesStrategy,
+    exchangeType,
+  }: CompleteExchangeRequest,
+  uiNavigation: (request: CompleteExchangeUiRequest) => Promise<Operation>
+): Promise<Operation> {
+  tracking.platformCompleteExchangeRequested(manifest);
+
+  // Nb get a hold of the actual accounts, and parent accounts
+  const fromAccount = accounts.find((a) => a.id === fromAccountId);
+
+  const toAccount = accounts.find((a) => a.id === toAccountId);
+
+  if (!fromAccount) {
+    return Promise.reject();
+  }
+
+  if (exchangeType === 0x00 && !toAccount) {
+    // if we do a swap, a destination account must be provided
+    return Promise.reject();
+  }
+
+  const fromParentAccount = getParentAccount(fromAccount, accounts);
+  const toParentAccount = toAccount
+    ? getParentAccount(toAccount, accounts)
+    : null;
+  const exchange = {
+    fromAccount,
+    fromParentAccount,
+    toAccount,
+    toParentAccount,
+  };
+
+  const accountBridge = getAccountBridge(fromAccount, fromParentAccount);
+  const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
+
+  if (transaction.family !== mainFromAccount.currency.family) {
+    return Promise.reject(
+      new Error("Account and transaction must be from the same family")
+    );
+  }
+
+  const platformTransaction = deserializePlatformTransaction(transaction);
+  const { liveTx: liveTransaction } =
+    getPlatformTransactionSignFlowInfos(platformTransaction);
+
+  let processedTransaction = accountBridge.createTransaction(mainFromAccount);
+  processedTransaction = accountBridge.updateTransaction(
+    {
+      ...processedTransaction,
+      recipient: liveTransaction.recipient,
+    },
+    {
+      ...liveTransaction,
+      feesStrategy,
+    }
+  );
+
+  return uiNavigation({
+    provider,
+    exchange,
+    transaction: processedTransaction,
+    binaryPayload,
+    signature,
+    feesStrategy,
+    exchangeType,
+  });
+}
+
+export function signMessageLogic(
+  { manifest, accounts, tracking }: WebPlatformContext,
+  accountId: string,
+  message: string,
+  uiNavigation: (
+    account: AccountLike,
+    message: MessageData | null
+  ) => Promise<string>
+): Promise<string> {
+  tracking.platformSignMessageRequested(manifest);
+
+  const account = accounts.find((account) => account.id === accountId);
+  if (account === undefined) {
+    tracking.platformSignMessageFail(manifest);
+    return Promise.reject(new Error("account not found"));
+  }
+
+  let formattedMessage: MessageData | null;
+  try {
+    if (isAccount(account)) {
+      formattedMessage = prepareMessageToSign(account, message);
+    } else {
+      throw new Error("account provided should be the main one");
+    }
+  } catch (error) {
+    tracking.platformSignMessageFail(manifest);
+    return Promise.reject(error);
+  }
+
+  return uiNavigation(account, formattedMessage);
+}

package/src/platform/react.ts

@@ -20,6 +20,12 @@ import {
 import { getParentAccount } from "../account";
 import { listCurrencies } from "../currencies";
 
+/**
+ * TODO: we might want to use "searchParams.append" instead of "searchParams.set"
+ * to handle duplicated query params (example: "?foo=bar&foo=baz")
+ *
+ * We can also use the stringify method of qs (https://github.com/ljharb/qs#stringifying)
+ */
 export function usePlatformUrl(
   manifest: AppManifest,
   params: { background: string; text: string; loadDate?: Date },

package/src/platform/tracking.test.ts

@@ -2,7 +2,7 @@ import trackingWrapper from "./tracking";
 import { AppManifest } from "./types";
 
 describe("trackingWrapper", () => {
-  const methodToMessage = [
+  test.each([
     {
       method: "platformLoad",
       message: "Platform Load",
@@ -107,10 +107,9 @@ describe("trackingWrapper", () => {
       method: "platformSignMessageUserRefused",
       message: "Platform sign message user refused",
     },
-  ];
-
-  for (const { method, message } of methodToMessage) {
-    it(`calls once inner trackPlatform function ${method} with event named: ${message}`, () => {
+  ])(
+    "calls once inner trackPlatform function $method with event named: $message",
+    ({ method, message }) => {
       // Given
       const appManifest = appManifestFixture();
       const mockedTrack = jest.fn();
@@ -127,8 +126,8 @@ describe("trackingWrapper", () => {
         },
         null
       );
-    });
-  }
+    }
+  );
 });
 
 function appManifestFixture(name = "live-app"): AppManifest {

package/src/platform/tracking.ts

@@ -11,7 +11,7 @@ type TrackPlatform = (
   mandatory: boolean | null
 ) => void;
 
-type TrackFunction = (manifest: AppManifest) => void;
+export type TrackFunction = (manifest: AppManifest) => void;
 
 /**
  * Obtain Event data from Platform App manifest

package/src/reconciliation.ts

@@ -20,17 +20,22 @@ import {
   fromCosmosResourcesRaw,
   fromBitcoinResourcesRaw,
   fromAlgorandResourcesRaw,
+  fromCardanoResourceRaw,
   fromPolkadotResourcesRaw,
   fromTezosResourcesRaw,
   fromElrondResourcesRaw,
   fromCryptoOrgResourcesRaw,
   fromSolanaResourcesRaw,
   fromNFTRaw,
-  fromCardanoResourceRaw,
+  toTronResourcesRaw,
+  toCosmosResourcesRaw,
+  toAlgorandResourcesRaw,
+  toCardanoResourceRaw,
+  toPolkadotResourcesRaw,
+  toTezosResourcesRaw,
+  toElrondResourcesRaw,
   toCryptoOrgResourcesRaw,
   toSolanaResourcesRaw,
-  toCosmosResourcesRaw,
-  toTronResourcesRaw,
 } from "./account";
 import consoleWarnExpectToEqual from "./consoleWarnExpectToEqual";
 import { AlgorandAccount, AlgorandAccountRaw } from "./families/algorand/types";
@@ -288,6 +293,13 @@ export function patchAccount(
     }
   }
 
+  // TODO This will be reworked to belong in each coin family
+  // Temporary logic to patch resources for each coin is:
+  // - there is raw data to patch from
+  // AND
+  //   - there is no current account data
+  //   OR
+  //   - current account data is different
   switch (account.currency.family) {
     case "tron":
       {
@@ -295,10 +307,11 @@ export function patchAccount(
         const tronUpdatedRaw = updatedRaw as TronAccountRaw;
         if (
           tronUpdatedRaw.tronResources &&
-          !areSameResources(
-            toTronResourcesRaw(tronAcc.tronResources),
-            tronUpdatedRaw.tronResources
-          )
+          (!tronAcc.tronResources ||
+            !areSameResources(
+              toTronResourcesRaw(tronAcc.tronResources),
+              tronUpdatedRaw.tronResources
+            ))
         ) {
           (next as TronAccount).tronResources = fromTronResourcesRaw(
             tronUpdatedRaw.tronResources
@@ -312,10 +325,11 @@ export function patchAccount(
       const cosmosUpdatedRaw = updatedRaw as CosmosAccountRaw;
       if (
         cosmosUpdatedRaw.cosmosResources &&
-        !areSameResources(
-          toCosmosResourcesRaw(cosmosAcc.cosmosResources),
-          cosmosUpdatedRaw.cosmosResources
-        )
+        (!cosmosAcc.cosmosResources ||
+          !areSameResources(
+            toCosmosResourcesRaw(cosmosAcc.cosmosResources),
+            cosmosUpdatedRaw.cosmosResources
+          ))
       ) {
         (next as CosmosAccount).cosmosResources = fromCosmosResourcesRaw(
           cosmosUpdatedRaw.cosmosResources
@@ -328,10 +342,12 @@ export function patchAccount(
       const cosmosAcc = account as CosmosAccount;
       const cosmosUpdatedRaw = updatedRaw as CosmosAccountRaw;
       if (
-        !areSameResources(
-          toCosmosResourcesRaw(cosmosAcc.cosmosResources),
-          cosmosUpdatedRaw.cosmosResources
-        )
+        cosmosUpdatedRaw.cosmosResources &&
+        (!cosmosAcc.cosmosResources ||
+          !areSameResources(
+            toCosmosResourcesRaw(cosmosAcc.cosmosResources),
+            cosmosUpdatedRaw.cosmosResources
+          ))
       ) {
         (next as CosmosAccount).cosmosResources = fromCosmosResourcesRaw(
           cosmosUpdatedRaw.cosmosResources
@@ -345,10 +361,11 @@ export function patchAccount(
       const algorandUpdatedRaw = updatedRaw as AlgorandAccountRaw;
       if (
         algorandUpdatedRaw.algorandResources &&
-        !areSameResources(
-          algorandAcc.algorandResources,
-          algorandUpdatedRaw.algorandResources
-        )
+        (!algorandAcc.algorandResources ||
+          !areSameResources(
+            toAlgorandResourcesRaw(algorandAcc.algorandResources),
+            algorandUpdatedRaw.algorandResources
+          ))
       ) {
         (next as AlgorandAccount).algorandResources = fromAlgorandResourcesRaw(
           algorandUpdatedRaw.algorandResources
@@ -370,10 +387,11 @@ export function patchAccount(
       const polkadotUpdatedRaw = updatedRaw as PolkadotAccountRaw;
       if (
         polkadotUpdatedRaw.polkadotResources &&
-        !areSameResources(
-          polkadotAcc.polkadotResources,
-          polkadotUpdatedRaw.polkadotResources
-        )
+        (!polkadotAcc.polkadotResources ||
+          !areSameResources(
+            toPolkadotResourcesRaw(polkadotAcc.polkadotResources),
+            polkadotUpdatedRaw.polkadotResources
+          ))
       ) {
         (next as PolkadotAccount).polkadotResources = fromPolkadotResourcesRaw(
           polkadotUpdatedRaw.polkadotResources
@@ -387,10 +405,11 @@ export function patchAccount(
       const tezosUpdatedRaw = updatedRaw as TezosAccountRaw;
       if (
         tezosUpdatedRaw.tezosResources &&
-        !areSameResources(
-          tezosAcc.tezosResources,
-          tezosUpdatedRaw.tezosResources
-        )
+        (!tezosAcc.tezosResources ||
+          !areSameResources(
+            toTezosResourcesRaw(tezosAcc.tezosResources),
+            tezosUpdatedRaw.tezosResources
+          ))
       ) {
         (next as TezosAccount).tezosResources = fromTezosResourcesRaw(
           tezosUpdatedRaw.tezosResources
@@ -404,10 +423,11 @@ export function patchAccount(
       const elrondUpdatedRaw = updatedRaw as ElrondAccountRaw;
       if (
         elrondUpdatedRaw.elrondResources &&
-        areSameResources(
-          elrondAcc.elrondResources,
-          elrondUpdatedRaw.elrondResources
-        )
+        (!elrondAcc.elrondResources ||
+          !areSameResources(
+            toElrondResourcesRaw(elrondAcc.elrondResources),
+            elrondUpdatedRaw.elrondResources
+          ))
       ) {
         (next as ElrondAccount).elrondResources = fromElrondResourcesRaw(
           elrondUpdatedRaw.elrondResources
@@ -421,10 +441,11 @@ export function patchAccount(
       const cardanoUpdatedRaw = updatedRaw as CardanoAccountRaw;
       if (
         cardanoUpdatedRaw.cardanoResources &&
-        !areSameResources(
-          cardanoAcc.cardanoResources,
-          cardanoUpdatedRaw.cardanoResources
-        )
+        (!cardanoAcc.cardanoResources ||
+          !areSameResources(
+            toCardanoResourceRaw(cardanoAcc.cardanoResources),
+            cardanoUpdatedRaw.cardanoResources
+          ))
       ) {
         (next as CardanoAccount).cardanoResources = fromCardanoResourceRaw(
           cardanoUpdatedRaw.cardanoResources
@@ -438,10 +459,11 @@ export function patchAccount(
       const cryptoOrgUpdatedRaw = updatedRaw as CryptoOrgAccountRaw;
       if (
         cryptoOrgUpdatedRaw.cryptoOrgResources &&
-        !areSameResources(
-          toCryptoOrgResourcesRaw(cryptoOrgAcc.cryptoOrgResources),
-          cryptoOrgUpdatedRaw.cryptoOrgResources
-        )
+        (!cryptoOrgAcc.cryptoOrgResources ||
+          !areSameResources(
+            toCryptoOrgResourcesRaw(cryptoOrgAcc.cryptoOrgResources),
+            cryptoOrgUpdatedRaw.cryptoOrgResources
+          ))
       ) {
         (next as CryptoOrgAccount).cryptoOrgResources =
           fromCryptoOrgResourcesRaw(cryptoOrgUpdatedRaw.cryptoOrgResources);
@@ -455,10 +477,11 @@ export function patchAccount(
 
       if (
         solanaUpdatedRaw.solanaResources &&
-        !areSameResources(
-          toSolanaResourcesRaw(solanaAcc.solanaResources),
-          solanaUpdatedRaw.solanaResources
-        )
+        (!solanaAcc.solanaResources ||
+          !areSameResources(
+            toSolanaResourcesRaw(solanaAcc.solanaResources),
+            solanaUpdatedRaw.solanaResources
+          ))
       ) {
         (next as SolanaAccount).solanaResources = fromSolanaResourcesRaw(
           solanaUpdatedRaw.solanaResources

package/lib/bot/test.bot.d.ts

@@ -1,2 +0,0 @@
-import "../__tests__/test-helpers/setup";
-//# sourceMappingURL=test.bot.d.ts.map

package/lib/bot/test.bot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.bot.d.ts","sourceRoot":"","sources":["../../src/bot/test.bot.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/lib/bot/test.bot.js

@@ -1,62 +0,0 @@
-"use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-exports.__esModule = true;
-require("../__tests__/test-helpers/setup");
-var _1 = require(".");
-jest.setTimeout(110 * 60 * 1000);
-var _a = process.env, BOT_FILTER_CURRENCY = _a.BOT_FILTER_CURRENCY, BOT_FILTER_FAMILY = _a.BOT_FILTER_FAMILY;
-test("bot", function () { return __awaiter(void 0, void 0, void 0, function () {
-    var arg;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                arg = {};
-                if (BOT_FILTER_CURRENCY) {
-                    arg.currency = BOT_FILTER_CURRENCY;
-                }
-                if (BOT_FILTER_FAMILY) {
-                    arg.family = BOT_FILTER_FAMILY;
-                }
-                return [4 /*yield*/, (0, _1.bot)(arg)];
-            case 1:
-                _a.sent();
-                return [2 /*return*/];
-        }
-    });
-}); });
-//# sourceMappingURL=test.bot.js.map

package/lib/bot/test.bot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.bot.js","sourceRoot":"","sources":["../../src/bot/test.bot.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAAyC;AACzC,sBAAwB;AAExB,IAAI,CAAC,UAAU,CAAC,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;AAC3B,IAAA,KAA6C,OAAO,CAAC,GAAG,EAAtD,mBAAmB,yBAAA,EAAE,iBAAiB,uBAAgB,CAAC;AAC/D,IAAI,CAAC,KAAK,EAAE;;;;;gBACJ,GAAG,GAGL,EAAE,CAAC;gBAEP,IAAI,mBAAmB,EAAE;oBACvB,GAAG,CAAC,QAAQ,GAAG,mBAAmB,CAAC;iBACpC;gBAED,IAAI,iBAAiB,EAAE;oBACrB,GAAG,CAAC,MAAM,GAAG,iBAAiB,CAAC;iBAChC;gBAED,qBAAM,IAAA,MAAG,EAAC,GAAG,CAAC,EAAA;;gBAAd,SAAc,CAAC;;;;KAChB,CAAC,CAAC"}

package/lib/generated/speculos-deviceActions.d.ts

@@ -1,56 +0,0 @@
-declare const _default: {
-    algorand: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/algorand/types").AlgorandTransaction, any>;
-    };
-    bitcoin: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/bitcoin/types").Transaction, any>;
-    };
-    cardano: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/cardano/types").Transaction, any>;
-    };
-    celo: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/celo/types").Transaction, any>;
-    };
-    cosmos: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/cosmos/types").Transaction, any>;
-    };
-    crypto_org: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/crypto_org/types").Transaction, any>;
-    };
-    elrond: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/elrond/types").Transaction, any>;
-    };
-    ethereum: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/ethereum/types").Transaction, any>;
-    };
-    filecoin: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/filecoin/types").Transaction, any>;
-    };
-    hedera: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/hedera/types").Transaction, any>;
-    };
-    osmosis: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/osmosis/types").Transaction, any>;
-    };
-    polkadot: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/polkadot/types").Transaction, any>;
-    };
-    ripple: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/ripple/types").Transaction, any>;
-    };
-    solana: {
-        acceptTransferTransaction: import("../bot/types").DeviceAction<import("../families/solana/types").Transaction, any>;
-        acceptStakeCreateAccountTransaction: import("../bot/types").DeviceAction<import("../families/solana/types").Transaction, any>;
-    };
-    stellar: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/stellar/types").Transaction, any>;
-    };
-    tezos: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/tezos/types").Transaction, any>;
-    };
-    tron: {
-        acceptTransaction: import("../bot/types").DeviceAction<import("../families/tron/types").Transaction, any>;
-    };
-};
-export default _default;
-//# sourceMappingURL=speculos-deviceActions.d.ts.map

package/lib/generated/speculos-deviceActions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"speculos-deviceActions.d.ts","sourceRoot":"","sources":["../../src/generated/speculos-deviceActions.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,wBAkBE"}