@ledgerhq/coin-aptos 2.0.0-nightly.5 → 2.1.0-next.0

package/src/logic/buildTransaction.ts

@@ -0,0 +1,70 @@
+import type { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
+import type { Account } from "@ledgerhq/types-live";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { APTOS_ASSET_ID, TOKEN_TYPE } from "../constants";
+import type { AptosAPI } from "../network";
+import { normalizeTransactionOptions } from "./normalizeTransactionOptions";
+import type { Transaction } from "../types";
+import type BigNumber from "bignumber.js";
+
+const buildTransaction = async (
+  account: Account,
+  transaction: Transaction,
+  aptosClient: AptosAPI,
+  contractAddress?: string,
+  tokenType?: TOKEN_TYPE,
+): Promise<RawTransaction> => {
+  const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
+
+  const payloadContracAddress = subAccount ? subAccount.token.contractAddress : contractAddress;
+  const payloadTokenType = (subAccount?.token?.tokenType as TOKEN_TYPE) ?? tokenType;
+
+  const txPayload = getPayload({
+    amount: transaction.amount,
+    recipient: transaction.recipient,
+    contractAddress: payloadContracAddress,
+    tokenType: payloadTokenType,
+  });
+
+  const txOptions = normalizeTransactionOptions(transaction.options);
+
+  const tx = await aptosClient.generateTransaction(account.freshAddress, txPayload, txOptions);
+
+  return tx;
+};
+
+const getPayload = (args: {
+  amount: BigNumber;
+  recipient: string;
+  contractAddress?: string | undefined;
+  tokenType?: string;
+}): InputEntryFunctionData => {
+  if (args.tokenType !== undefined && !isTokenType(args.tokenType)) {
+    throw new Error(`Token type ${args.tokenType} not supported`);
+  }
+
+  if (args.tokenType === TOKEN_TYPE.FUNGIBLE_ASSET) {
+    return {
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: [args.contractAddress, args.recipient, args.amount.toString()],
+    };
+  }
+
+  let address = args.contractAddress ?? "";
+  if (address === "") {
+    address = APTOS_ASSET_ID;
+  }
+
+  return {
+    function: "0x1::aptos_account::transfer_coins",
+    typeArguments: [address],
+    functionArguments: [args.recipient, args.amount.toString()],
+  };
+};
+
+export const isTokenType = (value: string): boolean => {
+  return Object.values(TOKEN_TYPE).includes(value as TOKEN_TYPE);
+};
+
+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,65 @@
+import type { TransactionIntent } from "@ledgerhq/coin-framework/lib/api/types";
+import type { AptosAsset, AptosExtra, AptosSender } from "../types/assets";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import type { AptosAPI } from "../network";
+import buildTransaction, { isTokenType } from "./buildTransaction";
+import createTransaction from "./createTransaction";
+import BigNumber from "bignumber.js";
+import { APTOS_ASSET_ID, type TOKEN_TYPE } from "../constants";
+import type { AptosBalance } from "../types";
+
+export async function craftTransaction(
+  aptosClient: AptosAPI,
+  transactionIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>,
+): Promise<string> {
+  const newTx = createTransaction();
+  newTx.amount = BigNumber(transactionIntent.amount.toString());
+  newTx.recipient = transactionIntent.recipient;
+  newTx.mode = transactionIntent.type;
+  newTx.useAllAmount = transactionIntent.amount === BigInt(0);
+
+  const account = {
+    freshAddress: transactionIntent.sender.freshAddress,
+    xpub: transactionIntent.sender.xpub,
+    subAccounts: new Array<TokenAccount>(),
+  } as Account;
+
+  let tokenType: TOKEN_TYPE | undefined;
+  const contractAddress = getContractAddress(transactionIntent);
+  let balance: AptosBalance | undefined;
+
+  if (newTx.useAllAmount === true) {
+    const balances = await aptosClient.getBalances(transactionIntent.sender.freshAddress);
+    balance = balances?.find(
+      b => b.contractAddress.toLowerCase() === contractAddress?.toLowerCase(),
+    );
+
+    if (balance !== undefined) {
+      newTx.amount = BigNumber(balance.amount.toString());
+    }
+  }
+
+  if (transactionIntent.asset.type === "token") {
+    tokenType = transactionIntent.asset.standard as TOKEN_TYPE;
+  }
+
+  const aptosTx = await buildTransaction(
+    account,
+    newTx,
+    aptosClient,
+    contractAddress,
+    tokenType ?? undefined,
+  );
+
+  return aptosTx.bcsToHex().toString();
+}
+
+function getContractAddress(
+  txIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>,
+): string {
+  if (txIntent.asset.type === "token" && isTokenType(txIntent.asset.standard)) {
+    return txIntent.asset.contractAddress;
+  }
+
+  return APTOS_ASSET_ID;
+}

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/normalizeAddress.ts

@@ -0,0 +1,8 @@
+export const normalizeAddress = (address: string): string => {
+  const rawAddresss = address.slice(2);
+  if (rawAddresss.length === 64) {
+    return address;
+  }
+
+  return "0x" + rawAddresss.padStart(64, "0");
+};

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,88 @@
+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";
+import { normalizeAddress } from "./normalizeAddress";
+
+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(normalizeAddress(payload.functionArguments[0]));
+  }
+};
+
+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(normalizeAddress(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(normalizeAddress(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,106 @@
+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 { processRecipients } from "./processRecipients";
+import { getFunctionAddress } from "./getFunctionAddress";
+import { normalizeAddress } from "./normalizeAddress";
+
+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;
+};
+
+const getTokenStandard = (coin_id: string): string => {
+  const parts = coin_id.split("::");
+  if (parts.length === 3) {
+    return "coin";
+  }
+  return "fungible_asset";
+};
+
+export function transactionsToOperations(
+  address: string,
+  txs: (AptosTransaction | null)[],
+): Operation<AptosAsset>[] {
+  const operations: 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(normalizeAddress(tx.sender));
+
+    processRecipients(payload, address, op, function_address);
+
+    if (op.type !== DIRECTION.UNKNOWN && coin_id !== null) {
+      if (coin_id === APTOS_ASSET_ID) {
+        acc.push(op);
+        return acc;
+      } else {
+        op.asset = {
+          type: "token",
+          standard: getTokenStandard(coin_id),
+          contractAddress: coin_id,
+        };
+        acc.push(op);
+      }
+    }
+    return acc;
+  }, operations);
+}