@ledgerhq/live-common 34.50.0 → 34.51.0-nightly.1

package/src/__tests__/test-helpers/environment.ts

@@ -120,7 +120,7 @@ setSupportedCurrencies([
   "babylon",
   "canton_network",
   "canton_network_devnet",
-  "canton_network_localnet",
+  "canton_network_testnet",
   "kaspa",
 ]);
 LiveConfig.setConfig(liveConfig);

package/src/bridge/generic-alpaca/alpaca/index.ts

@@ -3,6 +3,7 @@ import { createApi as createStellarApi } from "@ledgerhq/coin-stellar/api/index"
 import { createApi as createCantonApi } from "@ledgerhq/coin-canton/api/index";
 import { createApi as createTronApi } from "@ledgerhq/coin-tron/api/index";
 import { createApi as createEvmApi } from "@ledgerhq/coin-evm/api/index";
+import { createApi as createTezosApi } from "@ledgerhq/coin-tezos/api/index";
 import { getCurrencyConfiguration } from "../../../config";
 import { getNetworkAlpacaApi } from "./network/network-alpaca";
 import { Api } from "@ledgerhq/coin-framework/api/types";
@@ -11,6 +12,7 @@ import { StellarCoinConfig } from "@ledgerhq/coin-stellar/config";
 import { CantonCoinConfig } from "@ledgerhq/coin-canton/config";
 import { TronCoinConfig } from "@ledgerhq/coin-tron/config";
 import { EvmConfigInfo } from "@ledgerhq/coin-evm/config";
+import { TezosCoinConfig } from "@ledgerhq/coin-tezos/config";
 import { findCryptoCurrencyByNetwork } from "../utils";
 
 export function getAlpacaApi(network: string, kind: string): Api<any> {
@@ -30,6 +32,8 @@ export function getAlpacaApi(network: string, kind: string): Api<any> {
           getCurrencyConfiguration<EvmConfigInfo>(currency),
           currency.id,
         ) as Api<any>;
+      case "tezos":
+        return createTezosApi(getCurrencyConfiguration<TezosCoinConfig>(currency)) as Api<any>;
     }
   }
   return getNetworkAlpacaApi(network) satisfies Partial<Api<any>>;

package/src/bridge/generic-alpaca/buildSubAccounts.ts

@@ -55,47 +55,47 @@ function buildTokenAccount({
   };
 }
 
-export function buildSubAccounts({
+export async function buildSubAccounts({
   currency,
   accountId,
-  assetsBalance,
+  allTokenAssetsBalances,
   syncConfig,
   operations,
   getTokenFromAsset,
 }: {
   currency: CryptoCurrency;
   accountId: string;
-  assetsBalance: Balance[];
+  allTokenAssetsBalances: Balance[];
   syncConfig: SyncConfig;
   operations: OperationCommon[];
-  getTokenFromAsset?: (asset: AssetInfo) => TokenCurrency | undefined;
-}): TokenAccount[] | undefined {
+  getTokenFromAsset?: (asset: AssetInfo) => Promise<TokenCurrency | undefined>;
+}): Promise<TokenAccount[]> {
   const { blacklistedTokenIds = [] } = syncConfig;
   const allTokens = listTokensForCryptoCurrency(currency);
+  const tokenAccounts: TokenAccount[] = [];
 
-  if (allTokens.length === 0 || assetsBalance.length === 0) {
-    return undefined;
+  if (allTokens.length === 0 || allTokenAssetsBalances.length === 0) {
+    return tokenAccounts;
   }
-  const tokenAccounts: TokenAccount[] = [];
-  assetsBalance
-    .filter(b => b.asset.type !== "native") // NOTE: this could be removed, keeping here while fixing things up
-    .map(balance => {
-      const token = getTokenFromAsset && getTokenFromAsset(balance.asset);
-      // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
-      if (token && !blacklistedTokenIds.includes(token.id)) {
-        tokenAccounts.push(
-          buildTokenAccount({
-            parentAccountId: accountId,
-            assetBalance: balance,
-            token,
-            operations: operations.filter(
-              op =>
-                op.extra.assetReference === balance.asset?.["assetReference"] &&
-                op.extra.assetOwner === balance.asset?.["assetOwner"], // NOTE: we could narrow type
-            ),
-          }),
-        );
-      }
-    });
+
+  for (const balance of allTokenAssetsBalances) {
+    const token = getTokenFromAsset && (await getTokenFromAsset(balance.asset));
+    // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      tokenAccounts.push(
+        buildTokenAccount({
+          parentAccountId: accountId,
+          assetBalance: balance,
+          token,
+          operations: operations.filter(
+            op =>
+              op.extra.assetReference === balance.asset?.["assetReference"] &&
+              op.extra.assetOwner === balance.asset?.["assetOwner"], // NOTE: we could narrow type
+          ),
+        }),
+      );
+    }
+  }
+
   return tokenAccounts;
 }

package/src/bridge/generic-alpaca/createTransaction.ts

@@ -30,6 +30,17 @@ export function createTransaction(account: Account | TokenAccount): GenericTrans
         assetOwner: "",
         networkInfo: null,
       };
+    case "tezos":
+      // note: default transaction for tezos, mode will be set by UI (send, stake, unstake)
+      return {
+        family: currency.family,
+        amount: new BigNumber(0),
+        fees: null,
+        recipient: "",
+        useAllAmount: false,
+        mode: "send",
+        networkInfo: null,
+      };
     case "evm": {
       return {
         mode: "send-eip1559",

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -1,5 +1,6 @@
 import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
@@ -31,18 +32,25 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
     const balanceRes = await alpacaApi.getBalance(address);
     const nativeAsset = extractBalance(balanceRes, "native");
 
-    const assetsBalance = balanceRes
-      .filter(b => b.asset.type !== "native")
-      .filter(b => alpacaApi.getTokenFromAsset && alpacaApi.getTokenFromAsset(b.asset));
+    const allTokenAssetsBalances = balanceRes.filter(b => b.asset.type !== "native");
     const nativeBalance = BigInt(nativeAsset?.value ?? "0");
 
     const spendableBalance = BigInt(nativeBalance - BigInt(nativeAsset?.locked ?? "0"));
 
-    const oldOps = (initialAccount?.operations || []) as OperationCommon[];
+    // Normalize pre-alpaca operations to the new accountId to keep UI rendering consistent
+    const oldOps = ((initialAccount?.operations || []) as OperationCommon[]).map(op =>
+      op.accountId === accountId
+        ? op
+        : { ...op, accountId, id: encodeOperationId(accountId, op.hash, op.type) },
+    );
     const lastPagingToken = oldOps[0]?.extra?.pagingToken || "";
 
-    const blockHeight = oldOps.length ? (oldOps[0].blockHeight ?? 0) + 1 : 0;
-    const paginationParams: Pagination = { minHeight: blockHeight, order: "asc" };
+    // Calculate minHeight for pagination
+    let minHeight: number = 0;
+    if (oldOps.length > 0 && initialAccount?.blockHeight !== 0) {
+      minHeight = (oldOps[0].blockHeight ?? 0) + 1;
+    }
+    const paginationParams: Pagination = { minHeight, order: "asc" };
     if (lastPagingToken) {
       paginationParams.lastPagingToken = lastPagingToken;
     }
@@ -64,15 +72,14 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
       }
     });
 
-    const subAccounts =
-      buildSubAccounts({
-        currency,
-        accountId,
-        assetsBalance,
-        syncConfig,
-        operations: assetOperations,
-        getTokenFromAsset: alpacaApi.getTokenFromAsset,
-      }) || [];
+    const subAccounts = await buildSubAccounts({
+      currency,
+      accountId,
+      allTokenAssetsBalances,
+      syncConfig,
+      operations: assetOperations,
+      getTokenFromAsset: alpacaApi.getTokenFromAsset,
+    });
 
     const operations = mergedOps.map(op => {
       const subOperations = inferSubOperations(op.hash, subAccounts);

package/src/bridge/generic-alpaca/getTransactionStatus.ts

@@ -13,7 +13,7 @@ export function genericGetTransactionStatus(
   return async (account, transaction: GenericTransaction) => {
     const alpacaApi = getAlpacaApi(account.currency.id, kind);
     const draftTransaction = {
-      mode: transaction?.mode,
+      mode: transaction?.mode ?? "send",
       recipient: transaction.recipient,
       amount: transaction.amount ?? new BigNumber(0),
       useAllAmount: !!transaction.useAllAmount,

package/src/bridge/generic-alpaca/prepareTransaction.ts

@@ -26,15 +26,15 @@ export function genericPrepareTransaction(
   kind,
 ): AccountBridge<GenericTransaction, Account>["prepareTransaction"] {
   return async (account, transaction: GenericTransaction) => {
-    const { getAssetFromToken, computeIntentType, estimateFees } = getAlpacaApi(
+    const { getAssetFromToken, computeIntentType, estimateFees, validateIntent } = getAlpacaApi(
       account.currency.id,
       kind,
     );
     const { assetReference, assetOwner } = getAssetFromToken
       ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
-
-    let fees: BigNumber | bigint | null = transaction.customFees?.parameters?.fees || null;
+    const customParametersFees = transaction.customFees?.parameters?.fees;
+    let fees: BigNumber | bigint | null = customParametersFees || null;
     if (fees === null) {
       fees = (
         await estimateFees(
@@ -50,17 +50,59 @@ export function genericPrepareTransaction(
     }
 
     if (!bnEq(transaction.fees, new BigNumber(fees.toString()))) {
-      return {
+      const next: GenericTransaction = {
         ...transaction,
         fees: new BigNumber(fees.toString()),
         assetReference,
         assetOwner,
         customFees: {
           parameters: {
-            fees: new BigNumber(fees.toString()),
+            fees: customParametersFees ? new BigNumber(customParametersFees.toString()) : undefined,
           },
         },
       };
+
+      // propagate storageLimit fee parameter when present (ex: tezos)
+      const feeEstimation = await estimateFees(
+        transactionToIntent(
+          account,
+          {
+            ...transaction,
+          },
+          computeIntentType,
+        ),
+      );
+      const params = feeEstimation?.parameters;
+      if (params) {
+        const storageLimit = params["storageLimit"];
+        if (
+          storageLimit !== undefined &&
+          (typeof storageLimit === "bigint" ||
+            typeof storageLimit === "number" ||
+            typeof storageLimit === "string")
+        ) {
+          next.storageLimit = new BigNumber(storageLimit.toString());
+        }
+      }
+
+      // align with stellar/xrp: when send max (or staking intents), reflect validated amount in UI
+      if (
+        transaction.useAllAmount ||
+        transaction["mode"] === "stake" ||
+        transaction["mode"] === "unstake"
+      ) {
+        const { amount } = await validateIntent(
+          transactionToIntent(
+            account,
+            {
+              ...transaction,
+            },
+            computeIntentType,
+          ),
+        );
+        next.amount = new BigNumber(amount.toString());
+      }
+      return next;
     }
 
     return transaction;

package/src/bridge/generic-alpaca/signer/index.ts

@@ -1,12 +1,15 @@
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
 import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
 import Stellar from "@ledgerhq/hw-app-str";
-import { signTransaction, stellarSignTransaction } from "./signTransaction";
+import { signTransaction, stellarSignTransaction, tezosSignTransaction } from "./signTransaction";
 import { StrKey } from "@stellar/stellar-sdk";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
 import Transport from "@ledgerhq/hw-transport";
 import { AlpacaSigner } from "./types";
+import { DerivationType, LedgerSigner as TaquitoLedgerSigner } from "@taquito/ledger-signer";
+import tezosGetAddress from "@ledgerhq/coin-tezos/signer/getAddress";
+import Tezos from "@ledgerhq/hw-app-tezos";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -37,6 +40,39 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
+const createSignerTezos: CreateSigner<
+  Tezos & { createLedgerSigner: (path: string, prompt: boolean, derivationType: number) => any }
+> = (transport: Transport) => {
+  const tezos = new Tezos(transport);
+  // align with genericSignOperation that calls signer.signTransaction
+  return Object.assign(tezos, {
+    async signTransaction(path: string, rawTxHex: string) {
+      const { signature } = await tezos.signOperation(path, rawTxHex, {});
+      return signature;
+    },
+    async getAddress(path: string, { verify }: { verify?: boolean } = {}) {
+      // Use Taquito LedgerSigner to retrieve base58 public key and matching pkh (like oldbridge)
+      const ledgerSigner = new TaquitoLedgerSigner(
+        transport,
+        path,
+        !!verify,
+        DerivationType.ED25519,
+      );
+      const address = await ledgerSigner.publicKeyHash();
+      const publicKey = await ledgerSigner.publicKey();
+      return { path, address, publicKey };
+    },
+    createLedgerSigner(path: string, prompt: boolean, derivationType: number) {
+      // Map 0 -> ED25519, 1 -> SECP256K1, 2 -> P256 by convention
+      let dt: DerivationType = DerivationType.ED25519;
+      if (derivationType === 1) dt = DerivationType.SECP256K1;
+      else if (derivationType === 2) dt = DerivationType.P256;
+      return new TaquitoLedgerSigner(transport, path, prompt, dt);
+    },
+  });
+};
+const signerContextTezos = executeWithSigner(createSignerTezos);
+
 export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
@@ -54,6 +90,13 @@ export function getSigner(network: string): AlpacaSigner {
         context: signerContextStellar,
       };
     }
+    case "tezos": {
+      return {
+        getAddress: tezosGetAddress(signerContextTezos),
+        signTransaction: tezosSignTransaction(executeWithSigner(createSignerTezos)),
+        context: signerContextTezos,
+      };
+    }
   }
   throw new Error(`signer for ${network} not implemented`);
 }

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -1,5 +1,6 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
+import { TezosSigner } from "@ledgerhq/coin-tezos/types/signer";
 import { LegacySigner, SignTransactionOptions } from "./types";
 
 export const signTransaction = <Signer extends LegacySigner>(
@@ -23,3 +24,12 @@ export const stellarSignTransaction = (signerContext: SignerContext<StellarSigne
     return signedTx.signature.toString("base64"); // It should return a Buffer
   };
 };
+
+export const tezosSignTransaction = (signerContext: SignerContext<TezosSigner>) => {
+  return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
+    const signed = await signerContext(deviceId, signer =>
+      signer.signOperation(path, rawTxHex, {}),
+    );
+    return signed.signature;
+  };
+};

package/src/bridge/generic-alpaca/tests/estimateMaxSpendable.test.ts

@@ -35,9 +35,23 @@ const dummyAccounts = [
     freshAddress: "s123",
     pendingOperations: [],
   },
+  {
+    id: "js:2:tezos:t123",
+    type: "Account",
+    spendableBalance: new BigNumber(50000000),
+    balance: new BigNumber(60000000),
+    currency: {
+      id: "tezos",
+      family: "tezos",
+      name: "Tezos",
+      units: [{ name: "XTZ", magnitude: 6 }],
+    },
+    freshAddress: "t123",
+    pendingOperations: [],
+  },
 ] as unknown as Account[];
 
-["xrp", "stellar"].forEach((currencyName, idx) => {
+["xrp", "stellar", "tezos"].forEach((currencyName, idx) => {
   describe(`genericEstimateMaxSpendable for ${currencyName}`, () => {
     const dummyAccount = dummyAccounts[idx];
 

package/src/bridge/generic-alpaca/tests/getAccountShape.test.ts

@@ -117,9 +117,11 @@ describe("genericGetAccountShape (stellar & xrp)", () => {
         lastPagingToken: "pt1",
       });
 
-      const assetsBalancePassed = buildSubAccountsMock.mock.calls[0][0].assetsBalance;
-      expect(assetsBalancePassed).toHaveLength(1);
-      expect(assetsBalancePassed[0].asset.symbol).toBe("TOK1");
+      const assetsBalancePassed = buildSubAccountsMock.mock.calls[0][0].allTokenAssetsBalances;
+      expect(assetsBalancePassed).toEqual([
+        { asset: { symbol: "TOK1", type: "token" }, value: "42" },
+        { asset: { symbol: "TOK_IGNORE", type: "token" }, value: "5" },
+      ]);
 
       const assetOpsPassed = buildSubAccountsMock.mock.calls[0][0].operations;
       expect(assetOpsPassed).toHaveLength(1);

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -91,4 +91,82 @@ describe("genericPrepareTransaction", () => {
 
     expect(result).toBe(baseTransaction); // still same reference
   });
+
+  it("propagates storageLimit from second estimation", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 0 },
+    });
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest
+        .fn()
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
+    });
+
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(0),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
+    );
+
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
+  });
+
+  it("propagates storageLimit showing new account scenario", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 277 },
+    });
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest
+        .fn()
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
+    });
+
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(277),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
+    );
+
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
+  });
 });

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -14,7 +14,7 @@ jest.mock("../utils", () => ({
   transactionToIntent: jest.fn(),
 }));
 describe("genericSignOperation", () => {
-  const networks = ["xrp", "stellar"];
+  const networks = ["xrp", "stellar", "tezos"];
   const kind = "local";
 
   const mockSignerContext = jest.fn();

package/src/bridge/generic-alpaca/types.ts

@@ -11,15 +11,23 @@ export type GenericTransaction = TransactionCommon & {
   fees?: BigNumber | null;
   storageLimit?: BigNumber | null;
   customFees?: {
-    parameters: { fees?: BigNumber | null; storageLimit?: BigNumber | null };
+    parameters: { fees?: BigNumber | null };
   };
   tag?: number | null | undefined;
   feeCustomUnit?: Unit | null | undefined;
   memoType?: string | null;
   memoValue?: string | null;
   data?: Buffer;
+  mode?:
+    | "send"
+    | "changeTrust"
+    | "send-legacy"
+    | "send-eip1559"
+    | "delegate"
+    | "stake"
+    | "undelegate"
+    | "unstake";
   type?: number;
-  mode?: "send" | "changeTrust" | "send-legacy" | "send-eip1559";
   assetReference?: string;
   assetOwner?: string;
   networkInfo?: NetworkInfo | null;

package/src/bridge/generic-alpaca/utils.ts

@@ -1,5 +1,5 @@
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
+import { Account, Operation, OperationType } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
 import {
@@ -128,15 +128,18 @@ export function transactionToIntent(
   data?: { type: string; value?: unknown };
 } {
   const intentType = (computeIntentType ?? defaultComputeIntentType)(transaction);
+  const isStaking = ["stake", "unstake"].includes(intentType);
+  const amount = isStaking ? 0n : fromBigNumberToBigInt(transaction.amount, 0n);
+  const useAllAmount = isStaking || !!transaction.useAllAmount;
   const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
     data?: { type: string; value?: unknown };
   } = {
     type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,
-    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
+    amount,
     asset: { type: "native", name: account.currency.name, unit: account.currency.units[0] },
-    useAllAmount: !!transaction.useAllAmount,
+    useAllAmount,
     feesStrategy:
       transaction.feesStrategy === "custom" ? undefined : transaction.feesStrategy ?? undefined,
     data: Buffer.isBuffer(transaction.data)
@@ -171,11 +174,27 @@ export function transactionToIntent(
 
 export const buildOptimisticOperation = (
   account: Account,
-  transaction: TransactionCommon,
+  transaction: GenericTransaction,
   sequenceNumber?: number,
 ): Operation => {
-  const type = transaction["mode"] === "changeTrust" ? "OPT_IN" : "OUT";
-  const fees = BigInt(transaction["fees"]?.toString() || "0");
+  let type: OperationType;
+  switch (transaction.mode) {
+    case "changeTrust":
+      type = "OPT_IN";
+      break;
+    case "delegate":
+    case "stake":
+      type = "DELEGATE";
+      break;
+    case "undelegate":
+    case "unstake":
+      type = "UNDELEGATE";
+      break;
+    default:
+      type = "OUT";
+      break;
+  }
+  const fees = BigInt(transaction.fees?.toString() || "0");
   const { subAccountId } = transaction;
   const { subAccounts } = account;
 

package/src/bridge/impl.ts

@@ -27,6 +27,7 @@ import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
 const alpacaized = {
   xrp: true,
   stellar: true,
+  tezos: true,
 };
 
 // let accountBridgeInstance: AccountBridge<any> | null = null;