@ledgerhq/live-common 34.2.0 → 34.3.0-next.0

package/src/families/tezos/bridge/js.ts

@@ -1,381 +0,0 @@
-// @flow
-import { BigNumber } from "bignumber.js";
-import { TezosToolkit, DEFAULT_FEE, DEFAULT_STORAGE_LIMIT, Estimate } from "@taquito/taquito";
-import { DerivationType } from "@taquito/ledger-signer";
-import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
-import { b58cencode, prefix, Prefix, validateAddress, ValidationResult } from "@taquito/utils";
-import {
-  AmountRequired,
-  NotEnoughBalance,
-  NotEnoughBalanceToDelegate,
-  FeeTooHigh,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  RecommendUndelegation,
-  NotEnoughBalanceBecauseDestinationNotCreated,
-  RecipientRequired,
-  InvalidAddress,
-} from "@ledgerhq/errors";
-import type { CurrencyBridge, AccountBridge, Account, AccountLike } from "@ledgerhq/types-live";
-import { makeSync, makeScanAccounts, makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { getMainAccount } from "../../../account";
-import type { TezosAccount, Transaction, TransactionStatus } from "../types";
-import { getAccountShape } from "../synchronisation";
-import { fetchAllBakers, hydrateBakers, isAccountDelegating } from "../bakers";
-import { getEnv } from "@ledgerhq/live-env";
-import { signOperation } from "../signOperation";
-import { patchOperationWithHash } from "../../../operation";
-import { log } from "@ledgerhq/logs";
-import { InvalidAddressBecauseAlreadyDelegated } from "../../../errors";
-import api from "../api/tzkt";
-import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
-
-const validateRecipient = (currency, recipient) => {
-  let recipientError: Error | null = null;
-  const recipientWarning = null;
-  if (!recipient) {
-    recipientError = new RecipientRequired("");
-  } else if (validateAddress(recipient) !== ValidationResult.VALID) {
-    recipientError = new InvalidAddress(undefined, {
-      currencyName: currency.name,
-    });
-  }
-  return Promise.resolve({ recipientError, recipientWarning });
-};
-
-const receive = makeAccountBridgeReceive();
-
-const EXISTENTIAL_DEPOSIT = new BigNumber(275000);
-
-const createTransaction: () => Transaction = () => ({
-  family: "tezos",
-  mode: "send",
-  amount: new BigNumber(0),
-  fees: null,
-  gasLimit: null,
-  storageLimit: null,
-  recipient: "",
-  networkInfo: null,
-  useAllAmount: false,
-  taquitoError: null,
-  estimatedFees: null,
-});
-
-const getTransactionStatus = async (
-  account: TezosAccount,
-  t: Transaction,
-): Promise<TransactionStatus> => {
-  const errors: {
-    recipient?: Error;
-    amount?: Error;
-    fees?: Error;
-  } = {};
-
-  const warnings: {
-    amount?: Error;
-    feeTooHigh?: Error;
-    recipient?: Error;
-  } = {};
-  let resetTotalSpent = false;
-
-  // Recipient validation logic
-  if (t.mode !== "undelegate") {
-    if (account.freshAddress === t.recipient) {
-      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-    } else {
-      const { recipientError, recipientWarning } = await validateRecipient(
-        account.currency,
-        t.recipient,
-      );
-      if (recipientError) {
-        errors.recipient = recipientError;
-      }
-      if (recipientWarning) {
-        warnings.recipient = recipientWarning;
-      }
-    }
-  }
-
-  // Pre validation of amount field
-  const estimatedFees = t.estimatedFees || new BigNumber(0);
-  if (t.mode === "send") {
-    if (!errors.amount && t.amount.eq(0) && !t.useAllAmount) {
-      resetTotalSpent = true;
-      errors.amount = new AmountRequired();
-    } else if (t.amount.gt(0) && estimatedFees.times(10).gt(t.amount)) {
-      warnings.feeTooHigh = new FeeTooHigh();
-    }
-    const thresholdWarning = 0.5 * 10 ** account.currency.units[0].magnitude;
-    if (
-      !errors.amount &&
-      account.balance.minus(t.amount).minus(estimatedFees).lt(thresholdWarning)
-    ) {
-      if (isAccountDelegating(account)) {
-        if (t.useAllAmount) {
-          errors.amount = new RecommendUndelegation();
-        } else {
-          warnings.amount = new RecommendUndelegation();
-        }
-      }
-    }
-  }
-
-  // effective amount
-  // if we also have taquitoError, we interprete them and they override the previously inferred errors
-  if (t.taquitoError) {
-    log("taquitoerror", String(t.taquitoError));
-
-    // remap taquito errors
-    if (
-      t.taquitoError.endsWith("balance_too_low") ||
-      t.taquitoError.endsWith("subtraction_underflow")
-    ) {
-      if (t.mode === "send") {
-        resetTotalSpent = true;
-        errors.amount = new NotEnoughBalance();
-      } else {
-        errors.amount = new NotEnoughBalanceToDelegate();
-      }
-    } else if (t.taquitoError.endsWith("delegate.unchanged")) {
-      errors.recipient = new InvalidAddressBecauseAlreadyDelegated();
-    } else if (!errors.amount) {
-      // unidentified error case
-      errors.amount = new Error(t.taquitoError);
-      resetTotalSpent = true;
-    }
-  }
-
-  if (!errors.amount && account.balance.lte(0)) {
-    resetTotalSpent = true;
-    errors.amount = new NotEnoughBalance();
-  }
-
-  // Catch a specific case that requires a minimum amount
-  if (
-    !errors.amount &&
-    t.mode === "send" &&
-    t.amount.lt(EXISTENTIAL_DEPOSIT) &&
-    (await api.getAccountByAddress(t.recipient)).type === "empty"
-  ) {
-    resetTotalSpent = true;
-    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
-      minimalAmount: "0.275 XTZ",
-    });
-  }
-
-  const result = {
-    errors,
-    warnings,
-    estimatedFees,
-    amount: t.amount,
-    totalSpent: resetTotalSpent ? new BigNumber(0) : t.amount.plus(estimatedFees),
-  };
-  return Promise.resolve(result);
-};
-
-const prepareTransaction = async (
-  account: TezosAccount,
-  transaction: Transaction,
-): Promise<Transaction> => {
-  const { tezosResources } = account;
-  if (!tezosResources) throw new Error("tezosResources is missing");
-
-  if (account.balance.lte(0)) {
-    return Promise.resolve(transaction);
-  }
-
-  // basic check to confirm the transaction is "complete"
-  if (transaction.mode !== "undelegate") {
-    if (!transaction.recipient) {
-      return Promise.resolve(transaction);
-    }
-
-    const { recipientError } = await validateRecipient(account.currency, transaction.recipient);
-    if (recipientError) {
-      return Promise.resolve(transaction);
-    }
-  }
-
-  const encodedPubKey = b58cencode(
-    compressPublicKey(Buffer.from(account.xpub || "", "hex"), DerivationType.ED25519),
-    prefix[Prefix.EDPK],
-  );
-
-  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
-
-  tezos.setProvider({
-    signer: {
-      publicKeyHash: async () => account.freshAddress,
-      publicKey: async () => encodedPubKey,
-      sign: () => Promise.reject(new Error("unsupported")),
-      secretKey: () => Promise.reject(new Error("unsupported")),
-    },
-  });
-
-  const tx: Transaction = { ...transaction, taquitoError: null };
-
-  let amount = transaction.amount;
-  if (transaction.useAllAmount) {
-    amount = new BigNumber(1); // send max do a pre-estimation with minimum amount (taquito refuses 0)
-  }
-
-  try {
-    let estimate: Estimate;
-    switch (transaction.mode) {
-      case "send":
-        estimate = await tezos.estimate.transfer({
-          mutez: true,
-          to: transaction.recipient,
-          amount: amount.toNumber(),
-          storageLimit: DEFAULT_STORAGE_LIMIT.ORIGINATION, // https://github.com/TezTech/eztz/blob/master/PROTO_003_FEES.md for originating an account
-        });
-        break;
-      case "delegate":
-        estimate = await tezos.estimate.setDelegate({
-          source: account.freshAddress,
-          delegate: transaction.recipient,
-        });
-        break;
-      case "undelegate":
-        estimate = await tezos.estimate.setDelegate({
-          source: account.freshAddress,
-        });
-        break;
-      default:
-        throw new Error("unsupported mode=" + transaction.mode);
-    }
-
-    if (tx.useAllAmount) {
-      const totalFees = estimate.suggestedFeeMutez + estimate.burnFeeMutez;
-      const maxAmount = account.balance
-        .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
-        .toNumber();
-      // from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
-      // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
-      // we need to increase the gasLimit and fee returned by the estimation
-      const gasBuffer = 500;
-      const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
-      const increasedFee = (gasBuffer: number, opSize: number) => {
-        return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
-      };
-      const incr = increasedFee(gasBuffer, Number(estimate.opSize));
-      tx.fees = new BigNumber(estimate.suggestedFeeMutez + incr);
-      tx.gasLimit = new BigNumber(estimate.gasLimit + gasBuffer);
-      tx.amount = maxAmount - incr > 0 ? new BigNumber(maxAmount - incr) : new BigNumber(0);
-    } else {
-      tx.fees = new BigNumber(estimate.suggestedFeeMutez);
-      tx.gasLimit = new BigNumber(estimate.gasLimit);
-      tx.storageLimit = new BigNumber(estimate.storageLimit);
-    }
-
-    tx.storageLimit = new BigNumber(estimate.storageLimit);
-    tx.estimatedFees = tx.fees;
-    if (!tezosResources.revealed) {
-      tx.estimatedFees = tx.estimatedFees.plus(DEFAULT_FEE.REVEAL);
-    }
-  } catch (e) {
-    if (typeof e !== "object" || !e) throw e;
-    if ("id" in e) {
-      tx.taquitoError = (e as { id: string }).id;
-      log("taquito-error", "taquito got error " + tx.taquitoError);
-    } else if ("status" in e) {
-      // in case of http 400, log & ignore (more case to handle)
-      log("taquito-network-error", String((e as unknown as { message: string }).message || ""), {
-        transaction: tx,
-      });
-      throw e;
-    } else {
-      throw e;
-    }
-  }
-
-  // nothing changed
-  if (
-    bnEq(tx.estimatedFees, transaction.estimatedFees) &&
-    bnEq(tx.fees, transaction.fees) &&
-    bnEq(tx.gasLimit, transaction.gasLimit) &&
-    bnEq(tx.storageLimit, transaction.storageLimit) &&
-    bnEq(tx.amount, transaction.amount) &&
-    tx.taquitoError === transaction.taquitoError
-  ) {
-    return transaction;
-  }
-
-  return tx;
-};
-
-function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
-  return !a && !b ? true : !a || !b ? false : a.eq(b);
-}
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account | undefined;
-  transaction: Transaction;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount) as TezosAccount;
-  const t = await prepareTransaction(mainAccount, {
-    ...createTransaction(),
-    ...transaction,
-    // estimate using a burn address that exists so we don't enter into NotEnoughBalanceBecauseDestinationNotCreated
-    recipient: transaction?.recipient || "tz1burnburnburnburnburnburnburjAYjjX",
-    useAllAmount: true,
-  });
-  const s = await getTransactionStatus(mainAccount, t);
-  return s.amount;
-};
-
-const broadcast = async ({ signedOperation: { operation, signature } }) => {
-  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
-  const { rpc } = tezos;
-  const hash = await rpc.injectOperation(signature);
-
-  return patchOperationWithHash(operation, hash);
-};
-
-const scanAccounts = makeScanAccounts({ getAccountShape });
-
-const sync = makeSync({ getAccountShape });
-
-const getPreloadStrategy = _currency => ({
-  preloadMaxAge: 30 * 1000,
-});
-
-const preload = async () => {
-  const bakers = await fetchAllBakers();
-  return { bakers };
-};
-
-const hydrate = (data: any) => {
-  if (!data || typeof data !== "object") return;
-  const { bakers } = data;
-  if (!bakers || typeof bakers !== "object" || !Array.isArray(bakers)) return;
-  hydrateBakers(bakers);
-};
-
-const currencyBridge: CurrencyBridge = {
-  getPreloadStrategy,
-  preload,
-  hydrate,
-  scanAccounts,
-};
-
-const accountBridge: AccountBridge<Transaction> = {
-  createTransaction,
-  updateTransaction: defaultUpdateTransaction,
-  prepareTransaction,
-  estimateMaxSpendable,
-  getTransactionStatus,
-  sync,
-  receive,
-  signOperation,
-  broadcast,
-  assignToAccountRaw,
-  assignFromAccountRaw,
-};
-
-export default { currencyBridge, accountBridge };

package/src/families/tezos/cli-transaction.ts

@@ -1,121 +0,0 @@
-import { from, Observable } from "rxjs";
-import { map } from "rxjs/operators";
-import invariant from "invariant";
-import { BigNumber } from "bignumber.js";
-import flatMap from "lodash/flatMap";
-import type { Account, AccountLike, AccountLikeArray, SubAccount } from "@ledgerhq/types-live";
-import type { Transaction, Baker } from "./types";
-import { listBakers, fetchAllBakers } from "./bakers";
-import defaultList from "./bakers.whitelist-default";
-
-const options = [
-  {
-    name: "mode",
-    type: String,
-    desc: "mode of transaction",
-  },
-  {
-    name: "storageLimit",
-    type: String,
-    desc: "how much storageLimit. default is estimated with the recipient",
-  },
-  {
-    name: "subAccount",
-    type: String,
-    desc: "use a sub account instead of the parent by index",
-    multiple: true,
-  },
-  {
-    name: "fees",
-    type: String,
-    desc: "how much fees",
-  },
-  {
-    name: "gasLimit",
-    type: String,
-    desc: "how much gasLimit. default is estimated with the recipient",
-  },
-];
-
-function inferAccounts(account: Account, opts: Record<string, any>): AccountLikeArray {
-  invariant(account.currency.family === "tezos", "tezos family");
-
-  if (!opts.subAccount) {
-    const accounts: Account[] = [account];
-    return accounts;
-  }
-
-  const { subAccounts } = account;
-  invariant(subAccounts, "no sub accounts");
-  return opts.subAccount.map(i => {
-    const acc = (subAccounts as SubAccount[])[i];
-    invariant(acc, "sub account not found (index %s)", i);
-    return acc;
-  });
-}
-
-function inferTransactions(
-  transactions: Array<{
-    account: AccountLike;
-    transaction: Transaction;
-  }>,
-  opts: Record<string, any>,
-  { inferAmount }: any,
-): Transaction[] {
-  return flatMap(transactions, ({ transaction, account }) => {
-    invariant(transaction.family === "tezos", "tezos family");
-    let subAccountId;
-
-    return {
-      ...transaction,
-      mode: opts.mode || "send",
-      subAccountId,
-      fees: opts.fees ? inferAmount(account, opts.fees) : null,
-      gasLimit: opts.gasLimit ? new BigNumber(opts.gasLimit) : null,
-      storageLimit: opts.storageLimit ? new BigNumber(opts.storageLimit) : null,
-    };
-  });
-}
-
-const bakersFormatters = {
-  json: list => JSON.stringify(list),
-  default: list =>
-    list
-      .map(b => `${b.address} "${b.name}" ${b.nominalYield} ${b.capacityStatus} ${b.logoURL}`)
-      .join("\n"),
-};
-const tezosListBakers = {
-  args: [
-    {
-      name: "whitelist",
-      desc: "filter whitelist",
-      type: Boolean,
-    },
-    {
-      name: "format",
-      desc: Object.keys(bakersFormatters).join(" | "),
-      type: String,
-    },
-  ],
-  job: ({
-    whitelist,
-    format,
-  }: Partial<{
-    whitelist: boolean;
-    format: string;
-  }>): Observable<string> =>
-    from(whitelist ? listBakers(defaultList) : fetchAllBakers()).pipe(
-      map((list: Baker[]) => {
-        const f = (format && bakersFormatters[format]) || bakersFormatters.default;
-        return f(list);
-      }),
-    ),
-};
-export default {
-  options,
-  inferAccounts,
-  inferTransactions,
-  commands: {
-    tezosListBakers,
-  },
-};

package/src/families/tezos/datasets/tezos.scanAccounts.1.ts

@@ -1,35 +0,0 @@
-export default {
-  name: "tezos seed 1",
-  unstableAccounts: true,
-  // accounts are staking so receive over time. we disable for now snapshot comparison
-  apdus: `
-    => 800200000d038000002c800006c180000000
-    <= 2102ac76ba226118e2d593d09cd7e395546b7540c0e7fb3eb430da59f7982af632969000
-    => 8002000015058000002c800006c1800000008000000080000001
-    <= 2102b058662fd530e6463d774e3951a40ddd5e430dbeb62673f90caca0cec58735fd9000
-    => 8002000011048000002c800006c18000000080000001
-    <= 2102670e5e92d06e725b68edda589678fdf0f85a582df06ee634d841cf8042db63839000
-    => 8002000015058000002c800006c1800000008000000080000000
-    <= 2102f7ed85c519f7d39a664935a410d1a41ca302dfa3eee228e92cbe0dc12aba7a189000
-    => 8002000015058000002c800006c1800000018000000080000000
-    <= 2102c26d0da1978b7a7596c9853d80d0beac20519c73e76e7f677540db47165d94f39000
-    => 8002000015058000002c800006c1800000028000000080000000
-    <= 21020058c0efd324fa13d778c4b0995f6fa8d9c85e561c1465d770d4011993f557509000
-    => 8002000015058000002c800006c1800000038000000080000000
-    <= 21029bfe70b3e94ff23623f6c42f6e081a9ca8cc78f74b0d8da58f0d4cdc41c33c1a9000
-    => 8002000015058000002c800006c1800000048000000080000000
-    <= 21021d3b9b84feb81d5215cca4f0a016e99fc6cf86d06e864cb4a5098709f16aa2219000
-    => 8002000015058000002c800006c1800000058000000080000000
-    <= 21020162dc75ad3c2b6e097d15a1513033c60d8a033f2312ff5a6ead812228d9d6539000
-    => 8002000015058000002c800006c1800000068000000080000000
-    <= 21021831897c4224296519d496d32fdf9e17fb4af680635c5dbbc46cde84fe11dcc99000
-    => 8002000011048000002c800006c18000000080000000
-    <= 210294e8344ae6df2d3123fa100b5abd40cee339c67838b1c34c4f243cc582f4d2d89000
-    => 8002000011048000002c800006c18000000180000000
-    <= 2102389ffd73423626894cb151416e51c72ec285376673daf83545eb5edb45b261ce9000
-    => 8002000011048000002c800006c18000000280000000
-    <= 2102e4c49994c90ffe2e5480826d2f49fb9d0f45280e20bd0a61c488f652d7af0f9c9000
-    => 8002000011048000002c800006c18000000380000000
-    <= 2102a9ae8b0ff5f9a43565793ad78e10db6f12177d904d208ada591b8a5b9999e3fd9000
-    `,
-};

package/src/families/tezos/deviceTransactionConfig.ts

@@ -1,72 +0,0 @@
-import type { AccountLike, Account } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus } from "./types";
-import type { DeviceTransactionField } from "../../transaction";
-import { getMainAccount } from "../../account";
-export type ExtraDeviceTransactionField =
-  | {
-      type: "tezos.delegateValidator";
-      label: string;
-    }
-  | {
-      type: "tezos.storageLimit";
-      label: string;
-    };
-
-function getDeviceTransactionConfig({
-  account,
-  parentAccount,
-  transaction: { mode, recipient },
-  status: { amount, estimatedFees },
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction;
-  status: TransactionStatus;
-}): Array<DeviceTransactionField> {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const source = mainAccount.freshAddress;
-  const isDelegateOperation = mode === "delegate";
-  const fields: Array<DeviceTransactionField> = [
-    {
-      type: "address",
-      label: "Source",
-      address: source,
-    },
-  ];
-
-  if (isDelegateOperation) {
-    fields.push(
-      {
-        type: "tezos.delegateValidator",
-        label: "Validator",
-      },
-      {
-        type: "address",
-        label: "Delegate",
-        address: recipient,
-      },
-    );
-  }
-
-  if (!amount.isZero()) {
-    fields.push({
-      type: "amount",
-      label: "Amount",
-    });
-  }
-
-  if (!estimatedFees.isZero()) {
-    fields.push({
-      type: "fees",
-      label: "Fees",
-    });
-  }
-
-  fields.push({
-    type: "tezos.storageLimit",
-    label: "Storage Limit",
-  });
-  return fields;
-}
-
-export default getDeviceTransactionConfig;

package/src/families/tezos/fixtures/makeAccount.ts

@@ -1,43 +0,0 @@
-import BigNumber from "bignumber.js";
-import { TezosAccount } from "../types";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-
-export function makeAccount(
-  name: string,
-  pubkey: string,
-  address: string,
-  isRevelead: boolean,
-): TezosAccount {
-  return {
-    id: `js:2:tezos:${pubkey}:${"standard"}`,
-    seedIdentifier: address,
-    name: "Tezos " + name,
-    derivationMode: "",
-    index: 0,
-    freshAddress: address,
-    freshAddressPath: "",
-    freshAddresses: [],
-    blockHeight: 0,
-    operations: [],
-    pendingOperations: [],
-    lastSyncDate: new Date(),
-    balance: new BigNumber(0),
-    xpub: pubkey,
-    subAccounts: [],
-    type: "Account",
-    starred: false,
-    used: true,
-    spendableBalance: new BigNumber(100),
-    creationDate: new Date(),
-    currency: getCryptoCurrencyById("tezos"),
-    unit: { name: "xtz", code: "xtz", magnitude: 6 },
-    operationsCount: 0,
-    swapHistory: [],
-    balanceHistoryCache: {
-      WEEK: { latestDate: 0, balances: [] },
-      DAY: { latestDate: 0, balances: [] },
-      HOUR: { latestDate: 0, balances: [] },
-    },
-    tezosResources: { revealed: isRevelead, counter: 0 },
-  };
-}

package/src/families/tezos/hw-getAddress.ts

@@ -1,10 +0,0 @@
-import Xtz from "@ledgerhq/hw-app-tezos";
-import type { Resolver } from "../../hw/getAddress/types";
-
-const resolver: Resolver = async (transport, { path, verify }) => {
-  const xtz = new Xtz(transport);
-  const r = await xtz.getAddress(path, { verify });
-  return { ...r, path };
-};
-
-export default resolver;

package/src/families/tezos/serialization.ts

@@ -1,27 +0,0 @@
-import type { TezosAccount, TezosAccountRaw, TezosResources, TezosResourcesRaw } from "./types";
-import { Account, AccountRaw } from "@ledgerhq/types-live";
-
-export function toTezosResourcesRaw(r: TezosResources): TezosResourcesRaw {
-  const { revealed, counter } = r;
-  return { revealed, counter };
-}
-
-export function fromTezosResourcesRaw(r: TezosResourcesRaw): TezosResources {
-  const { revealed, counter } = r;
-  return { revealed, counter };
-}
-
-export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
-  const tezosAccount = account as TezosAccount;
-  if (tezosAccount.tezosResources) {
-    (accountRaw as TezosAccountRaw).tezosResources = toTezosResourcesRaw(
-      tezosAccount.tezosResources,
-    );
-  }
-}
-
-export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
-  const tezosResourcesRaw = (accountRaw as TezosAccountRaw).tezosResources;
-  if (tezosResourcesRaw)
-    (account as TezosAccount).tezosResources = fromTezosResourcesRaw(tezosResourcesRaw);
-}