@ledgerhq/coin-vechain 2.9.1-nightly.1 → 2.10.0-nightly.2

package/src/common-logic/mapping-utils.ts

@@ -1,67 +0,0 @@
-import BigNumber from "bignumber.js";
-import vip180 from "../contracts/abis/VIP180";
-import { Operation } from "@ledgerhq/types-live";
-import { EventLog, TransferLog } from "../types";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { getFees } from "../network";
-
-export const mapVetTransfersToOperations = async (
-  txs: TransferLog[],
-  accountId: string,
-  addr: string,
-): Promise<Operation[]> => {
-  return Promise.all(
-    txs.map(async tx => {
-      const fees = await getFees(tx.meta.txID);
-      return {
-        id: encodeOperationId(
-          accountId,
-          tx.meta.txID,
-          tx.recipient === addr.toLowerCase() ? "IN" : "OUT",
-        ),
-        hash: tx.meta.txID,
-        type: tx.recipient === addr.toLowerCase() ? "IN" : "OUT",
-        value: new BigNumber(tx.amount),
-        fee: new BigNumber(fees),
-        senders: [tx.sender],
-        recipients: [tx.recipient],
-        blockHeight: tx.meta.blockNumber,
-        blockHash: tx.meta.blockID,
-        accountId,
-        date: new Date(tx.meta.blockTimestamp * 1000),
-        extra: {},
-      };
-    }),
-  );
-};
-
-export const mapTokenTransfersToOperations = async (
-  evnts: EventLog[],
-  accountId: string,
-  addr: string,
-): Promise<Operation[]> => {
-  return Promise.all(
-    evnts.map(async evnt => {
-      const decoded = vip180.TransferEvent.decode(evnt.data, evnt.topics);
-      const fees = await getFees(evnt.meta.txID);
-      return {
-        id: encodeOperationId(
-          accountId,
-          evnt.meta.txID,
-          decoded.to === addr.toLowerCase() ? "IN" : "OUT",
-        ),
-        hash: evnt.meta.txID,
-        type: decoded.to === addr.toLowerCase() ? "IN" : "OUT",
-        value: new BigNumber(decoded.value),
-        fee: fees,
-        senders: [decoded.from],
-        recipients: [decoded.to],
-        blockHeight: evnt.meta.blockNumber,
-        blockHash: evnt.meta.blockID,
-        accountId,
-        date: new Date(evnt.meta.blockTimestamp * 1000),
-        extra: {},
-      };
-    }),
-  );
-};

package/src/common-logic/transaction-utils.ts

@@ -1,190 +0,0 @@
-import BigNumber from "bignumber.js";
-import { DEFAULT_GAS_COEFFICIENT, HEX_PREFIX } from "../types";
-import crypto from "crypto";
-import { Transaction as ThorTransaction } from "thor-devkit";
-import params from "../contracts/abis/params";
-import { BASE_GAS_PRICE_KEY, PARAMS_ADDRESS } from "../contracts/constants";
-import { query } from "../network";
-import { Account, TokenAccount } from "@ledgerhq/types-live";
-import { Transaction, TransactionInfo, Query } from "../types";
-import { isValid } from "./address-utils";
-import { calculateClausesVet, calculateClausesVtho } from "./logic";
-import { ImpossibleToCalculateAmountAndFees } from "../errors";
-
-const GAS_COEFFICIENT = 15000;
-
-/**
- * Generate a Unique ID to be used as a nonce
- * @returns a unique string
- */
-export const generateNonce = (): string => {
-  const randBuffer = crypto.randomBytes(Math.ceil(4));
-  if (!randBuffer) throw Error("Failed to generate random hex");
-  return `${HEX_PREFIX}${randBuffer.toString("hex").substring(0, 8)}`;
-};
-
-/**
- * Estimate the gas that will be used by the transaction.
- * @param transaction - The transaction to estimate the gas for
- * @returns an estimate of the gas usage
- */
-export const estimateGas = async (t: Transaction): Promise<number> => {
-  const intrinsicGas = ThorTransaction.intrinsicGas(t.body.clauses);
-
-  const queryData: Query[] = [];
-
-  t.body.clauses.forEach(c => {
-    if (c.to) {
-      queryData.push({
-        to: c.to,
-        data: c.data,
-      });
-    }
-  });
-
-  const response = await query(queryData);
-
-  const execGas = response.reduce((sum, out) => sum + out.gasUsed, 0);
-
-  return intrinsicGas + (execGas ? execGas + GAS_COEFFICIENT : 0);
-};
-
-const getBaseGasPrice = async (): Promise<string> => {
-  const queryData: Query = {
-    to: PARAMS_ADDRESS,
-    data: params.get.encode(BASE_GAS_PRICE_KEY),
-  };
-
-  const response = await query([queryData]);
-
-  // Expect 1 value
-  if (response && response.length !== 1) throw Error("Unexpected response received for query");
-
-  return response[0].data;
-};
-
-/**
- * Calculate the fee in VTHO
- * @param gas - the gas used
- * @param gasPriceCoef - the gas price coefficient
- * @returns the fee in VTHO
- */
-export const calculateFee = async (gas: BigNumber, gasPriceCoef: number): Promise<BigNumber> => {
-  const baseGasPrice = await getBaseGasPrice();
-  return new BigNumber(baseGasPrice).times(gasPriceCoef).idiv(255).plus(baseGasPrice).times(gas);
-};
-
-// Here there is a circular dependency between values, that is why we need the do-while loop
-// dependencies are:
-// useAllAmount: USER
-// amount: useAllAmount & spendableBalance
-// fees: amount
-// spendableBalance: fees & balance
-// balance: USER
-// circular dependency is:
-// amount -> spendableBalance -> fees -> amount
-
-export const calculateTransactionInfo = async (
-  account: Account,
-  transaction: Transaction,
-  fixedMaxTokenFees?: {
-    estimatedGas: number;
-    estimatedGasFees: BigNumber;
-  },
-): Promise<TransactionInfo> => {
-  const { subAccounts } = account;
-  const { amount: oldAmount, subAccountId, useAllAmount } = transaction;
-
-  const tokenAccount =
-    subAccountId && subAccounts
-      ? (subAccounts.find(subAccount => {
-          return subAccount.id === subAccountId;
-        }) as TokenAccount)
-      : undefined;
-  const isTokenAccount = !!tokenAccount;
-
-  let amount = oldAmount;
-  let amountBackup;
-  let tempTransaction = { ...transaction, amount };
-  let balance = account.balance;
-  let spendableBalance = account.balance;
-  let maxEstimatedGasFees = new BigNumber(0);
-  let maxEstimatedGas = 0;
-
-  if (!amount.isNaN()) {
-    const MAX_ITERATIONS = 5; // it should never reach more than 2 iterations, but just in case
-    let iterations = 0;
-    do {
-      amountBackup = amount;
-
-      const estimatedGasAndFees =
-        fixedMaxTokenFees || (await calculateGasFees(tempTransaction, isTokenAccount));
-
-      maxEstimatedGasFees = estimatedGasAndFees.estimatedGasFees;
-      maxEstimatedGas = estimatedGasAndFees.estimatedGas;
-
-      if (isTokenAccount && tokenAccount) {
-        balance = tokenAccount.balance;
-        spendableBalance = tokenAccount.balance.minus(maxEstimatedGasFees).gt(0)
-          ? tokenAccount.balance.minus(maxEstimatedGasFees)
-          : new BigNumber(0);
-      } else {
-        balance = account.balance;
-        spendableBalance = account.balance;
-      }
-
-      amount = useAllAmount ? spendableBalance : oldAmount;
-
-      tempTransaction = {
-        ...tempTransaction,
-        amount,
-      };
-      iterations++;
-    } while (!amountBackup.isEqualTo(amount) && iterations < MAX_ITERATIONS);
-    if (iterations === MAX_ITERATIONS) {
-      throw new ImpossibleToCalculateAmountAndFees();
-    }
-  }
-
-  return {
-    isTokenAccount,
-    amount,
-    spendableBalance,
-    balance,
-    tokenAccount,
-    estimatedFees: maxEstimatedGasFees.toString(),
-    estimatedGas: maxEstimatedGas,
-  };
-};
-
-export const calculateGasFees = async (
-  transaction: Transaction,
-  isTokenAccount: boolean,
-): Promise<{
-  estimatedGas: number;
-  estimatedGasFees: BigNumber;
-}> => {
-  if (transaction.recipient && isValid(transaction.recipient)) {
-    let clauses;
-    if (isTokenAccount) {
-      clauses = await calculateClausesVtho(transaction.recipient, transaction.amount);
-    } else {
-      clauses = await calculateClausesVet(transaction.recipient, transaction.amount);
-    }
-    const gas = await estimateGas({
-      ...transaction,
-      body: { ...transaction.body, clauses: clauses },
-    });
-    return {
-      estimatedGas: gas,
-      estimatedGasFees: await calculateFee(
-        new BigNumber(gas),
-        transaction.body.gasPriceCoef || DEFAULT_GAS_COEFFICIENT,
-      ),
-    };
-  }
-  return {
-    estimatedGas: 0,
-    estimatedGasFees: new BigNumber(0),
-  };
-};

package/src/contracts/abis/VIP180.ts

@@ -1,265 +0,0 @@
-import { abi } from "thor-devkit";
-
-/**
- * EVENTS
- */
-const ApprovalEvent: abi.Event.Definition = {
-  anonymous: false,
-  inputs: [
-    {
-      indexed: true,
-      internalType: "address",
-      name: "owner",
-      type: "address",
-    },
-    {
-      indexed: true,
-      internalType: "address",
-      name: "spender",
-      type: "address",
-    },
-    {
-      indexed: false,
-      internalType: "uint256",
-      name: "value",
-      type: "uint256",
-    },
-  ],
-  name: "Approval",
-  type: "event",
-};
-const TransferEvent: abi.Event.Definition = {
-  anonymous: false,
-  inputs: [
-    {
-      indexed: true,
-      internalType: "address",
-      name: "from",
-      type: "address",
-    },
-    {
-      indexed: true,
-      internalType: "address",
-      name: "to",
-      type: "address",
-    },
-    {
-      indexed: false,
-      internalType: "uint256",
-      name: "value",
-      type: "uint256",
-    },
-  ],
-  name: "Transfer",
-  type: "event",
-};
-
-/**
- * FUNCTIONS
- */
-const allowance: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "address",
-      name: "owner",
-      type: "address",
-    },
-    {
-      internalType: "address",
-      name: "spender",
-      type: "address",
-    },
-  ],
-  name: "allowance",
-  outputs: [
-    {
-      internalType: "uint256",
-      name: "",
-      type: "uint256",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const approve: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "address",
-      name: "spender",
-      type: "address",
-    },
-    {
-      internalType: "uint256",
-      name: "amount",
-      type: "uint256",
-    },
-  ],
-  name: "approve",
-  outputs: [
-    {
-      internalType: "bool",
-      name: "",
-      type: "bool",
-    },
-  ],
-  stateMutability: "nonpayable",
-  type: "function",
-};
-const balanceOf: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "address",
-      name: "account",
-      type: "address",
-    },
-  ],
-  name: "balanceOf",
-  outputs: [
-    {
-      internalType: "uint256",
-      name: "",
-      type: "uint256",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const decimals: abi.Function.Definition = {
-  inputs: [],
-  name: "decimals",
-  outputs: [
-    {
-      internalType: "uint8",
-      name: "",
-      type: "uint8",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const name: abi.Function.Definition = {
-  inputs: [],
-  name: "name",
-  outputs: [
-    {
-      internalType: "string",
-      name: "",
-      type: "string",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const supportsInterface: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "bytes4",
-      name: "interfaceId",
-      type: "bytes4",
-    },
-  ],
-  name: "supportsInterface",
-  outputs: [
-    {
-      internalType: "bool",
-      name: "",
-      type: "bool",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const symbol: abi.Function.Definition = {
-  inputs: [],
-  name: "symbol",
-  outputs: [
-    {
-      internalType: "string",
-      name: "",
-      type: "string",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const totalSupply: abi.Function.Definition = {
-  inputs: [],
-  name: "totalSupply",
-  outputs: [
-    {
-      internalType: "uint256",
-      name: "",
-      type: "uint256",
-    },
-  ],
-  stateMutability: "view",
-  type: "function",
-};
-const transfer: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "address",
-      name: "to",
-      type: "address",
-    },
-    {
-      internalType: "uint256",
-      name: "amount",
-      type: "uint256",
-    },
-  ],
-  name: "transfer",
-  outputs: [
-    {
-      internalType: "bool",
-      name: "",
-      type: "bool",
-    },
-  ],
-  stateMutability: "nonpayable",
-  type: "function",
-};
-const transferFrom: abi.Function.Definition = {
-  inputs: [
-    {
-      internalType: "address",
-      name: "from",
-      type: "address",
-    },
-    {
-      internalType: "address",
-      name: "to",
-      type: "address",
-    },
-    {
-      internalType: "uint256",
-      name: "amount",
-      type: "uint256",
-    },
-  ],
-  name: "transferFrom",
-  outputs: [
-    {
-      internalType: "bool",
-      name: "",
-      type: "bool",
-    },
-  ],
-  stateMutability: "nonpayable",
-  type: "function",
-};
-
-export default {
-  ApprovalEvent: new abi.Event(ApprovalEvent),
-  TransferEvent: new abi.Event(TransferEvent),
-  allowance: new abi.Function(allowance),
-  approve: new abi.Function(approve),
-  balanceOf: new abi.Function(balanceOf),
-  decimals: new abi.Function(decimals),
-  name: new abi.Function(name),
-  supportsInterface: new abi.Function(supportsInterface),
-  symbol: new abi.Function(symbol),
-  totalSupply: new abi.Function(totalSupply),
-  transfer: new abi.Function(transfer),
-  transferFrom: new abi.Function(transferFrom),
-};

package/src/contracts/abis/params.ts

@@ -1,70 +0,0 @@
-import { abi } from "thor-devkit";
-
-/**
- * FUNCTIONS
- */
-const set: abi.Function.Definition = {
-  constant: false,
-  inputs: [
-    {
-      name: "_key",
-      type: "bytes32",
-    },
-    {
-      name: "_value",
-      type: "uint256",
-    },
-  ],
-  name: "set",
-  outputs: [],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function",
-};
-
-const get: abi.Function.Definition = {
-  constant: true,
-  inputs: [
-    {
-      name: "_key",
-      type: "bytes32",
-    },
-  ],
-  name: "get",
-  outputs: [
-    {
-      name: "",
-      type: "uint256",
-    },
-  ],
-  payable: false,
-  stateMutability: "view",
-  type: "function",
-};
-
-/**
- * EVENTS
- */
-const Set: abi.Event.Definition = {
-  anonymous: false,
-  inputs: [
-    {
-      indexed: true,
-      name: "key",
-      type: "bytes32",
-    },
-    {
-      indexed: false,
-      name: "value",
-      type: "uint256",
-    },
-  ],
-  name: "Set",
-  type: "event",
-};
-
-export default {
-  set: new abi.Function(set),
-  get: new abi.Function(get),
-  Set: new abi.Event(Set),
-};

package/src/contracts/constants.ts

@@ -1,11 +0,0 @@
-export const TransferEventSignature =
-  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-
-export const VTHO_ADDRESS = "0x0000000000000000000000000000456e65726779";
-
-// params.sol - builtin contract (https://www.vechain.org/whitepaper/#bit_v48i3)
-export const PARAMS_ADDRESS = "0x0000000000000000000000000000506172616d73";
-export const REWARD_RATIO_KEY =
-  "0x00000000000000000000000000000000000000007265776172642d726174696f";
-export const BASE_GAS_PRICE_KEY =
-  "0x000000000000000000000000000000000000626173652d6761732d7072696365";