@ledgerhq/coin-aptos 2.5.1 → 2.5.2-nightly.0

package/src/bridge/getTransactionStatus.ts

@@ -1,5 +1,10 @@
 import {
   NotEnoughBalance,
+  NotEnoughToStake,
+  UnstakeNotEnoughStakedBalanceLeft,
+  RestakeNotEnoughStakedBalanceLeft,
+  NotEnoughToRestake,
+  NotEnoughToUnstake,
   RecipientRequired,
   InvalidAddress,
   FeeNotLoaded,
@@ -7,69 +12,240 @@ import {
   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 { BigNumber } from "bignumber.js";
+import type { AptosAccount, AptosStakingPosition, Transaction, TransactionStatus } from "../types";
 import { getTokenAccount } from "./logic";
+import {
+  APTOS_DELEGATION_RESERVE_IN_OCTAS,
+  APTOS_MINIMUM_RESTAKE,
+  APTOS_MINIMUM_RESTAKE_IN_OCTAS,
+  APTOS_PRECISION,
+  MIN_AMOUNT_TO_UNSTAKE,
+  MIN_AMOUNT_TO_UNSTAKE_IN_OCTAS,
+  MIN_COINS_ON_SHARES_POOL,
+  MIN_COINS_ON_SHARES_POOL_IN_OCTAS,
+} from "../constants";
+import { TokenAccount } from "@ledgerhq/types-live";
+import { getStakingPosition } from "../logic/staking";
 
-const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
-  const errors: Record<string, Error> = {};
-  const warnings = {};
+const checkSendTransaction = (
+  t: Transaction,
+  a: AptosAccount,
+  tokenAccount: TokenAccount | undefined,
+  estimatedFees: BigNumber,
+  errors: Record<string, Error>,
+): Record<string, Error> => {
+  const newErrors = { ...errors };
 
   if (!t.recipient) {
-    errors.recipient = new RecipientRequired();
+    newErrors.recipient = new RecipientRequired();
   }
 
-  if (!AccountAddress.isValid({ input: t.recipient }).valid && !errors.recipient) {
-    errors.recipient = new InvalidAddress("", { currencyName: a.currency.name });
+  if (!AccountAddress.isValid({ input: t.recipient }).valid && !newErrors.recipient) {
+    newErrors.recipient = new InvalidAddress("", { currencyName: a.currency.name });
   }
 
-  if (t.recipient === a.freshAddress && !errors.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  if (t.recipient === a.freshAddress && !newErrors.recipient) {
+    newErrors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
   }
 
-  if (!t.fees) {
-    errors.fees = new FeeNotLoaded();
+  if (t.amount.gt(a.balance) && !newErrors.amount) {
+    newErrors.amount = new NotEnoughBalance();
+  }
+
+  if (tokenAccount && t.errors?.maxGasAmount === "GasInsufficientBalance" && !newErrors.amount) {
+    newErrors.amount = new NotEnoughBalanceFees();
+  }
+
+  if (
+    (tokenAccount
+      ? tokenAccount.spendableBalance.isLessThan(t.amount) ||
+        a.spendableBalance.isLessThan(estimatedFees)
+      : a.spendableBalance.isLessThan(t.amount.plus(estimatedFees))) &&
+    !newErrors.amount
+  ) {
+    newErrors.amount = new NotEnoughBalance();
+  }
+
+  return newErrors;
+};
+
+const checkStakeTransaction = (
+  t: Transaction,
+  stakingPosition: AptosStakingPosition | undefined,
+  a: AptosAccount,
+  errors: Record<string, Error>,
+): Record<string, Error> => {
+  const newErrors = { ...errors };
+
+  if (t.amount.gt(a.spendableBalance)) {
+    newErrors.amount = new NotEnoughBalance();
+  }
+
+  if (
+    (((!stakingPosition || stakingPosition?.active.isZero()) &&
+      ((!t.useAllAmount && t.amount.lt(MIN_COINS_ON_SHARES_POOL_IN_OCTAS)) ||
+        (t.useAllAmount &&
+          a.spendableBalance
+            .minus(APTOS_DELEGATION_RESERVE_IN_OCTAS)
+            .lt(MIN_COINS_ON_SHARES_POOL_IN_OCTAS)))) ||
+      (stakingPosition &&
+        !stakingPosition.active.isZero() &&
+        t.amount.lt(APTOS_MINIMUM_RESTAKE_IN_OCTAS))) &&
+    !newErrors.amount
+  ) {
+    newErrors.amount = new NotEnoughToStake("", {
+      minStake:
+        stakingPosition && !stakingPosition.active.isZero()
+          ? APTOS_MINIMUM_RESTAKE
+          : MIN_COINS_ON_SHARES_POOL,
+      currency: a.currency.ticker,
+    });
+  }
+
+  return newErrors;
+};
+
+const checkRestakeTransaction = (
+  t: Transaction,
+  stakingPosition: AptosStakingPosition | undefined,
+  errors: Record<string, Error>,
+): Record<string, Error> => {
+  const newErrors = { ...errors };
+
+  if (!stakingPosition) {
+    newErrors.recipient = new RecipientRequired();
+  } else {
+    if ((t.amount.gt(stakingPosition.pendingInactive) || t.amount.isZero()) && !newErrors.amount) {
+      newErrors.amount = new NotEnoughBalance();
+    }
+    if (!t.useAllAmount && t.amount.lt(MIN_COINS_ON_SHARES_POOL_IN_OCTAS) && !newErrors.amount) {
+      newErrors.amount = new NotEnoughToRestake("", {
+        minAmount: `${MIN_COINS_ON_SHARES_POOL.toNumber().toString()} APT`,
+      });
+    }
+    if (
+      !t.useAllAmount &&
+      stakingPosition.pendingInactive.minus(t.amount).lt(MIN_COINS_ON_SHARES_POOL_IN_OCTAS) &&
+      !newErrors.amount
+    ) {
+      newErrors.amount = new RestakeNotEnoughStakedBalanceLeft("", {
+        maxAmount: `${stakingPosition.pendingInactive.minus(MIN_COINS_ON_SHARES_POOL_IN_OCTAS).shiftedBy(-APTOS_PRECISION).toNumber().toString()} APT`,
+        totalAmount: `${stakingPosition.pendingInactive.shiftedBy(-APTOS_PRECISION).toNumber().toString()} APT`,
+      });
+    }
+  }
+
+  return newErrors;
+};
+
+const checkUnstakeTransaction = (
+  t: Transaction,
+  stakingPosition: AptosStakingPosition | undefined,
+  errors: Record<string, Error>,
+): Record<string, Error> => {
+  const newErrors = { ...errors };
+
+  if (!stakingPosition) {
+    newErrors.recipient = new RecipientRequired();
+  } else {
+    if (t.amount.gt(stakingPosition.active) && !newErrors.amount) {
+      newErrors.amount = new NotEnoughBalance();
+    }
+    if (!t.useAllAmount && t.amount.lt(MIN_AMOUNT_TO_UNSTAKE_IN_OCTAS) && !newErrors.amount) {
+      newErrors.amount = new NotEnoughToUnstake("", {
+        minAmount: `${MIN_AMOUNT_TO_UNSTAKE.toNumber().toString()} APT`,
+      });
+    }
+    if (
+      !t.useAllAmount &&
+      stakingPosition.active.minus(t.amount).lt(MIN_AMOUNT_TO_UNSTAKE_IN_OCTAS) &&
+      !newErrors.amount
+    ) {
+      newErrors.amount = new UnstakeNotEnoughStakedBalanceLeft("", {
+        maxAmount: `${stakingPosition.active.minus(MIN_AMOUNT_TO_UNSTAKE_IN_OCTAS).shiftedBy(-APTOS_PRECISION).toNumber().toString()} APT`,
+        totalAmount: `${stakingPosition.active.shiftedBy(-APTOS_PRECISION).toNumber().toString()} APT`,
+      });
+    }
   }
 
+  return newErrors;
+};
+
+const checkWithdrawTransaction = (
+  t: Transaction,
+  stakingPosition: AptosStakingPosition | undefined,
+  errors: Record<string, Error>,
+) => {
+  const newErrors = { ...errors };
+
+  if (!stakingPosition) {
+    newErrors.recipient = new RecipientRequired();
+  } else if (t.amount.gt(stakingPosition.inactive) && !newErrors.amount) {
+    newErrors.amount = new NotEnoughBalance();
+  }
+
+  return newErrors;
+};
+
+const getTransactionStatus = async (
+  a: AptosAccount,
+  t: Transaction,
+): Promise<TransactionStatus> => {
+  let errors: Record<string, Error> = {};
+  const warnings = {};
+
   const estimatedFees = t.fees || BigNumber(0);
+  const tokenAccount = getTokenAccount(a, t);
+
+  const stakingPosition = getStakingPosition(a, t.recipient);
 
-  if (t.amount.lte(0)) {
+  if (!t.useAllAmount && t.amount.lte(0)) {
     errors.amount = new AmountRequired();
   }
 
-  const tokenAccount = getTokenAccount(a, t);
+  switch (t.mode) {
+    case "send":
+      errors = checkSendTransaction(t, a, tokenAccount, estimatedFees, errors);
+      break;
+    case "stake":
+      errors = checkStakeTransaction(t, stakingPosition, a, errors);
+      break;
+    case "restake":
+      errors = checkRestakeTransaction(t, stakingPosition, errors);
+      break;
+    case "unstake":
+      errors = checkUnstakeTransaction(t, stakingPosition, errors);
+      break;
+    case "withdraw":
+      errors = checkWithdrawTransaction(t, stakingPosition, errors);
+      break;
+  }
+
+  if (!t.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  const maxSpendable =
+    t.mode === "stake"
+      ? a.spendableBalance.minus(estimatedFees).minus(APTOS_DELEGATION_RESERVE_IN_OCTAS)
+      : a.spendableBalance.minus(estimatedFees);
 
   const amount = t.useAllAmount
     ? tokenAccount
       ? tokenAccount.spendableBalance
       : a.spendableBalance.minus(estimatedFees).isLessThan(0)
         ? BigNumber(0)
-        : a.spendableBalance.minus(estimatedFees)
+        : maxSpendable
     : t.amount;
 
-  const totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);
-
-  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({
     errors,
     warnings,
     estimatedFees,
     amount,
-    totalSpent,
+    totalSpent: tokenAccount ? amount : amount.plus(estimatedFees),
   });
 };
 

package/src/bridge/index.ts

@@ -7,9 +7,10 @@ import {
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import type { SignerContext } from "@ledgerhq/coin-framework/signer";
-import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import resolver from "../signer";
-import type { Transaction, TransactionStatus, AptosSigner } from "../types";
+import { assignToAccountRaw, assignFromAccountRaw } from "./serialization";
+import type { Transaction, TransactionStatus, AptosSigner, AptosAccount } from "../types";
 import getTransactionStatus from "./getTransactionStatus";
 import estimateMaxSpendable from "./estimateMaxSpendable";
 import prepareTransaction from "./prepareTransaction";
@@ -17,6 +18,12 @@ import { getAccountShape } from "./synchronisation";
 import buildSignOperation from "./signOperation";
 import broadcast from "./broadcast";
 import createTransaction from "../logic/createTransaction";
+import { hydrate, preloadWithValidators } from "../preload";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+function makePreload() {
+  return (currency: CryptoCurrency) => preloadWithValidators(currency);
+}
 
 function buildCurrencyBridge(signerContext: SignerContext<AptosSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);
@@ -27,8 +34,8 @@ function buildCurrencyBridge(signerContext: SignerContext<AptosSigner>): Currenc
   });
 
   return {
-    preload: () => Promise.resolve({}),
-    hydrate: () => {},
+    preload: makePreload(),
+    hydrate,
     scanAccounts,
   };
 }
@@ -37,7 +44,7 @@ const sync = makeSync({ getAccountShape });
 
 function buildAccountBridge(
   signerContext: SignerContext<AptosSigner>,
-): AccountBridge<Transaction, Account, TransactionStatus> {
+): AccountBridge<Transaction, AptosAccount, TransactionStatus> {
   const getAddress = resolver(signerContext);
 
   const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
@@ -54,6 +61,8 @@ function buildAccountBridge(
     receive,
     signOperation,
     broadcast,
+    assignToAccountRaw,
+    assignFromAccountRaw,
   };
 }
 

package/src/bridge/logic.ts

@@ -1,3 +1,4 @@
+import BigNumber from "bignumber.js";
 import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
 import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import {
@@ -6,11 +7,10 @@ import {
   findSubAccountById,
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
-import BigNumber from "bignumber.js";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { APTOS_ASSET_ID, DIRECTION } from "../constants";
-import type { AptosTransaction, Transaction } from "../types";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import { APTOS_ASSET_ID, OP_TYPE, DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
+import type { AptosTransaction, Transaction } from "../types";
 import { convertFunctionPayloadResponseToInputEntryFunctionData } from "../logic/transactionsToOperations";
 import { compareAddress, getCoinAndAmounts } from "../logic/getCoinAndAmounts";
 import { calculateAmount } from "../logic/calculateAmount";
@@ -18,14 +18,17 @@ import { processRecipients } from "../logic/processRecipients";
 import { getFunctionAddress } from "../logic/getFunctionAddress";
 
 export const getMaxSendBalance = (
-  gas: BigNumber,
-  gasPrice: BigNumber,
   account: Account,
   transaction?: Transaction,
+  gas?: BigNumber,
+  gasPrice?: BigNumber,
 ): BigNumber => {
   const tokenAccount = findSubAccountById(account, transaction?.subAccountId ?? "");
   const fromTokenAccount = tokenAccount && isTokenAccount(tokenAccount);
 
+  gas = gas ?? BigNumber(DEFAULT_GAS);
+  gasPrice = gasPrice ?? BigNumber(DEFAULT_GAS_PRICE);
+
   const totalGas = gas.multipliedBy(gasPrice);
 
   return fromTokenAccount
@@ -59,10 +62,11 @@ export const txsToOps = (
   info: { address: string },
   id: string,
   txs: (AptosTransaction | null)[],
-): [Operation[], Operation[]] => {
+): [Operation[], Operation[], Operation[]] => {
   const { address } = info;
   const ops: Operation[] = [];
   const opsTokens: Operation[] = [];
+  const opsStaking: Operation[] = [];
 
   txs.forEach(tx => {
     if (tx !== null) {
@@ -79,9 +83,14 @@ export const txsToOps = (
         return; // skip transaction without functions in payload
       }
 
-      const { coin_id, amount_in, amount_out } = getCoinAndAmounts(tx, address);
+      const { coin_id, amount_in, amount_out, type } = getCoinAndAmounts(tx, address);
       op.value = calculateAmount(tx.sender, address, amount_in, amount_out);
-      op.type = compareAddress(tx.sender, address) ? DIRECTION.OUT : DIRECTION.IN;
+      op.type =
+        type !== OP_TYPE.UNKNOWN
+          ? type
+          : compareAddress(tx.sender, address)
+            ? OP_TYPE.OUT
+            : OP_TYPE.IN;
       op.senders.push(tx.sender);
       op.hasFailed = !tx.success;
       op.id = encodeOperationId(op.accountId, tx.hash, op.type);
@@ -90,10 +99,17 @@ export const txsToOps = (
 
       if (op.value.isZero()) {
         // skip transaction that result no Aptos change
-        op.type = DIRECTION.UNKNOWN;
+        op.type = OP_TYPE.UNKNOWN;
       }
 
-      if (op.type !== DIRECTION.UNKNOWN && coin_id !== null) {
+      if (
+        op.type === OP_TYPE.STAKE ||
+        op.type === OP_TYPE.UNSTAKE ||
+        op.type === OP_TYPE.WITHDRAW
+      ) {
+        ops.push(op);
+        opsStaking.push(op);
+      } else if (op.type !== OP_TYPE.UNKNOWN && coin_id !== null) {
         if (coin_id === APTOS_ASSET_ID) {
           ops.push(op);
         } else {
@@ -102,7 +118,7 @@ export const txsToOps = (
             op.accountId = encodeTokenAccountId(id, token);
             opsTokens.push(op);
 
-            if (op.type === DIRECTION.OUT) {
+            if (op.type === OP_TYPE.OUT) {
               ops.push({
                 ...op,
                 accountId: decodeTokenAccountId(op.accountId).accountId,
@@ -116,7 +132,7 @@ export const txsToOps = (
     }
   });
 
-  return [ops, opsTokens];
+  return [ops, opsTokens, opsStaking];
 };
 
 export function getTokenAccount(

package/src/bridge/prepareTransaction.ts

@@ -1,23 +1,69 @@
-import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 
 import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
-import type { Transaction } from "../types";
+import type { AptosAccount, Transaction } from "../types";
 import { getMaxSendBalance } from "./logic";
-import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../constants";
+import {
+  APTOS_DELEGATION_RESERVE_IN_OCTAS,
+  APTOS_MINIMUM_RESTAKE_IN_OCTAS,
+  MIN_COINS_ON_SHARES_POOL_IN_OCTAS,
+} from "./../constants";
+import { getDelegationOpMaxAmount, getStakingPosition } from "../logic/staking";
+
+const checkSendConditions = (transaction: Transaction, account: AptosAccount) =>
+  transaction.mode === "send" && transaction.amount.gt(account.spendableBalance);
+
+const checkStakeConditions = (transaction: Transaction, account: AptosAccount) => {
+  const txAmount = transaction.useAllAmount ? account.spendableBalance : transaction.amount;
+  const stakingPosition = account.aptosResources?.stakingPositions
+    ?.find(stakingPosition => stakingPosition.validatorId === transaction.recipient)
+    ?.active.gt(MIN_COINS_ON_SHARES_POOL_IN_OCTAS);
+  const minimumToStake = stakingPosition
+    ? APTOS_MINIMUM_RESTAKE_IN_OCTAS
+    : MIN_COINS_ON_SHARES_POOL_IN_OCTAS;
+
+  return (
+    transaction.mode === "stake" &&
+    (txAmount.gt(account.spendableBalance) || txAmount.lt(minimumToStake))
+  );
+};
+
+const checkRestakeConditions = (transaction: Transaction, account: AptosAccount) => {
+  const stakingPosition = getStakingPosition(account, transaction.recipient)?.pendingInactive || 0;
+
+  return transaction.mode === "restake" && transaction.amount.gt(stakingPosition);
+};
+
+const checkUnstakeConditions = (transaction: Transaction, account: AptosAccount) => {
+  const stakingPosition = getStakingPosition(account, transaction.recipient)?.active || 0;
+
+  return transaction.mode === "unstake" && transaction.amount.gt(stakingPosition);
+};
+
+const checkWithdrawConditions = (transaction: Transaction, account: AptosAccount) => {
+  const stakingPosition = getStakingPosition(account, transaction.recipient)?.inactive || 0;
+
+  return transaction.mode === "withdraw" && transaction.amount.gt(stakingPosition);
+};
 
 const prepareTransaction = async (
-  account: Account,
+  account: AptosAccount,
   transaction: Transaction,
 ): Promise<Transaction> => {
-  if (!transaction.recipient) {
+  if (
+    !transaction.recipient ||
+    checkSendConditions(transaction, account) ||
+    checkStakeConditions(transaction, account) ||
+    checkRestakeConditions(transaction, account) ||
+    checkUnstakeConditions(transaction, account) ||
+    checkWithdrawConditions(transaction, account)
+  )
     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) {
+  if (!transaction.useAllAmount && transaction.amount.isZero()) {
     return {
       ...transaction,
       fees: BigNumber(0),
@@ -27,27 +73,29 @@ const prepareTransaction = async (
   const aptosClient = new AptosAPI(account.currency.id);
 
   if (transaction.useAllAmount) {
-    // we will use this amount in simulation, to estimate gas
-    transaction.amount = getMaxSendBalance(
-      new BigNumber(DEFAULT_GAS),
-      new BigNumber(DEFAULT_GAS_PRICE),
-      account,
-      transaction,
-    );
+    if (transaction.mode === "send") {
+      transaction.amount = getMaxSendBalance(account, transaction);
+    } else if (
+      transaction.mode === "restake" ||
+      transaction.mode === "unstake" ||
+      transaction.mode === "withdraw"
+    ) {
+      // Reserve a certain amount to cover future network fees to deactivate and withdraw
+      transaction.amount = getDelegationOpMaxAmount(
+        account,
+        transaction.recipient,
+        transaction.mode,
+      );
+    } else if (transaction.mode === "stake") {
+      // Reserve a certain amount to cover future network fees to deactivate and withdraw
+      transaction.amount = getMaxSendBalance(account, transaction).minus(
+        APTOS_DELEGATION_RESERVE_IN_OCTAS,
+      );
+    }
   }
 
   const { fees, estimate, errors } = await getEstimatedGas(account, transaction, aptosClient);
 
-  if (transaction.useAllAmount) {
-    // correct the transaction amount according to estimated fees
-    transaction.amount = getMaxSendBalance(
-      BigNumber(estimate.maxGasAmount),
-      BigNumber(estimate.gasUnitPrice),
-      account,
-      transaction,
-    );
-  }
-
   transaction.fees = fees;
   transaction.options = estimate;
   transaction.errors = errors;

package/src/bridge/serialization.ts

@@ -0,0 +1,52 @@
+import BigNumber from "bignumber.js";
+import { AptosAccount, AptosAccountRaw, AptosResources, AptosResourcesRaw } from "../types";
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+
+export function toAptosResourcesRaw(r: AptosResources): AptosResourcesRaw {
+  const { activeBalance, pendingInactiveBalance, inactiveBalance, stakingPositions } = r;
+  return {
+    activeBalance: activeBalance.toString(),
+    pendingInactiveBalance: pendingInactiveBalance.toString(),
+    inactiveBalance: inactiveBalance.toString(),
+    stakingPositions: stakingPositions.map(
+      ({ active, validatorId, inactive, pendingInactive }) => ({
+        active: active.toString(),
+        pendingInactive: pendingInactive.toString(),
+        inactive: inactive.toString(),
+        validatorId,
+      }),
+    ),
+  };
+}
+
+export function fromAptosResourcesRaw(r: AptosResourcesRaw): AptosResources {
+  const { activeBalance, pendingInactiveBalance, inactiveBalance, stakingPositions = [] } = r;
+  return {
+    activeBalance: new BigNumber(activeBalance),
+    pendingInactiveBalance: new BigNumber(pendingInactiveBalance),
+    inactiveBalance: new BigNumber(inactiveBalance),
+    stakingPositions: stakingPositions.map(
+      ({ active, pendingInactive, inactive, validatorId }) => ({
+        active: new BigNumber(active),
+        pendingInactive: new BigNumber(pendingInactive),
+        inactive: new BigNumber(inactive),
+        validatorId,
+      }),
+    ),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const aptosAccount = account as AptosAccount;
+  if (aptosAccount.aptosResources) {
+    (accountRaw as AptosAccountRaw).aptosResources = toAptosResourcesRaw(
+      aptosAccount.aptosResources,
+    );
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const aptosResourcesRaw = (accountRaw as AptosAccountRaw).aptosResources;
+  if (aptosResourcesRaw)
+    (account as AptosAccount).aptosResources = fromAptosResourcesRaw(aptosResourcesRaw);
+}

package/src/bridge/signOperation.ts

@@ -1,4 +1,4 @@
-import type { AptosAccount, Transaction } from "../types";
+import type { AptosAccount, AptosOperation, Transaction } from "../types";
 import { Observable } from "rxjs";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import BigNumber from "bignumber.js";
@@ -16,6 +16,21 @@ export const getAddress = (a: Account) => ({
   derivationPath: a.freshAddressPath,
 });
 
+const getOperationType = (transaction: Transaction): OperationType => {
+  switch (transaction.mode) {
+    case "stake":
+      return "STAKE";
+    case "restake":
+      return "STAKE";
+    case "unstake":
+      return "UNSTAKE";
+    case "withdraw":
+      return "WITHDRAW";
+    default:
+      return "OUT";
+  }
+};
+
 const buildSignOperation =
   (
     signerContext: SignerContext<AptosSigner>,
@@ -35,22 +50,20 @@ const buildSignOperation =
 
         const accountId = account.id;
         const hash = "";
-        const type: OperationType = "OUT";
+        const type: OperationType = getOperationType(transaction);
         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);
-        }
+        senders.push(account.freshAddress);
+        recipients.push(transaction.recipient);
 
         const subAccount =
           !!transaction.subAccountId && findSubAccountById(account, transaction.subAccountId);
 
         // build optimistic operation
-        const operation: Operation = {
+        const operation: AptosOperation = {
           id: encodeOperationId(accountId, hash, type),
           hash,
           type,