@ledgerhq/coin-aptos 1.4.0-next.0

package/src/bridge/logic.ts

@@ -0,0 +1,265 @@
+import {
+  EntryFunctionPayloadResponse,
+  Event,
+  InputEntryFunctionData,
+  MoveResource,
+  WriteSetChange,
+} from "@aptos-labs/ts-sdk";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import {
+  APTOS_COIN_CHANGE,
+  BATCH_TRANSFER_TYPES,
+  DELEGATION_POOL_TYPES,
+  DIRECTION,
+  TRANSFER_TYPES,
+  WRITE_RESOURCE,
+} from "../constants";
+import type { AptosMoveResource, AptosTransaction, TransactionOptions } from "../types";
+
+export const DEFAULT_GAS = new BigNumber(200);
+export const DEFAULT_GAS_PRICE = new BigNumber(100);
+export const ESTIMATE_GAS_MUL = new BigNumber(1.0); // define buffer for gas estimation change here, if needed
+
+const CLEAN_HEX_REGEXP = /^0x0*|^0+/;
+
+export function isTestnet(currencyId: string): boolean {
+  return getCryptoCurrencyById(currencyId).isTestnetFor ? true : false;
+}
+
+export const getMaxSendBalance = (
+  amount: BigNumber,
+  gas: BigNumber,
+  gasPrice: BigNumber,
+): BigNumber => {
+  const totalGas = gas.multipliedBy(gasPrice);
+
+  return amount.gt(totalGas) ? amount.minus(totalGas) : new BigNumber(0);
+};
+
+export function normalizeTransactionOptions(options: TransactionOptions): TransactionOptions {
+  // FIXME: this is wrong. TransactionOptions is
+  // {
+  //     maxGasAmount: string;
+  //     gasUnitPrice: string;
+  //     sequenceNumber?: string;
+  //     expirationTimestampSecs?: string;
+  // }
+  // meaning we can't return undefined in check method.
+  // This method is useless, not deleting as it breaks code and this iteration is coin modularisation.
+  const check = (v: any) => ((v ?? "").toString().trim() ? v : undefined);
+  return {
+    maxGasAmount: check(options.maxGasAmount),
+    gasUnitPrice: check(options.gasUnitPrice),
+  };
+}
+
+export const getBlankOperation = (
+  tx: AptosTransaction,
+  id: string,
+): Operation<Record<string, string>> => ({
+  id: "",
+  hash: tx.hash,
+  type: "" as OperationType,
+  value: new BigNumber(0),
+  fee: new BigNumber(0),
+  blockHash: tx.block?.hash,
+  blockHeight: tx.block?.height,
+  senders: [] as string[],
+  recipients: [] as string[],
+  accountId: id,
+  date: new Date(parseInt(tx.timestamp) / 1000),
+  extra: { version: tx.version },
+  transactionSequenceNumber: parseInt(tx.sequence_number),
+  hasFailed: false,
+});
+
+const convertFunctionPayloadResponseToInputEntryFunctionData = (
+  payload: EntryFunctionPayloadResponse,
+): InputEntryFunctionData => ({
+  function: payload.function,
+  typeArguments: payload.type_arguments,
+  functionArguments: payload.arguments,
+});
+
+export const txsToOps = (
+  info: { address: string },
+  id: string,
+  txs: (AptosTransaction | null)[],
+): Operation[] => {
+  const { address } = info;
+  const ops: Operation[] = [];
+
+  txs.forEach(tx => {
+    if (tx !== null) {
+      const op: Operation = getBlankOperation(tx, id);
+      op.fee = new BigNumber(tx.gas_used).multipliedBy(new BigNumber(tx.gas_unit_price));
+
+      const payload = convertFunctionPayloadResponseToInputEntryFunctionData(
+        tx.payload as EntryFunctionPayloadResponse,
+      );
+
+      const function_address = getFunctionAddress(payload);
+
+      if (!function_address) {
+        return; // skip transaction without functions in payload
+      }
+
+      const { amount_in, amount_out } = getAptosAmounts(tx, address);
+      op.value = calculateAmount(tx.sender, address, op.fee, amount_in, amount_out);
+      op.type = compareAddress(tx.sender, address) ? DIRECTION.OUT : DIRECTION.IN;
+      op.senders.push(tx.sender);
+
+      processRecipients(payload, address, op, function_address);
+
+      if (op.value.isZero()) {
+        // skip transaction that result no Aptos change
+        op.type = DIRECTION.UNKNOWN;
+      }
+
+      op.hasFailed = !tx.success;
+      op.id = encodeOperationId(id, tx.hash, op.type);
+      if (op.type !== DIRECTION.UNKNOWN) ops.push(op);
+    }
+  });
+
+  return ops;
+};
+
+export function compareAddress(addressA: string, addressB: string) {
+  return (
+    addressA.replace(CLEAN_HEX_REGEXP, "").toLowerCase() ===
+    addressB.replace(CLEAN_HEX_REGEXP, "").toLowerCase()
+  );
+}
+
+export function getFunctionAddress(payload: InputEntryFunctionData): string | undefined {
+  if (payload.function) {
+    const parts = payload.function.split("::");
+    return parts.length === 3 && parts[0].length ? parts[0] : undefined;
+  }
+  return undefined;
+}
+
+export function processRecipients(
+  payload: InputEntryFunctionData,
+  address: string,
+  op: Operation,
+  function_address: string,
+): void {
+  // get recipients buy 3 groups
+  if (
+    (TRANSFER_TYPES.includes(payload.function) ||
+      DELEGATION_POOL_TYPES.includes(payload.function)) &&
+    payload.functionArguments &&
+    payload.functionArguments.length > 0 &&
+    typeof payload.functionArguments[0] === "string"
+  ) {
+    // 1. Transfer like functions (includes some delegation pool functions)
+    op.recipients.push(payload.functionArguments[0].toString());
+  } else if (
+    BATCH_TRANSFER_TYPES.includes(payload.function) &&
+    payload.functionArguments &&
+    payload.functionArguments.length > 0 &&
+    Array.isArray(payload.functionArguments[0])
+  ) {
+    // 2. Batch function, to validate we are in the recipients list
+    if (!compareAddress(op.senders[0], address)) {
+      for (const recipient of payload.functionArguments[0]) {
+        if (recipient && compareAddress(recipient.toString(), address)) {
+          op.recipients.push(recipient.toString());
+        }
+      }
+    }
+  } else {
+    // 3. other smart contracts, in this case smart contract will be treated as a recipient
+    op.recipients.push(function_address);
+  }
+}
+
+function checkWriteSets(tx: AptosTransaction, event: Event, event_name: string): boolean {
+  return tx.changes.some(change => {
+    return isChangeOfAptos(change, event, event_name);
+  });
+}
+
+export function isChangeOfAptos(
+  writeSetChange: WriteSetChange,
+  event: Event,
+  event_name: string,
+): boolean {
+  // to validate the event is related to Aptos Tokens we need to find change of type "write_resource"
+  // with the same guid as event
+  if (writeSetChange.type !== WRITE_RESOURCE) {
+    return false;
+  }
+
+  if (!("data" in writeSetChange)) {
+    return false;
+  }
+
+  const change_data = writeSetChange.data;
+
+  if (!("type" in change_data)) {
+    return false;
+  }
+
+  const mr = change_data as MoveResource<AptosMoveResource>;
+
+  if (mr.type !== APTOS_COIN_CHANGE) {
+    return false;
+  }
+
+  const change_event_data = mr.data[event_name];
+
+  return (
+    change_event_data.guid.id.addr === event.guid.account_address &&
+    change_event_data.guid.id.creation_num === event.guid.creation_number
+  );
+}
+
+export function getAptosAmounts(
+  tx: AptosTransaction,
+  address: string,
+): { amount_in: BigNumber; amount_out: BigNumber } {
+  let amount_in = new BigNumber(0);
+  let amount_out = new BigNumber(0);
+  // collect all events related to the address and calculate the overall amounts
+  tx.events.forEach(event => {
+    if (compareAddress(event.guid.account_address, address)) {
+      switch (event.type) {
+        case "0x1::coin::WithdrawEvent":
+          if (checkWriteSets(tx, event, "withdraw_events")) {
+            amount_out = amount_out.plus(event.data.amount);
+          }
+          break;
+        case "0x1::coin::DepositEvent":
+          if (checkWriteSets(tx, event, "deposit_events")) {
+            amount_in = amount_in.plus(event.data.amount);
+          }
+          break;
+      }
+    }
+  });
+  return { amount_in, amount_out };
+}
+
+export function calculateAmount(
+  sender: string,
+  address: string,
+  fee: BigNumber,
+  amount_in: BigNumber,
+  amount_out: BigNumber,
+): BigNumber {
+  const is_sender: boolean = compareAddress(sender, address);
+  // Include fees if our address is the sender
+  if (is_sender) {
+    amount_out = amount_out.plus(fee);
+  }
+  // LL negates the amount for SEND transactions
+  // to show positive amount on the send transaction (ex: in "cancel" tx, when amount will be returned to our account)
+  // we need to make it negative
+  return is_sender ? amount_out.minus(amount_in) : amount_in.minus(amount_out);
+}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,55 @@
+import type { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+import { AptosAPI } from "../api";
+import { getEstimatedGas } from "./getFeesForTransaction";
+import type { Transaction } from "../types";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
+
+const prepareTransaction = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<Transaction> => {
+  if (!transaction.recipient) {
+    return transaction;
+  }
+
+  // if transaction.useAllAmount is true, then we expect transaction.amount to be 0
+  // so to check that actual amount is zero or not, we also need to check if useAllAmount is false
+  if (transaction.amount.isZero() && !transaction.useAllAmount) {
+    return {
+      ...transaction,
+      fees: BigNumber(0),
+    };
+  }
+
+  const aptosClient = new AptosAPI(account.currency.id);
+
+  if (transaction.useAllAmount) {
+    // we will use this amount in simulation, to estimate gas
+    transaction.amount = getMaxSendBalance(
+      account.spendableBalance,
+      new BigNumber(DEFAULT_GAS),
+      new BigNumber(DEFAULT_GAS_PRICE),
+    );
+  }
+
+  const { fees, estimate, errors } = await getEstimatedGas(account, transaction, aptosClient);
+
+  if (transaction.useAllAmount) {
+    // correct the transaction amount according to estimated fees
+    transaction.amount = getMaxSendBalance(
+      account.spendableBalance,
+      BigNumber(estimate.maxGasAmount),
+      BigNumber(estimate.gasUnitPrice),
+    );
+  }
+
+  transaction.fees = fees;
+  transaction.options = estimate;
+  transaction.errors = errors;
+
+  return transaction;
+};
+
+export default prepareTransaction;

package/src/bridge/signOperation.ts

@@ -0,0 +1,82 @@
+import type { AptosAccount, Transaction } from "../types";
+import { Observable } from "rxjs";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import buildTransaction from "./buildTransaction";
+import BigNumber from "bignumber.js";
+import type { Account, AccountBridge, Operation, OperationType } from "@ledgerhq/types-live";
+import { AptosAPI } from "../api";
+
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { AptosSigner } from "../types";
+import { signTransaction } from "../network";
+
+export const getAddress = (a: Account) => ({
+  address: a.freshAddress,
+  derivationPath: a.freshAddressPath,
+});
+
+const buildSignOperation =
+  (
+    signerContext: SignerContext<AptosSigner>,
+  ): AccountBridge<Transaction, AptosAccount>["signOperation"] =>
+  ({ account, transaction, deviceId }) =>
+    new Observable(o => {
+      async function main() {
+        o.next({ type: "device-signature-requested" });
+
+        const aptosClient = new AptosAPI(account.currency.id);
+
+        const rawTx = await buildTransaction(account, transaction, aptosClient);
+        const txBytes = await signTransaction(signerContext, account, deviceId, rawTx);
+        const signature = Buffer.from(txBytes).toString("hex");
+
+        o.next({ type: "device-signature-granted" });
+
+        const accountId = account.id;
+        const hash = "";
+        const type: OperationType = "OUT";
+        const fee = transaction.fees || new BigNumber(0);
+        const extra = {};
+        const senders: string[] = [];
+        const recipients: string[] = [];
+
+        if (transaction.mode === "send") {
+          senders.push(account.freshAddress);
+          recipients.push(transaction.recipient);
+        }
+
+        // build optimistic operation
+        const operation: Operation = {
+          id: encodeOperationId(accountId, hash, type),
+          hash,
+          type,
+          value: transaction.useAllAmount
+            ? account.balance.minus(fee)
+            : transaction.amount.plus(fee),
+          fee,
+          extra,
+          blockHash: null,
+          blockHeight: null,
+          senders,
+          recipients,
+          accountId,
+          date: new Date(),
+          transactionSequenceNumber: Number(rawTx.sequence_number),
+        };
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });
+
+export default buildSignOperation;

package/src/bridge/synchronisation.ts

@@ -0,0 +1,50 @@
+import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { AptosAPI } from "../api";
+import { txsToOps } from "./logic";
+import type { AptosAccount } from "../types";
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, initialAccount, currency, derivationMode, rest } = info;
+
+  const publicKey =
+    rest?.publicKey || (initialAccount && decodeAccountId(initialAccount.id).xpubOrAddress);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey || address,
+    derivationMode,
+  });
+
+  // "xpub" field is used to store publicKey to simulate transaction during sending tokens.
+  // We can't get access to the Nano X via bluetooth on the step of simulation
+  // but we need public key to simulate transaction.
+  // "xpub" field is used because this field exists in ledger operation type
+  const xpub = initialAccount?.xpub || publicKey || "";
+
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = (oldOperations[0]?.extra as any)?.version;
+
+  const aptosClient = new AptosAPI(currency.id);
+  const { balance, transactions, blockHeight } = await aptosClient.getAccountInfo(address, startAt);
+
+  const newOperations = txsToOps(info, accountId, transactions);
+  const operations = mergeOps(oldOperations, newOperations);
+
+  const shape: Partial<AptosAccount> = {
+    type: "Account",
+    id: accountId,
+    xpub,
+    balance: balance,
+    spendableBalance: balance,
+    operations,
+    operationsCount: operations.length,
+    blockHeight,
+    lastSyncDate: new Date(),
+  };
+
+  return shape;
+};

package/src/bridge/transaction.ts

@@ -0,0 +1,61 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction, TransactionRaw } from "../types";
+
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import { Account } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+export const formatTransaction = (
+  { mode, amount, fees, recipient, useAllAmount }: Transaction,
+  account: Account,
+): string => {
+  return `
+${mode.toUpperCase()} ${
+    useAllAmount
+      ? "MAX"
+      : amount.isZero()
+        ? ""
+        : " " + formatCurrencyUnit(account.currency.units[0], amount)
+  }
+TO ${recipient}
+with fees=${fees ? formatCurrencyUnit(account.currency.units[0], fees) : "?"}`;
+};
+
+export const fromTransactionRaw = (t: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    options: JSON.parse(t.options),
+    ...(t.fees && { fees: new BigNumber(t.fees) }),
+    ...(t.errors && { errors: JSON.parse(t.errors) }),
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    fees: t.fees ? t.fees.toString() : null,
+    options: JSON.stringify(t.options),
+    errors: JSON.stringify(t.errors),
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/constants.ts

@@ -0,0 +1,34 @@
+import { MoveStructId } from "@aptos-labs/ts-sdk";
+
+export const LOAD_LIMIT = 10;
+
+export enum TX_STATUS {
+  PENDING = "pending",
+  FAIL = "fail",
+  SUCCESS = "success",
+}
+
+export const WRITE_RESOURCE = "write_resource";
+
+export const TRANSFER_TYPES: MoveStructId[] = [
+  "0x1::aptos_account::transfer",
+  "0x1::aptos_account::transfer_coins",
+  "0x1::coin::transfer",
+];
+export const BATCH_TRANSFER_TYPES: MoveStructId[] = [
+  "0x1::aptos_account::batch_transfer",
+  "0x1::aptos_account::batch_transfer_coins",
+];
+export const DELEGATION_POOL_TYPES: MoveStructId[] = [
+  "0x1::delegation_pool::add_stake",
+  "0x1::delegation_pool::withdraw",
+];
+
+export const APTOS_ASSET_ID: MoveStructId = "0x1::aptos_coin::AptosCoin";
+export const APTOS_COIN_CHANGE: MoveStructId = `0x1::coin::CoinStore<${APTOS_ASSET_ID}>`;
+
+export enum DIRECTION {
+  IN = "IN",
+  OUT = "OUT",
+  UNKNOWN = "UNKNOWN",
+}

package/src/errors.ts

@@ -0,0 +1,7 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const SequenceNumberTooOldError = createCustomErrorClass("SequenceNumberTooOld");
+
+export const SequenceNumberTooNewError = createCustomErrorClass("SequenceNumberTooNew");
+
+export const TransactionExpiredError = createCustomErrorClass("TransactionExpired");

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";

package/src/network/index.ts

@@ -0,0 +1,54 @@
+import {
+  AccountAddress,
+  AccountAuthenticatorEd25519,
+  Ed25519PublicKey,
+  Ed25519Signature,
+  generateSignedTransaction,
+  generateSigningMessageForTransaction,
+  Hex,
+  RawTransaction,
+  SimpleTransaction,
+} from "@aptos-labs/ts-sdk";
+import { SignerContext } from "@ledgerhq/coin-framework/lib/signer";
+import { Account } from "@ledgerhq/types-live";
+import { AptosSigner } from "../types";
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
+
+export async function signTransaction(
+  signerContext: SignerContext<AptosSigner>,
+  account: Account,
+  deviceId: string,
+  rawTxn: RawTransaction,
+): Promise<Uint8Array> {
+  const { freshAddressPath: derivationPath } = account;
+
+  if (!account.xpub) {
+    throw Error("Account must have a public signing key");
+  }
+
+  const publicKey = Buffer.from(AccountAddress.from(account.xpub).toUint8Array());
+  const hash = sha3Hash.create();
+  hash.update(publicKey.toString("hex"));
+  hash.update("\x00");
+
+  const signingMessage = generateSigningMessageForTransaction({
+    rawTransaction: rawTxn,
+  } as SimpleTransaction);
+
+  const response = await signerContext(
+    deviceId,
+    async signer => await signer.signTransaction(derivationPath, Buffer.from(signingMessage)),
+  );
+
+  const sigHexStr = Hex.fromHexString(response.signature.toString("hex"));
+  const signature = new Ed25519Signature(sigHexStr.toUint8Array());
+  const authenticator = new AccountAuthenticatorEd25519(
+    new Ed25519PublicKey(publicKey.toString("hex")),
+    signature,
+  );
+
+  return generateSignedTransaction({
+    transaction: { rawTransaction: rawTxn } as SimpleTransaction,
+    senderAuthenticator: authenticator,
+  });
+}

package/src/signer/index.ts

@@ -0,0 +1,17 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { AptosSigner } from "../types";
+
+const resolver = (signerContext: SignerContext<AptosSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = await signerContext(deviceId, signer => signer.getAddress(path, verify || false));
+    return {
+      address: r.address,
+      publicKey: r.publicKey.toString("hex"),
+      path,
+    };
+  };
+};
+
+export default resolver;