@ledgerhq/live-common 21.4.1-btcjs.4 → 21.5.0

package/src/families/bitcoin/js-estimateMaxSpendable.ts

@@ -1,36 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { AccountLike, Account } from "../../types";
-import type { Transaction } from "./types";
-import { getMainAccount } from "../../account";
-import wallet, { getWalletAccount } from "./wallet";
-import { getAccountNetworkInfo } from "./getAccountNetworkInfo";
-
-/**
- * Returns the maximum possible amount for transaction
- *
- * @param {Object} param - the account, parentAccount and transaction
- */
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const walletAccount = await getWalletAccount(mainAccount);
-  let feePerByte = transaction?.feePerByte;
-  if (!feePerByte) {
-    const networkInfo = await getAccountNetworkInfo(mainAccount);
-    feePerByte = networkInfo.feeItems.defaultFeePerByte;
-  }
-  const maxSpendable = await wallet.estimateAccountMaxSpendable(
-    walletAccount,
-    feePerByte.toNumber() //!\ wallet-btc handles fees as JS number
-  );
-  return maxSpendable.lt(0) ? new BigNumber(0) : maxSpendable;
-};
-
-export default estimateMaxSpendable;

package/src/families/bitcoin/js-getFeesForTransaction.ts

@@ -1,59 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Account } from "./../../types";
-import type { Transaction } from "./types";
-import { buildTransaction } from "./js-buildTransaction";
-import { perCoinLogic } from "./logic";
-
-const getFeesForTransaction = async ({
-  account,
-  transaction,
-}: {
-  account: Account;
-  transaction: Transaction;
-}) => {
-  const walletTx = await buildTransaction(account, transaction);
-  const fees = new BigNumber(walletTx.fee).integerValue();
-  let txInputs = walletTx.inputs.map((i) => {
-    return {
-      address: i.address,
-      value: new BigNumber(i.value),
-      previousTxHash: i.output_hash,
-      previousOutputIndex: i.output_index,
-    };
-  });
-  let txOutputs = walletTx.outputs.map((o) => {
-    return {
-      outputIndex: walletTx.outputs.indexOf(o),
-      address: o.address,
-      isChange: o.isChange,
-      value: new BigNumber(o.value),
-      hash: undefined,
-      blockHeight: undefined,
-      rbf: transaction.rbf,
-    };
-  });
-  const perCoin = perCoinLogic[account.currency.id];
-
-  if (perCoin) {
-    const { syncReplaceAddress } = perCoin;
-
-    if (syncReplaceAddress) {
-      txInputs = txInputs.map((i) => ({
-        ...i,
-        address: i.address && syncReplaceAddress(i.address),
-      }));
-      txOutputs = txOutputs.map((o) => ({
-        ...o,
-        address: o.address && syncReplaceAddress(o.address),
-      }));
-    }
-  }
-
-  return {
-    fees,
-    txInputs,
-    txOutputs,
-  };
-};
-
-export default getFeesForTransaction;

package/src/families/bitcoin/js-getTransactionStatus.ts

@@ -1,118 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { log } from "@ledgerhq/logs";
-import {
-  AmountRequired,
-  NotEnoughBalance,
-  FeeNotLoaded,
-  FeeTooHigh,
-  FeeRequired,
-} from "@ledgerhq/errors";
-import { LowerThanMinimumRelayFee } from "./../../errors";
-import type { Account, TransactionStatus } from "./../../types";
-import type { Transaction } from "./types";
-import { calculateFees, validateRecipient } from "./cache";
-import { getMinRelayFee } from "./logic";
-
-const getTransactionStatus = async (
-  a: Account,
-  t: Transaction
-): Promise<TransactionStatus> => {
-  const errors: any = {};
-  const warnings: any = {};
-  const useAllAmount = !!t.useAllAmount;
-  const { recipientError, recipientWarning } = await validateRecipient(
-    a.currency,
-    t.recipient
-  );
-
-  if (recipientError) {
-    errors.recipient = recipientError;
-  }
-
-  if (recipientWarning) {
-    warnings.recipient = recipientWarning;
-  }
-
-  let txInputs;
-  let txOutputs;
-  let estimatedFees = new BigNumber(0);
-
-  if (!t.feePerByte) {
-    errors.feePerByte = new FeeNotLoaded();
-  } else if (t.feePerByte.eq(0)) {
-    errors.feePerByte = new FeeRequired();
-  } else if (t.recipient && !errors.recipient) {
-    await calculateFees({
-      account: a,
-      transaction: t,
-    }).then(
-      (res) => {
-        txInputs = res.txInputs;
-        txOutputs = res.txOutputs;
-        estimatedFees = res.fees;
-      },
-      (error) => {
-        if (error.name === "NotEnoughBalance") {
-          errors.amount = error;
-        } else {
-          throw error;
-        }
-      }
-    );
-  }
-
-  const sumOfInputs = (txInputs || []).reduce(
-    (sum, input) => sum.plus(input.value),
-    new BigNumber(0)
-  );
-  const sumOfChanges = (txOutputs || [])
-    .filter((o) => o.isChange)
-    .reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
-
-  if (txInputs) {
-    log("bitcoin", `${txInputs.length} inputs, sum: ${sumOfInputs.toString()}`);
-  }
-
-  if (txOutputs) {
-    log(
-      "bitcoin",
-      `${txOutputs.length} outputs, sum of changes: ${sumOfChanges.toString()}`
-    );
-  }
-
-  const totalSpent = sumOfInputs.minus(sumOfChanges);
-  const amount = useAllAmount ? totalSpent.minus(estimatedFees) : t.amount;
-  log(
-    "bitcoin",
-    `totalSpent ${totalSpent.toString()} amount ${amount.toString()}`
-  );
-
-  if (!errors.amount && !amount.gt(0)) {
-    errors.amount = useAllAmount
-      ? new NotEnoughBalance()
-      : new AmountRequired();
-  }
-
-  if (
-    process.env.EXPERIMENTAL_MIN_RELAY_FEE &&
-    estimatedFees &&
-    estimatedFees.gt(0) &&
-    estimatedFees.lt(getMinRelayFee(a.currency))
-  ) {
-    warnings.feePerByte = new LowerThanMinimumRelayFee();
-  } else if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
-    warnings.feeTooHigh = new FeeTooHigh();
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-    txInputs,
-    txOutputs,
-  });
-};
-
-export default getTransactionStatus;

package/src/families/bitcoin/js-prepareTransaction.ts

@@ -1,35 +0,0 @@
-import invariant from "invariant";
-import type { Account } from "../../types";
-import type { Transaction } from "./types";
-import { getAccountNetworkInfo } from "./getAccountNetworkInfo";
-import { inferFeePerByte } from "./logic";
-
-const prepareTransaction = async (
-  a: Account,
-  t: Transaction
-): Promise<Transaction> => {
-  let networkInfo = t.networkInfo;
-
-  if (!networkInfo) {
-    networkInfo = await getAccountNetworkInfo(a);
-    invariant(networkInfo.family === "bitcoin", "bitcoin networkInfo expected");
-  }
-
-  const feePerByte = inferFeePerByte(t, networkInfo);
-
-  if (
-    t.networkInfo === networkInfo &&
-    (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))
-  ) {
-    // nothing changed
-    return t;
-  }
-
-  return {
-    ...t,
-    networkInfo,
-    feePerByte,
-  };
-};
-
-export default prepareTransaction;

package/src/families/bitcoin/js-signOperation.ts

@@ -1,164 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import Btc from "@ledgerhq/hw-app-btc";
-import { log } from "@ledgerhq/logs";
-import type { Account, Operation, SignOperationEvent } from "./../../types";
-import { isSegwitDerivationMode } from "./../../derivation";
-import { encodeOperationId } from "./../../operation";
-import { open, close } from "./../../hw";
-import type { Transaction } from "./types";
-import { getNetworkParameters } from "./networks";
-import { buildTransaction } from "./js-buildTransaction";
-import { calculateFees } from "./cache";
-import wallet, { getWalletAccount } from "./wallet";
-import { perCoinLogic } from "./logic";
-
-const signOperation = ({
-  account,
-  deviceId,
-  transaction,
-}: {
-  account: Account;
-  deviceId: any;
-  transaction: Transaction;
-}): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const { currency } = account;
-      const transport = await open(deviceId);
-      const hwApp = new Btc(transport);
-      const walletAccount = await getWalletAccount(account);
-
-      try {
-        log("hw", `signTransaction ${currency.id} for account ${account.id}`);
-        const txInfo = await buildTransaction(account, transaction);
-        let senders: string[] = [];
-        let recipients: string[] = [];
-        let fee = new BigNumber(0);
-        // Maybe better not re-calculate these fields here, instead include them
-        // in Transaction type and set them in prepareTransaction?
-        await calculateFees({
-          account,
-          transaction,
-        }).then((res) => {
-          senders = res.txInputs
-            .map((i) => i.address)
-            .filter(Boolean) as string[];
-          recipients = res.txOutputs
-            .map((o) => o.address)
-            .filter(Boolean) as string[];
-          fee = res.fees;
-        });
-
-        // FIXME (legacy)
-        // should be `transaction.getLockTime()` as soon as lock time is
-        // handled by libcore (actually: it always returns a default value
-        // and that caused issue with zcash (see #904))
-        // cf. https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/transaction_builders/BitcoinLikeUtxoPicker.cpp#L156-L159
-        let lockTime;
-
-        // (legacy) Set lockTime for Komodo to enable reward claiming on UTXOs created by
-        // Ledger Live. We should only set this if the currency is Komodo and
-        // lockTime isn't already defined.
-        if (currency.id === "komodo" && lockTime === undefined) {
-          const unixtime = Math.floor(Date.now() / 1000);
-          lockTime = unixtime - 777;
-        }
-
-        const networkParams = getNetworkParameters(currency.id);
-        const sigHashType = networkParams.sigHash;
-        if (isNaN(sigHashType)) {
-          throw new Error("sigHashType should not be NaN");
-        }
-
-        const segwit = isSegwitDerivationMode(account.derivationMode);
-
-        // FIXME Call to explorer needed to set timestamp
-        // cf. https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/transaction_builders/BitcoinLikeUtxoPicker.cpp#L150-L154
-        /*
-        const hasTimestamp = networkParams.usesTimestampedTransaction;
-        const initialTimestamp = hasTimestamp
-          ? transaction.timestamp
-          : undefined;
-        */
-
-        const perCoin = perCoinLogic[currency.id];
-        let additionals = [currency.id];
-
-        if (account.derivationMode === "native_segwit") {
-          additionals.push("bech32");
-        }
-
-        if (perCoin?.getAdditionals) {
-          additionals = additionals.concat(
-            perCoin.getAdditionals({
-              transaction,
-            })
-          );
-        }
-
-        const expiryHeight = perCoin?.hasExpiryHeight
-          ? Buffer.from([0x00, 0x00, 0x00, 0x00])
-          : undefined;
-
-        const signature = await wallet.signAccountTx({
-          btc: hwApp,
-          fromAccount: walletAccount,
-          txInfo,
-          lockTime,
-          sigHashType,
-          segwit,
-          //initialTimestamp,
-          additionals,
-          expiryHeight,
-          onDeviceSignatureGranted: () =>
-            o.next({
-              type: "device-signature-granted",
-            }),
-          onDeviceSignatureRequested: () =>
-            o.next({
-              type: "device-signature-requested",
-            }),
-          onDeviceStreaming: ({ progress, index, total }) =>
-            o.next({
-              type: "device-streaming",
-              progress,
-              index,
-              total,
-            }),
-        });
-        // Build the optimistic operation
-        const operation: Operation = {
-          id: encodeOperationId(account.id, "", "OUT"),
-          hash: "", // Will be resolved in broadcast()
-          type: "OUT",
-          value: new BigNumber(transaction.amount).plus(fee),
-          fee,
-          blockHash: null,
-          blockHeight: null,
-          senders,
-          recipients,
-          accountId: account.id,
-          date: new Date(),
-          extra: {},
-        };
-        o.next({
-          type: "signed",
-          signedOperation: {
-            operation,
-            signature,
-            expirationDate: null,
-          },
-        });
-      } finally {
-        close(transport, deviceId);
-      }
-    }
-
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
-
-export default signOperation;

package/src/families/bitcoin/js-synchronisation.ts

@@ -1,362 +0,0 @@
-import { $Shape } from "utility-types";
-import type {
-  TX,
-  Currency,
-  Input as WalletInput,
-  Output as WalletOutput,
-} from "@ledgerhq/wallet-btc";
-import { DerivationModes as WalletDerivationModes } from "@ledgerhq/wallet-btc";
-import { BigNumber } from "bignumber.js";
-import Btc from "@ledgerhq/hw-app-btc";
-import { log } from "@ledgerhq/logs";
-import type {
-  Account,
-  Operation,
-  OperationType,
-  DerivationMode,
-} from "../../types";
-import type { GetAccountShape } from "../../bridge/jsHelpers";
-import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
-import { findCurrencyExplorer } from "../../api/Ledger";
-import { encodeOperationId } from "../../operation";
-import { BitcoinOutput } from "./types";
-import { perCoinLogic } from "./logic";
-import wallet from "./wallet";
-
-// Map LL's DerivationMode to wallet-btc's
-const toWalletDerivationMode = (
-  mode: DerivationMode
-): WalletDerivationModes => {
-  switch (mode) {
-    case "segwit":
-    case "segwit_on_legacy":
-    case "segwit_unsplit":
-    case "bch_on_bitcoin_segwit":
-    case "vertcoin_128_segwit":
-      return WalletDerivationModes.SEGWIT;
-
-    case "native_segwit":
-      return WalletDerivationModes.NATIVE_SEGWIT;
-
-    default:
-      return WalletDerivationModes.LEGACY;
-  }
-};
-
-// Map LL's currency ID to wallet-btc's Account.params.network
-const toWalletNetwork = (currencyId: string): "testnet" | "mainnet" => {
-  return ["bitcoin_testnet"].includes(currencyId) ? "testnet" : "mainnet";
-};
-
-// Map wallet-btc's Output to LL's BitcoinOutput
-const fromWalletUtxo = (utxo: WalletOutput): BitcoinOutput => {
-  return {
-    hash: utxo.output_hash,
-    outputIndex: utxo.output_index,
-    blockHeight: utxo.block_height,
-    address: utxo.address,
-    value: new BigNumber(utxo.value),
-    rbf: utxo.rbf,
-    isChange: false, // wallet-btc limitation: doesn't provide it
-    path: "",
-  };
-};
-
-// wallet-btc limitation: returns all transactions twice (for each side of the tx)
-// so we need to deduplicate them...
-const deduplicateOperations = (
-  operations: (Operation | undefined)[]
-): Operation[] => {
-  const seen = {};
-  const out: Operation[] = [];
-  let j = 0;
-
-  for (const operation of operations) {
-    if (operation) {
-      if (seen[operation.id] !== 1) {
-        seen[operation.id] = 1;
-        out[j++] = operation;
-      }
-    }
-  }
-
-  return out;
-};
-
-const mapTxToOperations = (
-  tx: TX,
-  currencyId: string,
-  accountId: string,
-  accountAddresses: string[],
-  changeAddresses: string[]
-): $Shape<Operation[]> => {
-  const operations: Operation[] = [];
-  const hash = tx.hash;
-  const fee = new BigNumber(tx.fees);
-  const blockHeight = tx.block?.height;
-  const blockHash = tx.block?.hash;
-  const date = new Date(tx.block?.time || tx.received_at);
-  const senders: string[] = [];
-  const recipients: string[] = [];
-  let type: OperationType = "OUT";
-  let value = new BigNumber(0);
-  const hasFailed = false;
-  const accountInputs: WalletInput[] = [];
-  const accountOutputs: WalletOutput[] = [];
-  const syncReplaceAddress = perCoinLogic[currencyId]?.syncReplaceAddress;
-
-  for (const input of tx.inputs) {
-    if (input.address) {
-      senders.push(
-        syncReplaceAddress ? syncReplaceAddress(input.address) : input.address
-      );
-
-      if (input.value) {
-        if (accountAddresses.includes(input.address)) {
-          // This address is part of the account
-          value = value.plus(input.value);
-          accountInputs.push(input);
-        }
-      }
-    }
-  }
-
-  // All inputs of a same transaction have the same sequence
-  const transactionSequenceNumber =
-    (accountInputs.length > 0 && accountInputs[0].sequence) || undefined;
-  const hasSpentNothing = value.eq(0);
-
-  for (const output of tx.outputs) {
-    if (output.address) {
-      if (accountAddresses.includes(output.address)) {
-        accountOutputs.push(output);
-
-        if (changeAddresses.includes(output.address)) {
-          if (
-            (recipients.length === 0 &&
-              output.output_hash ===
-                tx.outputs[tx.outputs.length - 1].output_hash) || // Is that condition safe?
-            hasSpentNothing
-          ) {
-            recipients.push(
-              syncReplaceAddress
-                ? syncReplaceAddress(output.address)
-                : output.address
-            );
-          }
-        } else {
-          recipients.push(
-            syncReplaceAddress
-              ? syncReplaceAddress(output.address)
-              : output.address
-          );
-        }
-      } else {
-        recipients.push(
-          syncReplaceAddress
-            ? syncReplaceAddress(output.address)
-            : output.address
-        );
-      }
-    }
-  }
-
-  if (accountInputs.length > 0) {
-    // It's a SEND operation
-    for (const output of accountOutputs) {
-      if (changeAddresses.includes(output.address)) {
-        value = value.minus(output.value);
-      }
-    }
-
-    type = "OUT";
-    operations.push({
-      id: encodeOperationId(accountId, hash, type),
-      hash,
-      type,
-      value,
-      fee,
-      senders,
-      recipients,
-      blockHeight,
-      blockHash,
-      transactionSequenceNumber,
-      accountId,
-      date,
-      hasFailed,
-      extra: {},
-    });
-  }
-
-  if (accountOutputs.length > 0) {
-    // It's a RECEIVE operation
-    const filterChangeAddresses = !!accountInputs.length;
-    let accountOutputCount = 0;
-    let finalAmount = new BigNumber(0);
-
-    for (const output of accountOutputs) {
-      if (!filterChangeAddresses || !changeAddresses.includes(output.address)) {
-        finalAmount = finalAmount.plus(output.value);
-        accountOutputCount += 1;
-      }
-    }
-
-    if (accountOutputCount > 0) {
-      value = finalAmount;
-      type = "IN";
-      operations.push({
-        id: encodeOperationId(accountId, hash, type),
-        hash,
-        type,
-        value,
-        fee,
-        senders,
-        recipients,
-        blockHeight,
-        blockHash,
-        transactionSequenceNumber,
-        accountId,
-        date,
-        hasFailed,
-        extra: {},
-      });
-    }
-  }
-
-  return operations;
-};
-
-const getAccountShape: GetAccountShape = async (info) => {
-  const {
-    transport,
-    currency,
-    id: accountId,
-    index,
-    derivationPath,
-    derivationMode,
-    initialAccount,
-  } = info;
-  const paramXpub = initialAccount?.xpub;
-
-  // In case we get a full derivation path, extract the seed identification part
-  // 44'/0'/0'/0/0 --> 44'/0'
-  // FIXME Only the CLI provides a full derivationPath: why?
-  const rootPath = derivationPath.split("/", 2).join("/");
-
-  const walletNetwork = toWalletNetwork(currency.id);
-  const walletDerivationMode = toWalletDerivationMode(derivationMode);
-  const explorer = findCurrencyExplorer(currency);
-  if (!explorer) {
-    throw new Error(`No explorer found for currency ${currency.name}`);
-  }
-  if (explorer.version !== "v2" && explorer.version !== "v3") {
-    throw new Error(`Unsupported explorer version ${explorer.version}`);
-  }
-
-  const walletAccount = initialAccount?.bitcoinResources?.serializedData
-    ? await wallet.importFromSerializedAccount(
-        initialAccount.bitcoinResources.serializedData
-      )
-    : await wallet.generateAccount({
-        btc: (!paramXpub && transport && new Btc(transport)) || undefined,
-        xpub: paramXpub,
-        path: rootPath,
-        index,
-        currency: <Currency>currency.id,
-        network: walletNetwork,
-        derivationMode: walletDerivationMode,
-        explorer: explorer && `ledger${explorer.version}`,
-        explorerURI: `${explorer.endpoint}/blockchain/${explorer.version}/${explorer.id}`,
-        storage: "mock",
-        storageParams: [],
-      });
-  const xpub = paramXpub || walletAccount.xpub.xpub;
-  const oldOperations = initialAccount?.operations || [];
-  await wallet.syncAccount(walletAccount);
-  const balance = await wallet.getAccountBalance(walletAccount);
-  const currentBlock = await walletAccount.xpub.explorer.getCurrentBlock();
-  const blockHeight = currentBlock?.height;
-
-  // @ts-expect-error return from wallet-btc should be typed
-  const { txs: transactions } = await wallet.getAccountTransactions(
-    walletAccount
-  );
-  const accountAddressesWithInfo = await walletAccount.xpub.getXpubAddresses();
-  const accountAddresses = accountAddressesWithInfo
-    ? accountAddressesWithInfo.map((a) => a.address)
-    : [];
-  const changeAddressesWithInfo =
-    await walletAccount.xpub.storage.getUniquesAddresses({
-      account: 1,
-    });
-  const changeAddresses = changeAddressesWithInfo
-    ? changeAddressesWithInfo.map((a) => a.address)
-    : [];
-  const newOperations = transactions
-    ?.map((tx) =>
-      mapTxToOperations(
-        tx,
-        currency.id,
-        accountId,
-        accountAddresses,
-        changeAddresses
-      )
-    )
-    .flat();
-  const newUniqueOperations = deduplicateOperations(newOperations);
-  const operations = mergeOps(oldOperations, newUniqueOperations);
-  const rawUtxos = await wallet.getAccountUnspentUtxos(walletAccount);
-  const utxos = rawUtxos.map(fromWalletUtxo);
-  const serializedData = await wallet.exportToSerializedAccount(walletAccount);
-  return {
-    id: accountId,
-    xpub,
-    balance,
-    spendableBalance: balance,
-    operations,
-    operationsCount: operations.length,
-    blockHeight,
-    bitcoinResources: {
-      utxos,
-      serializedData,
-    },
-  };
-};
-
-const postSync = (initial: Account, synced: Account) => {
-  log("bitcoin/postSync", "bitcoinResources");
-  const perCoin = perCoinLogic[synced.currency.id];
-
-  if (perCoin) {
-    const { postBuildBitcoinResources, syncReplaceAddress } = perCoin;
-
-    if (postBuildBitcoinResources) {
-      synced.bitcoinResources = postBuildBitcoinResources(
-        synced,
-        synced.bitcoinResources
-      );
-    }
-
-    if (syncReplaceAddress) {
-      synced.freshAddress = syncReplaceAddress(synced.freshAddress);
-      synced.freshAddresses = synced.freshAddresses.map((a) => ({
-        ...a,
-        address: syncReplaceAddress(a.address),
-      }));
-      if (synced.bitcoinResources) {
-        synced.bitcoinResources.utxos = synced.bitcoinResources?.utxos.map(
-          (u) => ({
-            ...u,
-            address: u.address && syncReplaceAddress(u.address),
-          })
-        );
-      }
-    }
-  }
-
-  log("bitcoin/postSync", "bitcoinResources DONE");
-  return synced;
-};
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);