@ledgerhq/coin-aptos 1.4.0-next.0

package/src/api/index.ts

@@ -0,0 +1,224 @@
+import { ApolloClient, InMemoryCache } from "@apollo/client";
+import {
+  AccountData,
+  Aptos,
+  AptosApiType,
+  AptosConfig,
+  Ed25519PublicKey,
+  GasEstimation,
+  InputEntryFunctionData,
+  InputGenerateTransactionOptions,
+  MimeType,
+  post,
+  RawTransaction,
+  SimpleTransaction,
+  TransactionResponse,
+  UserTransactionResponse,
+  PostRequestOptions,
+  Block,
+} from "@aptos-labs/ts-sdk";
+import { getEnv } from "@ledgerhq/live-env";
+import network from "@ledgerhq/live-network";
+import BigNumber from "bignumber.js";
+import isUndefined from "lodash/isUndefined";
+import { APTOS_ASSET_ID } from "../constants";
+import { isTestnet } from "../bridge/logic";
+import type { AptosTransaction, TransactionOptions } from "../types";
+import { GetAccountTransactionsData, GetAccountTransactionsDataGt } from "./graphql/queries";
+import {
+  GetAccountTransactionsDataQuery,
+  GetAccountTransactionsDataGtQueryVariables,
+} from "./graphql/types";
+
+const getApiEndpoint = (currencyId: string) =>
+  isTestnet(currencyId) ? getEnv("APTOS_TESTNET_API_ENDPOINT") : getEnv("APTOS_API_ENDPOINT");
+const getIndexerEndpoint = (currencyId: string) =>
+  isTestnet(currencyId)
+    ? getEnv("APTOS_TESTNET_INDEXER_ENDPOINT")
+    : getEnv("APTOS_INDEXER_ENDPOINT");
+
+export class AptosAPI {
+  private apiUrl: string;
+  private indexerUrl: string;
+  private aptosConfig: AptosConfig;
+  private aptosClient: Aptos;
+  private apolloClient: ApolloClient<object>;
+
+  constructor(currencyId: string) {
+    this.apiUrl = getApiEndpoint(currencyId);
+    this.indexerUrl = getIndexerEndpoint(currencyId);
+    this.aptosConfig = new AptosConfig({
+      fullnode: this.apiUrl,
+      indexer: this.indexerUrl,
+    });
+    this.aptosClient = new Aptos(this.aptosConfig);
+    this.apolloClient = new ApolloClient({
+      uri: this.indexerUrl,
+      cache: new InMemoryCache(),
+      headers: {
+        "x-client": "ledger-live",
+      },
+    });
+  }
+
+  async getAccount(address: string): Promise<AccountData> {
+    return this.aptosClient.getAccountInfo({ accountAddress: address });
+  }
+
+  async getAccountInfo(address: string, startAt: string) {
+    const [balance, transactions, blockHeight] = await Promise.all([
+      this.getBalance(address),
+      this.fetchTransactions(address, startAt),
+      this.getHeight(),
+    ]);
+
+    return {
+      balance,
+      transactions,
+      blockHeight,
+    };
+  }
+
+  async estimateGasPrice(): Promise<GasEstimation> {
+    return this.aptosClient.getGasPriceEstimation();
+  }
+
+  async generateTransaction(
+    address: string,
+    payload: InputEntryFunctionData,
+    options: TransactionOptions,
+  ): Promise<RawTransaction> {
+    const opts: Partial<InputGenerateTransactionOptions> = {};
+    if (!isUndefined(options.maxGasAmount)) {
+      opts.maxGasAmount = Number(options.maxGasAmount);
+    }
+
+    if (!isUndefined(options.gasUnitPrice)) {
+      opts.gasUnitPrice = Number(options.gasUnitPrice);
+    }
+
+    try {
+      const { ledger_timestamp } = await this.aptosClient.getLedgerInfo();
+      opts.expireTimestamp = Number(Math.ceil(+ledger_timestamp / 1_000_000 + 2 * 60)); // in milliseconds
+    } catch {
+      // skip
+    }
+
+    return this.aptosClient.transaction.build
+      .simple({
+        sender: address,
+        data: payload,
+        options: opts,
+      })
+      .then(t => t.rawTransaction)
+      .catch(error => {
+        throw error;
+      });
+  }
+
+  async simulateTransaction(
+    address: Ed25519PublicKey,
+    tx: RawTransaction,
+    options = {
+      estimateGasUnitPrice: true,
+      estimateMaxGasAmount: true,
+      estimatePrioritizedGasUnitPrice: false,
+    },
+  ): Promise<UserTransactionResponse[]> {
+    return this.aptosClient.transaction.simulate.simple({
+      signerPublicKey: address,
+      transaction: { rawTransaction: tx } as SimpleTransaction,
+      options,
+    });
+  }
+
+  async broadcast(signature: string): Promise<string> {
+    const txBytes = Uint8Array.from(Buffer.from(signature, "hex"));
+    const pendingTx = await post<PostRequestOptions, TransactionResponse>({
+      contentType: MimeType.BCS_SIGNED_TRANSACTION,
+      aptosConfig: this.aptosClient.config,
+      body: txBytes,
+      path: "transactions",
+      type: AptosApiType.FULLNODE,
+      originMethod: "",
+    });
+    return pendingTx.data.hash;
+  }
+
+  private async getBalance(address: string): Promise<BigNumber> {
+    try {
+      const [balanceStr] = await this.aptosClient.view<[string]>({
+        payload: {
+          function: "0x1::coin::balance",
+          typeArguments: [APTOS_ASSET_ID],
+          functionArguments: [address],
+        },
+      });
+      const balance = parseInt(balanceStr, 10);
+      return new BigNumber(balance);
+    } catch (_) {
+      return new BigNumber(0);
+    }
+  }
+
+  private async fetchTransactions(address: string, gt?: string) {
+    if (!address) {
+      return [];
+    }
+
+    let query = GetAccountTransactionsData;
+    if (gt) {
+      query = GetAccountTransactionsDataGt;
+    }
+
+    const queryResponse = await this.apolloClient.query<
+      GetAccountTransactionsDataQuery,
+      GetAccountTransactionsDataGtQueryVariables
+    >({
+      query,
+      variables: {
+        address,
+        limit: 1000,
+        gt,
+      },
+      fetchPolicy: "network-only",
+    });
+
+    return Promise.all(
+      queryResponse.data.address_version_from_move_resources.map(({ transaction_version }) => {
+        return this.richItemByVersion(transaction_version);
+      }),
+    );
+  }
+
+  private async richItemByVersion(version: number): Promise<AptosTransaction | null> {
+    try {
+      const tx: TransactionResponse = await this.aptosClient.getTransactionByVersion({
+        ledgerVersion: version,
+      });
+      const block = await this.getBlock(version);
+      return {
+        ...tx,
+        block,
+      } as AptosTransaction;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private async getHeight(): Promise<number> {
+    const { data } = await network<Block>({
+      method: "GET",
+      url: this.apiUrl,
+    });
+    return parseInt(data.block_height);
+  }
+
+  private async getBlock(version: number) {
+    const block = await this.aptosClient.getBlockByVersion({ ledgerVersion: version });
+    return {
+      height: parseInt(block.block_height),
+      hash: block.block_hash,
+    };
+  }
+}

package/src/bridge/bridge.fixture.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+import { faker } from "@faker-js/faker";
+import type { AptosAccount, Transaction } from "../types/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+
+const currency = getCryptoCurrencyById("aptos");
+
+export function createFixtureAccount(account?: Partial<AptosAccount>): AptosAccount {
+  const freshAddress = {
+    address: "address",
+    derivationPath: "derivation_path",
+  };
+
+  return {
+    type: "Account",
+    id: faker.string.uuid(),
+    seedIdentifier: faker.string.uuid(),
+    derivationMode: "",
+    index: faker.number.int(),
+    freshAddress: account?.freshAddress || freshAddress.address,
+    freshAddressPath: account?.freshAddressPath || freshAddress.derivationPath,
+    used: true,
+    balance: account?.balance || new BigNumber(0),
+    spendableBalance: account?.spendableBalance || new BigNumber(0),
+    creationDate: faker.date.past(),
+    blockHeight: faker.number.int({ min: 100_000, max: 200_000 }),
+    currency,
+    operationsCount: account?.operationsCount || 0,
+    operations: account?.operations || [],
+    pendingOperations: account?.pendingOperations || [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+    swapHistory: [],
+  };
+}
+
+export function createFixtureTransaction(tx?: Partial<Transaction>): Transaction {
+  const transaction: Transaction = {
+    amount: tx?.amount || new BigNumber(0),
+    recipient: tx?.recipient || "",
+    useAllAmount: tx?.useAllAmount || false,
+    family: "aptos",
+    mode: tx?.mode || "send",
+    fees: tx?.fees || null,
+    options: {
+      maxGasAmount: BigNumber(0).toString(),
+      gasUnitPrice: BigNumber(0).toString(),
+    },
+  };
+
+  return transaction;
+}

package/src/bridge/broadcast.ts

@@ -0,0 +1,17 @@
+import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { AptosAPI } from "../api";
+
+const broadcast = async ({
+  signedOperation,
+  account,
+}: {
+  signedOperation: SignedOperation;
+  account: Account;
+}): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+  const hash = await new AptosAPI(account.currency.id).broadcast(signature);
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/bridge/buildTransaction.ts

@@ -0,0 +1,29 @@
+import { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
+import type { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { AptosAPI } from "../api";
+import { APTOS_ASSET_ID } from "../constants";
+import { normalizeTransactionOptions } from "./logic";
+import type { Transaction } from "../types";
+
+const buildTransaction = async (
+  account: Account,
+  transaction: Transaction,
+  aptosClient: AptosAPI,
+): Promise<RawTransaction> => {
+  const txPayload = getPayload(transaction.recipient, transaction.amount);
+  const txOptions = normalizeTransactionOptions(transaction.options);
+  const tx = await aptosClient.generateTransaction(account.freshAddress, txPayload, txOptions);
+
+  return tx;
+};
+
+const getPayload = (sendTo: string, amount: BigNumber): InputEntryFunctionData => {
+  return {
+    function: "0x1::aptos_account::transfer_coins",
+    typeArguments: [APTOS_ASSET_ID],
+    functionArguments: [sendTo, amount.toString()],
+  };
+};
+
+export default buildTransaction;

package/src/bridge/createTransaction.ts

@@ -0,0 +1,17 @@
+import BigNumber from "bignumber.js";
+import type { Transaction } from "../types";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "./logic";
+
+const createTransaction = (): Transaction => ({
+  family: "aptos",
+  mode: "send",
+  amount: BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  options: {
+    maxGasAmount: DEFAULT_GAS.toString(),
+    gasUnitPrice: DEFAULT_GAS_PRICE.toString(),
+  },
+});
+
+export default createTransaction;

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,30 @@
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import BigNumber from "bignumber.js";
+
+export const methodToString = (method: number): string => {
+  switch (method) {
+    case 0:
+      return "Coin transfer";
+    default:
+      return "Unknown";
+  }
+};
+
+export type ExtraDeviceTransactionField = {
+  type: "aptos.extendedAmount";
+  label: string;
+  value: number | BigNumber;
+};
+
+function getDeviceTransactionConfig(): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  fields.push({
+    type: "text",
+    label: "Type",
+    value: methodToString(0),
+  });
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,35 @@
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { AptosAPI } from "../api";
+import { getEstimatedGas } from "./getFeesForTransaction";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
+import type { Transaction } from "../types";
+
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account;
+  transaction?: Transaction;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+
+  const aptosClient = new AptosAPI(mainAccount.currency.id);
+
+  let maxGasAmount = new BigNumber(DEFAULT_GAS);
+  let gasUnitPrice = new BigNumber(DEFAULT_GAS_PRICE);
+
+  if (transaction) {
+    const { estimate } = await getEstimatedGas(mainAccount, transaction, aptosClient);
+
+    maxGasAmount = BigNumber(estimate.maxGasAmount);
+    gasUnitPrice = BigNumber(estimate.gasUnitPrice);
+  }
+
+  return getMaxSendBalance(mainAccount.spendableBalance, maxGasAmount, gasUnitPrice);
+};
+
+export default estimateMaxSpendable;

package/src/bridge/getFeesForTransaction.ts

@@ -0,0 +1,87 @@
+import { Ed25519PublicKey } from "@aptos-labs/ts-sdk";
+import { log } from "@ledgerhq/logs";
+import type { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
+import { AptosAPI } from "../api";
+import buildTransaction from "./buildTransaction";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL } from "./logic";
+import type { Transaction, TransactionErrors } from "../types";
+
+type IGetEstimatedGasReturnType = {
+  fees: BigNumber;
+  estimate: {
+    maxGasAmount: string;
+    gasUnitPrice: string;
+  };
+  errors: TransactionErrors;
+};
+
+export const getFee = async (
+  account: Account,
+  transaction: Transaction,
+  aptosClient: AptosAPI,
+): Promise<IGetEstimatedGasReturnType> => {
+  const res = {
+    fees: new BigNumber(DEFAULT_GAS).multipliedBy(DEFAULT_GAS_PRICE),
+    estimate: {
+      maxGasAmount: DEFAULT_GAS.toString(),
+      gasUnitPrice: DEFAULT_GAS_PRICE.toString(),
+    },
+    errors: { ...transaction.errors },
+  };
+
+  let gasLimit = DEFAULT_GAS;
+  let gasPrice = DEFAULT_GAS_PRICE;
+  transaction.options = {
+    maxGasAmount: gasLimit.toString(),
+    gasUnitPrice: gasPrice.toString(),
+  };
+  if (account.xpub) {
+    try {
+      const publicKeyEd = new Ed25519PublicKey(account.xpub as string);
+      const tx = await buildTransaction(account, transaction, aptosClient);
+      const simulation = await aptosClient.simulateTransaction(publicKeyEd, tx);
+      const completedTx = simulation[0];
+
+      gasLimit = new BigNumber(completedTx.gas_used).multipliedBy(ESTIMATE_GAS_MUL);
+      gasPrice = new BigNumber(completedTx.gas_unit_price);
+
+      const expectedGas = gasPrice.multipliedBy(gasLimit);
+
+      const isUnderMaxSpendable = transaction.amount
+        .plus(expectedGas)
+        .isLessThan(account.spendableBalance);
+
+      if (isUnderMaxSpendable && !completedTx.success) {
+        // we want to skip INSUFFICIENT_BALANCE error because it will be processed by getTransactionStatus
+        if (!completedTx.vm_status.includes("INSUFFICIENT_BALANCE")) {
+          throw Error(`Simulation failed with following error: ${completedTx.vm_status}`);
+        }
+      }
+      res.fees = expectedGas;
+      res.estimate.maxGasAmount = gasLimit.toString();
+      res.estimate.gasUnitPrice = completedTx.gas_unit_price;
+    } catch (error: any) {
+      log(error.message);
+      throw error;
+    }
+  }
+  return res;
+};
+
+const CACHE = makeLRUCache(
+  getFee,
+  (_account: Account, transaction: Transaction, _aptosClient: AptosAPI) => {
+    return transaction.amount.toString();
+  },
+  seconds(30),
+);
+
+export const getEstimatedGas = async (
+  account: Account,
+  transaction: Transaction,
+  aptosClient: AptosAPI,
+): Promise<IGetEstimatedGasReturnType> => {
+  return await CACHE(account, transaction, aptosClient);
+};

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,54 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+} from "@ledgerhq/errors";
+import type { Account } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "../types";
+
+import { AccountAddress } from "@aptos-labs/ts-sdk";
+
+const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
+  const errors: Record<string, Error> = {};
+  const warnings = {};
+
+  if (!t.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  const estimatedFees = t.fees || BigNumber(0);
+
+  if (t.amount.eq(0)) {
+    errors.amount = new AmountRequired();
+  }
+
+  const amount = t.amount;
+
+  const totalSpent = BigNumber(t.amount).plus(estimatedFees);
+
+  if (totalSpent.gt(a.balance) && !errors.amount) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (!t.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (AccountAddress.isValid({ input: t.recipient }).valid === false && !errors.recipient) {
+    errors.recipient = new InvalidAddress("", { currencyName: a.currency.name });
+  } else if (t.recipient === a.freshAddress && !errors.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+};
+
+export default getTransactionStatus;

package/src/bridge/index.ts

@@ -0,0 +1,65 @@
+import {
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  getSerializedAddressParameters,
+  makeSync,
+  updateTransaction,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import resolver from "../signer";
+import type { Transaction, TransactionStatus, AptosSigner } from "../types";
+import getTransactionStatus from "./getTransactionStatus";
+import estimateMaxSpendable from "./estimateMaxSpendable";
+import prepareTransaction from "./prepareTransaction";
+import createTransaction from "./createTransaction";
+import { getAccountShape } from "./synchronisation";
+import buildSignOperation from "./signOperation";
+import broadcast from "./broadcast";
+
+function buildCurrencyBridge(signerContext: SignerContext<AptosSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+const sync = makeSync({ getAccountShape });
+
+function buildAccountBridge(
+  signerContext: SignerContext<AptosSigner>,
+): AccountBridge<Transaction, Account, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    getSerializedAddressParameters,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<AptosSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}