@ledgerhq/coin-aptos 2.0.0-nightly.5 → 2.0.0

package/src/api/index.ts

@@ -1,225 +1,33 @@
-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,
+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 coinConfig from "../config";
+import type { AptosAsset, AptosExtra, AptosFeeParameters, AptosSender } from "../types/assets";
+import { AptosAPI } from "../network";
+
+export function createApi(
+  config: AptosConfigApi,
+): Api<AptosAsset, AptosExtra, AptosSender, AptosFeeParameters> {
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
+
+  const client = new AptosAPI(config.aptosSettings);
+
+  return {
+    broadcast: (tx: string) => client.broadcast(tx),
+    combine: (_tx, _signature, _pubkey): string => {
+      throw new Error("Not Implemented");
     },
-  ): 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,
-    };
-  }
+    craftTransaction: (_transactionIntent, _customFees): Promise<string> => {
+      throw new Error("Not Implemented");
+    },
+    estimateFees: (transactionIntent: TransactionIntent<AptosAsset, AptosExtra, AptosSender>) =>
+      client.estimateFees(transactionIntent),
+    getBalance: (_address): Promise<Balance<AptosAsset>[]> => {
+      throw new Error("Not Implemented");
+    },
+    lastBlock: () => client.getLastBlock(),
+    listOperations: (_address, _pagination): Promise<[Operation<AptosAsset>[], string]> => {
+      throw new Error("Not Implemented");
+    },
+  };
 }

package/src/bridge/bridge.fixture.ts

@@ -3,6 +3,7 @@ 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";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 const currency = getCryptoCurrencyById("aptos");
 
@@ -18,35 +19,113 @@ export function createFixtureAccount(account?: Partial<AptosAccount>): AptosAcco
     seedIdentifier: faker.string.uuid(),
     derivationMode: "",
     index: faker.number.int(),
-    freshAddress: account?.freshAddress || freshAddress.address,
-    freshAddressPath: account?.freshAddressPath || freshAddress.derivationPath,
+    freshAddress: freshAddress.address,
+    freshAddressPath: freshAddress.derivationPath,
     used: true,
-    balance: account?.balance || new BigNumber(0),
-    spendableBalance: account?.spendableBalance || new BigNumber(0),
+    balance: new BigNumber(0),
+    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 || [],
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
     lastSyncDate: new Date(),
     balanceHistoryCache: emptyHistoryCache,
     swapHistory: [],
+    ...account,
+  };
+}
+
+export function createFixtureAccountWithSubAccount(
+  tokenType: string,
+  account?: Partial<AptosAccount>,
+): AptosAccount {
+  const freshAddress = {
+    address: "address",
+    derivationPath: "derivation_path",
+  };
+
+  const id = faker.string.uuid();
+
+  return {
+    type: "Account",
+    id,
+    seedIdentifier: faker.string.uuid(),
+    derivationMode: "",
+    index: faker.number.int(),
+    freshAddress: freshAddress.address,
+    freshAddressPath: freshAddress.derivationPath,
+    used: true,
+    balance: new BigNumber(0),
+    spendableBalance: new BigNumber(0),
+    creationDate: faker.date.past(),
+    blockHeight: faker.number.int({ min: 100_000, max: 200_000 }),
+    currency,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+    swapHistory: [],
+    subAccounts: [
+      {
+        id: "1",
+        parentId: id,
+        type: "TokenAccount",
+        token: {
+          type: "TokenCurrency",
+          id: "aptToken",
+          contractAddress: "contract_address",
+          parentCurrency: currency,
+          tokenType,
+        } as TokenCurrency,
+        balance: BigNumber(1000),
+        spendableBalance: BigNumber(1000),
+        creationDate: new Date(),
+        operationsCount: 0,
+        operations: [],
+        pendingOperations: [],
+        balanceHistoryCache: emptyHistoryCache,
+        swapHistory: [],
+      },
+    ],
+    ...account,
   };
 }
 
 export function createFixtureTransaction(tx?: Partial<Transaction>): Transaction {
   const transaction: Transaction = {
-    amount: tx?.amount || new BigNumber(0),
-    recipient: tx?.recipient || "",
-    useAllAmount: tx?.useAllAmount || false,
+    amount: new BigNumber(0),
+    recipient: "recipient",
+    useAllAmount: false,
+    family: "aptos",
+    mode: "send",
+    fees: null,
+    options: {
+      maxGasAmount: BigNumber(0).toString(),
+      gasUnitPrice: BigNumber(0).toString(),
+    },
+    ...tx,
+  };
+
+  return transaction;
+}
+
+export function createFixtureTransactionWithSubAccount(tx?: Partial<Transaction>): Transaction {
+  const transaction: Transaction = {
+    amount: new BigNumber(0),
+    recipient: "recipient",
+    useAllAmount: false,
     family: "aptos",
-    mode: tx?.mode || "send",
-    fees: tx?.fees || null,
+    mode: "send",
+    fees: null,
     options: {
       maxGasAmount: BigNumber(0).toString(),
       gasUnitPrice: BigNumber(0).toString(),
     },
+    subAccountId: "1",
+    ...tx,
   };
 
   return transaction;

package/src/bridge/broadcast.ts

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

package/src/bridge/buildTransaction.ts

@@ -1,8 +1,8 @@
 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 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 { AptosAPI } from "../network";
 import { normalizeTransactionOptions } from "./logic";
 import type { Transaction } from "../types";
 
@@ -11,18 +11,51 @@ const buildTransaction = async (
   transaction: Transaction,
   aptosClient: AptosAPI,
 ): Promise<RawTransaction> => {
-  const txPayload = getPayload(transaction.recipient, transaction.amount);
+  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 = (sendTo: string, amount: BigNumber): InputEntryFunctionData => {
+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: [sendTo, amount.toString()],
+    functionArguments: [transaction.recipient, transaction.amount.toString()],
   };
 };
 

package/src/bridge/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/bridge/estimateMaxSpendable.ts

@@ -1,9 +1,10 @@
 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 { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
+import { getMaxSendBalance } from "./logic";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
 import type { Transaction } from "../types";
 
 const estimateMaxSpendable = async ({
@@ -29,7 +30,7 @@ const estimateMaxSpendable = async ({
     gasUnitPrice = BigNumber(estimate.gasUnitPrice);
   }
 
-  return getMaxSendBalance(mainAccount.spendableBalance, maxGasAmount, gasUnitPrice);
+  return getMaxSendBalance(maxGasAmount, gasUnitPrice, mainAccount, transaction);
 };
 
 export default estimateMaxSpendable;

package/src/bridge/getFeesForTransaction.ts

@@ -3,9 +3,10 @@ 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 { AptosAPI } from "../network";
 import buildTransaction from "./buildTransaction";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL } from "./logic";
+import { getTokenAccount } from "./logic";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL } from "../constants";
 import type { Transaction, TransactionErrors } from "../types";
 
 type IGetEstimatedGasReturnType = {
@@ -49,16 +50,18 @@ export const getFee = async (
 
       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")) {
+      if (!completedTx.success) {
+        if (completedTx.vm_status.includes("MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS")) {
+          res.errors.maxGasAmount = "GasInsufficientBalance";
+        } else if (
+          !completedTx.vm_status.includes("INSUFFICIENT_BALANCE") &&
+          !completedTx.vm_status.includes("0x203ed") // 0x203ed -> PROLOGUE_ECANT_PAY_GAS_DEPOSIT equivalent to INSUFFICIENT_BALANCE_FOR_TRANSACTION_FEE
+        ) {
+          // INSUFFICIENT_BALANCE will be processed by getTransactionStatus
           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;
@@ -72,7 +75,10 @@ export const getFee = async (
 
 const CACHE = makeLRUCache(
   getFee,
-  (account: Account, transaction: Transaction) => `${account.id}-${transaction.amount.toString()}}`,
+  (account: Account, transaction: Transaction) => {
+    const tokenAccount = getTokenAccount(account, transaction);
+    return `${tokenAccount ? tokenAccount.id : account.id}-${transaction.amount.toString()}}`;
+  },
   seconds(30),
 );
 

package/src/bridge/getTransactionStatus.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "bignumber.js";
 import {
   NotEnoughBalance,
   RecipientRequired,
@@ -6,40 +5,63 @@ import {
   FeeNotLoaded,
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
+  NotEnoughBalanceFees,
 } from "@ledgerhq/errors";
 import type { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
 import type { Transaction, TransactionStatus } from "../types";
 
 import { AccountAddress } from "@aptos-labs/ts-sdk";
+import { getTokenAccount } from "./logic";
 
 const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
   const errors: Record<string, Error> = {};
   const warnings = {};
 
+  if (!t.recipient) {
+    errors.recipient = new RecipientRequired();
+  }
+
+  if (!AccountAddress.isValid({ input: t.recipient }).valid && !errors.recipient) {
+    errors.recipient = new InvalidAddress("", { currencyName: a.currency.name });
+  }
+
+  if (t.recipient === a.freshAddress && !errors.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
   if (!t.fees) {
     errors.fees = new FeeNotLoaded();
   }
 
   const estimatedFees = t.fees || BigNumber(0);
 
-  if (t.amount.eq(0)) {
+  if (t.amount.lte(0)) {
     errors.amount = new AmountRequired();
   }
 
-  const amount = t.amount;
+  const tokenAccount = getTokenAccount(a, t);
 
-  const totalSpent = BigNumber(t.amount).plus(estimatedFees);
+  const amount = t.useAllAmount
+    ? tokenAccount
+      ? tokenAccount.spendableBalance
+      : a.spendableBalance.minus(estimatedFees).isLessThan(0)
+        ? BigNumber(0)
+        : a.spendableBalance.minus(estimatedFees)
+    : t.amount;
 
-  if (totalSpent.gt(a.balance) && !errors.amount) {
-    errors.amount = new NotEnoughBalance();
-  }
+  const totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);
 
-  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();
+  if (tokenAccount && t.errors?.maxGasAmount == "GasInsufficientBalance" && !errors.amount) {
+    errors.amount = new NotEnoughBalanceFees();
+  }
+  if (
+    tokenAccount
+      ? tokenAccount.spendableBalance.isLessThan(totalSpent) ||
+        a.spendableBalance.isLessThan(estimatedFees)
+      : a.spendableBalance.isLessThan(totalSpent) && !errors.amount
+  ) {
+    errors.amount = new NotEnoughBalance();
   }
 
   return Promise.resolve({

package/src/bridge/index.ts

@@ -6,7 +6,7 @@ import {
   updateTransaction,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { 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";