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

package/src/api/index.ts

@@ -1,9 +1,12 @@
 import type { Api } from "@ledgerhq/coin-framework/api/index";
 import type { AptosConfig as AptosConfigApi } from "../config";
-import type { Balance, Operation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { Balance, Pagination, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import coinConfig from "../config";
 import type { AptosAsset, AptosExtra, AptosFeeParameters, AptosSender } from "../types/assets";
 import { AptosAPI } from "../network";
+import { combine } from "../logic/combine";
+import { craftTransaction } from "../logic/craftTransaction";
+import { getBalance } from "../logic/getBalance";
 
 export function createApi(
   config: AptosConfigApi,
@@ -14,20 +17,14 @@ export function createApi(
 
   return {
     broadcast: (tx: string) => client.broadcast(tx),
-    combine: (_tx, _signature, _pubkey): string => {
-      throw new Error("Not Implemented");
-    },
-    craftTransaction: (_transactionIntent, _customFees): Promise<string> => {
-      throw new Error("Not Implemented");
-    },
+    combine: (tx, signature, pubkey): string => combine(tx, signature, pubkey),
+    craftTransaction: (transactionIntent, _customFees): Promise<string> =>
+      craftTransaction(client, transactionIntent),
     estimateFees: (transactionIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>) =>
       client.estimateFees(transactionIntent),
-    getBalance: (_address): Promise<Balance<AptosAsset>[]> => {
-      throw new Error("Not Implemented");
-    },
+    getBalance: (address): Promise<Balance<AptosAsset>[]> => getBalance(client, address),
     lastBlock: () => client.getLastBlock(),
-    listOperations: (_address, _pagination): Promise<[Operation<AptosAsset>[], string]> => {
-      throw new Error("Not Implemented");
-    },
+    listOperations: (address: string, pagination: Pagination) =>
+      client.listOperations(address, pagination),
   };
 }

package/src/bridge/estimateMaxSpendable.ts

@@ -4,8 +4,8 @@ import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
 import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import { getMaxSendBalance } from "./logic";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 import type { Transaction } from "../types";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 
 const estimateMaxSpendable = async ({
   account,

package/src/bridge/getFeesForTransaction.ts

@@ -4,10 +4,10 @@ import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
 import { AptosAPI } from "../network";
-import buildTransaction from "./buildTransaction";
 import { getTokenAccount } from "./logic";
 import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL } from "../constants";
 import type { Transaction, TransactionErrors } from "../types";
+import buildTransaction from "../logic/buildTransaction";
 
 type IGetEstimatedGasReturnType = {
   fees: BigNumber;

package/src/bridge/index.ts

@@ -13,10 +13,10 @@ 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";
+import createTransaction from "../logic/createTransaction";
 
 function buildCurrencyBridge(signerContext: SignerContext<AptosSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);

package/src/bridge/logic.ts

@@ -1,12 +1,4 @@
-import {
-  EntryFunctionPayloadResponse,
-  Event,
-  InputEntryFunctionData,
-  MoveResource,
-  WriteSetChange,
-  WriteSetChangeWriteResource,
-} from "@aptos-labs/ts-sdk";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
 import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import {
   decodeTokenAccountId,
@@ -16,31 +8,14 @@ import {
 } from "@ledgerhq/coin-framework/account/index";
 import BigNumber from "bignumber.js";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import {
-  APTOS_ASSET_ID,
-  APTOS_FUNGIBLE_STORE,
-  BATCH_TRANSFER_TYPES,
-  DELEGATION_POOL_TYPES,
-  DIRECTION,
-  COIN_TRANSFER_TYPES,
-  FA_TRANSFER_TYPES,
-  APTOS_OBJECT_CORE,
-} from "../constants";
-import type {
-  AptosFungibleoObjectCoreResourceData,
-  AptosFungibleStoreResourceData,
-  AptosMoveResource,
-  AptosTransaction,
-  Transaction,
-  TransactionOptions,
-} from "../types";
+import { APTOS_ASSET_ID, DIRECTION } from "../constants";
+import type { AptosTransaction, Transaction } from "../types";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
-
-const CLEAN_HEX_REGEXP = /^0x0*|^0+/;
-
-export function isTestnet(currencyId: string): boolean {
-  return getCryptoCurrencyById(currencyId).isTestnetFor ? true : false;
-}
+import { convertFunctionPayloadResponseToInputEntryFunctionData } from "../logic/transactionsToOperations";
+import { compareAddress, getCoinAndAmounts } from "../logic/getCoinAndAmounts";
+import { calculateAmount } from "../logic/calculateAmount";
+import { processRecipients } from "../logic/processRecipients";
+import { getFunctionAddress } from "../logic/getFunctionAddress";
 
 export const getMaxSendBalance = (
   gas: BigNumber,
@@ -60,23 +35,6 @@ export const getMaxSendBalance = (
       : 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,
@@ -97,14 +55,6 @@ export const getBlankOperation = (
   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,
@@ -169,227 +119,6 @@ export const txsToOps = (
   return [ops, opsTokens];
 };
 
-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 (
-    (COIN_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 (
-    FA_TRANSFER_TYPES.includes(payload.function) &&
-    payload.functionArguments &&
-    payload.functionArguments.length > 1 &&
-    typeof payload.functionArguments[0] === "object" &&
-    typeof payload.functionArguments[1] === "string"
-  ) {
-    // 1. Transfer like functions (includes some delegation pool functions)
-    op.recipients.push(payload.functionArguments[1].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);
-  }
-}
-
-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 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;
-}
-
-function isWriteSetChangeWriteResource(
-  change: WriteSetChange,
-): change is WriteSetChangeWriteResource {
-  return (change as WriteSetChangeWriteResource).data !== undefined;
-}
-
-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;
-}
-
-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) {
-          if (coin_id === null) 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 }; // TODO: manage situation when there are several coinID from the events parsing
-}
-
-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);
-}
-
-/**
- * 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 = str.match(/<([^<>]+)>{1}$/);
-  return match ? match[1] : null;
-}
-
 export function getTokenAccount(
   account: Account,
   transaction: Transaction,

package/src/bridge/prepareTransaction.ts

@@ -5,7 +5,7 @@ import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import type { Transaction } from "../types";
 import { getMaxSendBalance } from "./logic";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "./../constants";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 
 const prepareTransaction = async (
   account: Account,

package/src/bridge/signOperation.ts

@@ -1,7 +1,6 @@
 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 "../network";
@@ -10,6 +9,7 @@ import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { AptosSigner } from "../types";
 import { signTransaction } from "../network";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
+import buildTransaction from "../logic/buildTransaction";
 
 export const getAddress = (a: Account) => ({
   address: a.freshAddress,

package/src/config.ts

@@ -1,4 +1,4 @@
-import { type AptosSettings } from "@aptos-labs/ts-sdk";
+import type { AptosSettings } from "@aptos-labs/ts-sdk";
 import buildCoinConfig, {
   type CoinConfig,
   type CurrencyConfig,

package/src/constants.ts

@@ -1,8 +1,6 @@
-import { MoveStructId } from "@aptos-labs/ts-sdk";
+import type { MoveStructId } from "@aptos-labs/ts-sdk";
 import BigNumber from "bignumber.js";
 
-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
 
 export const LOAD_LIMIT = 10;
@@ -47,4 +45,10 @@ export enum DIRECTION {
   UNKNOWN = "UNKNOWN",
 }
 
-export const SUPPORTED_TOKEN_TYPES = ["coin", "fungible_asset"];
+export enum TOKEN_TYPE {
+  COIN = "coin",
+  FUNGIBLE_ASSET = "fungible_asset",
+}
+
+export const DEFAULT_GAS = new BigNumber(200);
+export const DEFAULT_GAS_PRICE = new BigNumber(100);

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/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" },
+  }));
+}