@ledgerhq/coin-aptos 1.9.6 → 1.10.0-nightly.1

package/src/logic/buildTransaction.ts

@@ -0,0 +1,62 @@
+import { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/index";
+import { APTOS_ASSET_ID, SUPPORTED_TOKEN_TYPES } from "../constants";
+import type { AptosAPI } from "../network";
+import { normalizeTransactionOptions } from "./normalizeTransactionOptions";
+import type { Transaction } from "../types";
+
+const buildTransaction = async (
+  account: Account,
+  transaction: Transaction,
+  aptosClient: AptosAPI,
+): Promise<RawTransaction> => {
+  const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
+
+  const txPayload = getPayload(subAccount, transaction);
+  const txOptions = normalizeTransactionOptions(transaction.options);
+  const tx = await aptosClient.generateTransaction(account.freshAddress, txPayload, txOptions);
+
+  return tx;
+};
+
+const getPayload = (
+  tokenAccount: TokenAccount | undefined,
+  transaction: Transaction,
+): InputEntryFunctionData => {
+  if (tokenAccount && isTokenAccount(tokenAccount)) {
+    const { tokenType } = tokenAccount.token;
+
+    if (!SUPPORTED_TOKEN_TYPES.includes(tokenType)) {
+      throw new Error(`Token type ${tokenType} not supported`);
+    }
+
+    if (tokenType === "fungible_asset") {
+      return {
+        function: `0x1::primary_fungible_store::transfer`,
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: [
+          tokenAccount.token.contractAddress,
+          transaction.recipient,
+          transaction.amount.toString(),
+        ],
+      };
+    }
+
+    if (tokenType === "coin") {
+      return {
+        function: `0x1::aptos_account::transfer_coins`,
+        typeArguments: [tokenAccount.token.contractAddress],
+        functionArguments: [transaction.recipient, transaction.amount.toString()],
+      };
+    }
+  }
+
+  return {
+    function: "0x1::aptos_account::transfer_coins",
+    typeArguments: [APTOS_ASSET_ID],
+    functionArguments: [transaction.recipient, transaction.amount.toString()],
+  };
+};
+
+export default buildTransaction;

package/src/logic/calculateAmount.ts

@@ -0,0 +1,15 @@
+import BigNumber from "bignumber.js";
+import { compareAddress } from "./getCoinAndAmounts";
+
+export function calculateAmount(
+  sender: string,
+  address: string,
+  amount_in: BigNumber,
+  amount_out: BigNumber,
+): BigNumber {
+  const is_sender: boolean = compareAddress(sender, address);
+  // 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/logic/combine.ts

@@ -0,0 +1,51 @@
+import {
+  AccountAuthenticatorEd25519,
+  Deserializer,
+  Ed25519PublicKey,
+  Ed25519Signature,
+  Hex,
+  RawTransaction,
+  type SimpleTransaction,
+  generateSignedTransaction,
+} from "@aptos-labs/ts-sdk";
+
+export function combineSignedTransaction(
+  txRaw: RawTransaction,
+  signature: Ed25519Signature,
+  pubkey: Ed25519PublicKey,
+): Uint8Array {
+  const authenticator = new AccountAuthenticatorEd25519(pubkey, signature);
+
+  return generateSignedTransaction({
+    transaction: { rawTransaction: txRaw } as SimpleTransaction,
+    senderAuthenticator: authenticator,
+  });
+}
+
+export function combine(tx: string, signature: string, pubkey?: string) {
+  if (!Hex.isValid(tx).valid) {
+    throw new Error("tx must be a valid hex value");
+  }
+
+  if (!Hex.isValid(signature).valid) {
+    throw new Error("signature must be a valid hex value");
+  }
+
+  if (pubkey === undefined) {
+    throw new Error("account must have a public key");
+  }
+
+  if (!Hex.isValid(pubkey).valid) {
+    throw new Error("pubkey must be a valid hex value");
+  }
+
+  const ed25519Signature = new Ed25519Signature(signature);
+  const ed25519PubKey = new Ed25519PublicKey(pubkey);
+
+  const txBytes = Hex.fromHexString(tx).toUint8Array();
+  const txRaw = RawTransaction.deserialize(new Deserializer(txBytes));
+
+  const signedTxBytes = combineSignedTransaction(txRaw, ed25519Signature, ed25519PubKey);
+
+  return Hex.fromHexInput(signedTxBytes).toString();
+}

package/src/logic/craftTransaction.ts

@@ -0,0 +1,26 @@
+import type { TransactionIntent } from "@ledgerhq/coin-framework/lib/api/types";
+import type { AptosAsset, AptosExtra, AptosSender } from "../types/assets";
+import type { Account } from "@ledgerhq/types-live";
+import type { AptosAPI } from "../network";
+import buildTransaction from "./buildTransaction";
+import createTransaction from "./createTransaction";
+import BigNumber from "bignumber.js";
+
+export async function craftTransaction(
+  aptosClient: AptosAPI,
+  transactionIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>,
+): Promise<string> {
+  const account = {
+    freshAddress: transactionIntent.sender.freshAddress,
+    xpub: transactionIntent.sender.xpub,
+  } as Account;
+
+  const newTx = createTransaction();
+  newTx.amount = BigNumber(transactionIntent.amount.toString());
+  newTx.recipient = transactionIntent.recipient;
+  newTx.mode = transactionIntent.type;
+
+  const aptosTx = await buildTransaction(account, newTx, aptosClient);
+
+  return aptosTx.bcsToHex().toString();
+}

package/src/{bridge → logic}/createTransaction.ts

@@ -1,6 +1,6 @@
 import BigNumber from "bignumber.js";
 import type { Transaction } from "../types";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "./logic";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 
 const createTransaction = (): Transaction => ({
   family: "aptos",

package/src/logic/getBalance.ts

@@ -0,0 +1,15 @@
+import type { Balance } from "@ledgerhq/coin-framework/lib/api/types";
+import type { AptosAsset } from "../types/assets";
+import type { AptosAPI } from "../network";
+
+export async function getBalance(
+  aptosClient: AptosAPI,
+  address: string,
+): Promise<Balance<AptosAsset>[]> {
+  const balance = await aptosClient.getBalances(address);
+
+  return balance.map(x => ({
+    value: BigInt(x.amount.toString()),
+    asset: { type: "native" },
+  }));
+}

package/src/logic/getCoinAndAmounts.ts

@@ -0,0 +1,141 @@
+import BigNumber from "bignumber.js";
+import { APTOS_ASSET_ID, APTOS_FUNGIBLE_STORE, APTOS_OBJECT_CORE } from "../constants";
+import {
+  AptosFungibleoObjectCoreResourceData,
+  AptosFungibleStoreResourceData,
+  AptosMoveResource,
+  AptosTransaction,
+} from "../types";
+import { MoveResource, WriteSetChangeWriteResource, Event } from "@aptos-labs/ts-sdk";
+import { getResourceAddress } from "./getResourceAddress";
+import { isWriteSetChangeWriteResource } from "./isWriteSetChangeWriteResource";
+
+const CLEAN_HEX_REGEXP = /^0x0*|^0+/;
+
+export function compareAddress(addressA: string, addressB: string) {
+  return (
+    addressA.replace(CLEAN_HEX_REGEXP, "").toLowerCase() ===
+    addressB.replace(CLEAN_HEX_REGEXP, "").toLowerCase()
+  );
+}
+
+export function checkFAOwner(tx: AptosTransaction, event: Event, user_address: string): boolean {
+  for (const change of tx.changes) {
+    if (isWriteSetChangeWriteResource(change)) {
+      const storeData = change.data as MoveResource<AptosFungibleoObjectCoreResourceData>;
+      if (
+        change.address == event.data.store &&
+        storeData.type == APTOS_OBJECT_CORE &&
+        storeData.data.owner == user_address
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Extracts the address from a string like "0x1::coin::CoinStore<address::module::type>"
+ * @param {string} str - The input string containing the address.
+ * @returns {string | null} - The extracted address or null if not found.
+ */
+function extractAddress(str: string): string | null {
+  const match = /<([^<>]+)>$/.exec(str);
+  return match ? match[1] : null;
+}
+
+export function getEventCoinAddress(
+  change: WriteSetChangeWriteResource,
+  event: Event,
+  event_name: string,
+): string | null {
+  const change_data = change.data;
+
+  const mr = change_data as MoveResource<AptosMoveResource>; // -> this is data that we want to parse
+
+  if (!(event_name in mr.data)) {
+    return null;
+  }
+
+  const change_event_data = mr.data[event_name];
+  if (
+    change_event_data.guid.id.addr !== event.guid.account_address ||
+    change_event_data.guid.id.creation_num !== event.guid.creation_number
+  ) {
+    return null;
+  }
+
+  const address = extractAddress(mr.type);
+
+  return address;
+}
+
+export function getEventFAAddress(
+  change: WriteSetChangeWriteResource,
+  event: Event,
+  _event_name: string,
+): string | null {
+  const change_data = change.data;
+
+  if (change_data.type !== APTOS_FUNGIBLE_STORE) {
+    return null;
+  }
+
+  const mr = change_data as MoveResource<AptosFungibleStoreResourceData>;
+
+  if (change.address !== event.data.store) {
+    return null;
+  }
+
+  return mr.data.metadata.inner;
+}
+
+export function getCoinAndAmounts(
+  tx: AptosTransaction,
+  address: string,
+): { coin_id: string | null; amount_in: BigNumber; amount_out: BigNumber } {
+  let coin_id: string | null = null;
+  let amount_in = BigNumber(0);
+  let amount_out = BigNumber(0);
+
+  // collect all events related to the address and calculate the overall amounts
+  tx.events.forEach(event => {
+    switch (event.type) {
+      case "0x1::coin::WithdrawEvent":
+        if (compareAddress(event.guid.account_address, address)) {
+          coin_id = getResourceAddress(tx, event, "withdraw_events", getEventCoinAddress);
+          amount_out = amount_out.plus(event.data.amount);
+        }
+        break;
+      case "0x1::coin::DepositEvent":
+        if (compareAddress(event.guid.account_address, address)) {
+          coin_id = getResourceAddress(tx, event, "deposit_events", getEventCoinAddress);
+          amount_in = amount_in.plus(event.data.amount);
+        }
+        break;
+      case "0x1::fungible_asset::Withdraw":
+        if (checkFAOwner(tx, event, address)) {
+          coin_id = getResourceAddress(tx, event, "withdraw_events", getEventFAAddress);
+          amount_out = amount_out.plus(event.data.amount);
+        }
+        break;
+      case "0x1::fungible_asset::Deposit":
+        if (checkFAOwner(tx, event, address)) {
+          coin_id = getResourceAddress(tx, event, "deposit_events", getEventFAAddress);
+          amount_in = amount_in.plus(event.data.amount);
+        }
+        break;
+      case "0x1::transaction_fee::FeeStatement":
+        if (tx.sender === address) {
+          coin_id ??= APTOS_ASSET_ID;
+          if (coin_id === APTOS_ASSET_ID) {
+            const fees = BigNumber(tx.gas_unit_price).times(BigNumber(tx.gas_used));
+            amount_out = amount_out.plus(fees);
+          }
+        }
+        break;
+    }
+  });
+  return { coin_id, amount_in, amount_out };
+}

package/src/logic/getFunctionAddress.ts

@@ -0,0 +1,9 @@
+import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+
+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;
+}

package/src/logic/getResourceAddress.ts

@@ -0,0 +1,24 @@
+import { WriteSetChangeWriteResource, Event } from "@aptos-labs/ts-sdk";
+import { AptosTransaction } from "../types";
+import { isWriteSetChangeWriteResource } from "./isWriteSetChangeWriteResource";
+
+export function getResourceAddress(
+  tx: AptosTransaction,
+  event: Event,
+  event_name: string,
+  getAddressProcessor: (
+    change: WriteSetChangeWriteResource,
+    event: Event,
+    event_name: string,
+  ) => string | null,
+): string | null {
+  for (const change of tx.changes) {
+    if (isWriteSetChangeWriteResource(change)) {
+      const address = getAddressProcessor(change, event, event_name);
+      if (address !== null) {
+        return address;
+      }
+    }
+  }
+  return null;
+}

package/src/logic/isTestnet.ts

@@ -0,0 +1,5 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+export function isTestnet(currencyId: string): boolean {
+  return !!getCryptoCurrencyById(currencyId).isTestnetFor;
+}

package/src/logic/isWriteSetChangeWriteResource.ts

@@ -0,0 +1,7 @@
+import { WriteSetChange, WriteSetChangeWriteResource } from "@aptos-labs/ts-sdk";
+
+export function isWriteSetChangeWriteResource(
+  change: WriteSetChange,
+): change is WriteSetChangeWriteResource {
+  return (change as WriteSetChangeWriteResource).data !== undefined;
+}

package/src/logic/normalizeTransactionOptions.ts

@@ -0,0 +1,18 @@
+import type { TransactionOptions } from "../types";
+
+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),
+  };
+}

package/src/logic/processRecipients.ts

@@ -0,0 +1,87 @@
+import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import { Operation } from "@ledgerhq/types-live";
+import { Operation as APIOperation } from "@ledgerhq/coin-framework/api/types";
+import { AptosAsset } from "../types/assets";
+import {
+  BATCH_TRANSFER_TYPES,
+  COIN_TRANSFER_TYPES,
+  DELEGATION_POOL_TYPES,
+  FA_TRANSFER_TYPES,
+} from "../constants";
+import { compareAddress } from "./getCoinAndAmounts";
+
+const transferLikeFunctions = (payload: InputEntryFunctionData) =>
+  COIN_TRANSFER_TYPES.includes(payload.function) ||
+  DELEGATION_POOL_TYPES.includes(payload.function);
+
+const addLikeFunctionsToRecipients = (
+  op: Operation | APIOperation<AptosAsset>,
+  payload: InputEntryFunctionData,
+) => {
+  if (
+    payload.functionArguments &&
+    payload.functionArguments.length > 0 &&
+    typeof payload.functionArguments[0] === "string"
+  ) {
+    op.recipients.push(payload.functionArguments[0].toString());
+  }
+};
+
+const addFungibleToRecipients = (
+  op: Operation | APIOperation<AptosAsset>,
+  payload: InputEntryFunctionData,
+) => {
+  if (
+    payload.functionArguments &&
+    payload.functionArguments.length > 1 &&
+    typeof payload.functionArguments[0] === "object" &&
+    typeof payload.functionArguments[1] === "string"
+  ) {
+    op.recipients.push(payload.functionArguments[1].toString());
+  }
+};
+
+const addBatchedFunctions = (
+  op: Operation | APIOperation<AptosAsset>,
+  payload: InputEntryFunctionData,
+  address: string,
+) => {
+  if (
+    !(
+      payload.functionArguments &&
+      payload.functionArguments.length > 0 &&
+      Array.isArray(payload.functionArguments[0])
+    )
+  ) {
+    return;
+  }
+  for (const recipient of payload.functionArguments[0]) {
+    if (recipient && compareAddress(recipient.toString(), address)) {
+      op.recipients.push(recipient.toString());
+    }
+  }
+};
+
+export function processRecipients(
+  payload: InputEntryFunctionData,
+  address: string,
+  op: Operation | APIOperation<AptosAsset>,
+  function_address: string,
+): void {
+  // get recipients by 3 groups
+  if (transferLikeFunctions(payload)) {
+    // 1. Transfer like functions (includes some delegation pool functions)
+    addLikeFunctionsToRecipients(op, payload);
+  } else if (FA_TRANSFER_TYPES.includes(payload.function)) {
+    // 1. Transfer like functions (includes some delegation pool functions)
+    addFungibleToRecipients(op, payload);
+  } else if (BATCH_TRANSFER_TYPES.includes(payload.function)) {
+    // 2. Batch function, to validate we are in the recipients list
+    if (!compareAddress(op.senders[0], address)) {
+      addBatchedFunctions(op, payload, address);
+    }
+  } else {
+    // 3. other smart contracts, in this case smart contract will be treated as a recipient
+    op.recipients.push(function_address);
+  }
+}

package/src/logic/transactionsToOperations.ts

@@ -0,0 +1,105 @@
+import { AptosTransaction } from "../types";
+import { Operation } from "@ledgerhq/coin-framework/api/types";
+import { AptosAsset } from "../types/assets";
+import BigNumber from "bignumber.js";
+import { EntryFunctionPayloadResponse, InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import { APTOS_ASSET_ID, DIRECTION } from "../constants";
+import { compareAddress, getCoinAndAmounts } from "./getCoinAndAmounts";
+import { calculateAmount } from "./calculateAmount";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/index";
+import { processRecipients } from "./processRecipients";
+import { getFunctionAddress } from "./getFunctionAddress";
+
+export const convertFunctionPayloadResponseToInputEntryFunctionData = (
+  payload: EntryFunctionPayloadResponse,
+): InputEntryFunctionData => ({
+  function: payload.function,
+  typeArguments: payload.type_arguments,
+  functionArguments: payload.arguments,
+});
+
+const detectType = (address: string, tx: AptosTransaction, value: BigNumber): DIRECTION => {
+  let type = compareAddress(tx.sender, address) ? DIRECTION.OUT : DIRECTION.IN;
+
+  if (!value) {
+    // skip transaction that result no Aptos change
+    type = DIRECTION.UNKNOWN;
+  }
+
+  return type;
+};
+
+export function transactionsToOperations(
+  address: string,
+  txs: (AptosTransaction | null)[],
+): [Operation<AptosAsset>[], Operation<AptosAsset>[]] {
+  const operations: [Operation<AptosAsset>[], Operation<AptosAsset>[]] = [[], []];
+
+  return txs.reduce((acc, tx) => {
+    if (tx === null) {
+      return acc;
+    }
+
+    const payload = convertFunctionPayloadResponseToInputEntryFunctionData(
+      tx.payload as EntryFunctionPayloadResponse,
+    );
+
+    const function_address = getFunctionAddress(payload);
+
+    if (!function_address) {
+      return acc; // skip transaction without functions in payload
+    }
+
+    const { coin_id, amount_in, amount_out } = getCoinAndAmounts(tx, address);
+    const value = calculateAmount(tx.sender, address, amount_in, amount_out);
+    const type = detectType(address, tx, value);
+
+    const op: Operation<AptosAsset> = {
+      id: tx.hash,
+      type,
+      senders: [],
+      recipients: [],
+      value: BigInt(0),
+      asset: { type: "native" },
+      details: {
+        hasFailed: !tx.success,
+      },
+      tx: {
+        hash: tx.hash,
+        block: { height: 0 },
+        fees: BigInt(0),
+        date: new Date(parseInt(tx.timestamp) / 1000),
+      },
+    };
+
+    const fees = new BigNumber(tx.gas_used).multipliedBy(new BigNumber(tx.gas_unit_price));
+    op.tx.fees = BigInt(fees.toString());
+
+    op.value = BigInt(value.isNaN() ? 0 : value.toString());
+    op.senders.push(tx.sender);
+
+    processRecipients(payload, address, op, function_address);
+
+    if (op.type !== DIRECTION.UNKNOWN && coin_id !== null) {
+      if (coin_id === APTOS_ASSET_ID) {
+        acc[0].push(op);
+        return acc;
+      }
+
+      const token = findTokenByAddressInCurrency(coin_id.toLowerCase(), "aptos");
+
+      if (token !== undefined) {
+        acc[1].push(op);
+
+        if (op.type === DIRECTION.OUT) {
+          acc[0].push({
+            ...op,
+            value: op.tx.fees,
+            type: "FEES",
+          });
+        }
+      }
+    }
+    return acc;
+  }, operations);
+}