@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/families/internet_computer/__snapshots__/bridge.integration.test.ts.snap

@@ -0,0 +1,143 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`internet_computer currency bridge scanAccounts internet_computer seed 1 1`] = `
+Array [
+  Object {
+    "balance": "1000000",
+    "currencyId": "internet_computer",
+    "derivationMode": "internet_computer",
+    "freshAddress": "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+    "freshAddressPath": "44'/223'/0'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+        "derivationPath": "44'/223'/0'/0/0",
+      },
+    ],
+    "id": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:internet_computer",
+    "index": 0,
+    "name": "Internet Computer 1",
+    "nfts": undefined,
+    "operationsCount": 1,
+    "pendingOperations": Array [],
+    "seedIdentifier": "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+    "spendableBalance": "1000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 8,
+    "used": true,
+    "xpub": "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+  },
+  Object {
+    "balance": "1000000",
+    "currencyId": "internet_computer",
+    "derivationMode": "",
+    "freshAddress": "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+    "freshAddressPath": "44'/223'/0'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+        "derivationPath": "44'/223'/0'/0/0",
+      },
+    ],
+    "id": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:",
+    "index": 0,
+    "name": "Internet Computer 1",
+    "nfts": undefined,
+    "operationsCount": 1,
+    "pendingOperations": Array [],
+    "seedIdentifier": "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+    "spendableBalance": "1000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 8,
+    "used": true,
+    "xpub": "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+  },
+  Object {
+    "balance": "0",
+    "currencyId": "internet_computer",
+    "derivationMode": "",
+    "freshAddress": "02c1bf9b7b539ad8e39cf4df4881742be4fa2c4a6b1b97c1b735972665556742",
+    "freshAddressPath": "44'/223'/1'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "02c1bf9b7b539ad8e39cf4df4881742be4fa2c4a6b1b97c1b735972665556742",
+        "derivationPath": "44'/223'/1'/0/0",
+      },
+    ],
+    "id": "js:2:internet_computer:04fc89df2bb2677347117b550c9a66b9a54c384dfee78a83a1e3010fd2f5ce7418f6706102bc5611094702f64773fd5569ca5e24c44b77383e58e034f521f96baf:",
+    "index": 1,
+    "name": "Internet Computer 2",
+    "nfts": undefined,
+    "operationsCount": 0,
+    "pendingOperations": Array [],
+    "seedIdentifier": "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+    "spendableBalance": "0",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 8,
+    "used": false,
+    "xpub": "04fc89df2bb2677347117b550c9a66b9a54c384dfee78a83a1e3010fd2f5ce7418f6706102bc5611094702f64773fd5569ca5e24c44b77383e58e034f521f96baf",
+  },
+]
+`;
+
+exports[`internet_computer currency bridge scanAccounts internet_computer seed 1 2`] = `
+Array [
+  Array [
+    Object {
+      "accountId": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:internet_computer",
+      "blockHash": null,
+      "blockHeight": 5432782,
+      "contract": undefined,
+      "extra": Object {
+        "memo": "0",
+      },
+      "fee": "10000",
+      "hash": "c63c65091a4de0b9aec1b8bd242fa97b96dc8a7349577470f788c1f3df6fd7b8",
+      "id": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:internet_computer-c63c65091a4de0b9aec1b8bd242fa97b96dc8a7349577470f788c1f3df6fd7b8-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+      ],
+      "senders": Array [
+        "fdb7db0d3ae67368cb5010b7de7d98566c072f0a4eda871f45cd6582bf08aeb4",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "1000000",
+    },
+  ],
+  Array [
+    Object {
+      "accountId": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:",
+      "blockHash": null,
+      "blockHeight": 5432782,
+      "contract": undefined,
+      "extra": Object {
+        "memo": "0",
+      },
+      "fee": "10000",
+      "hash": "c63c65091a4de0b9aec1b8bd242fa97b96dc8a7349577470f788c1f3df6fd7b8",
+      "id": "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:-c63c65091a4de0b9aec1b8bd242fa97b96dc8a7349577470f788c1f3df6fd7b8-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+      ],
+      "senders": Array [
+        "fdb7db0d3ae67368cb5010b7de7d98566c072f0a4eda871f45cd6582bf08aeb4",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "1000000",
+    },
+  ],
+  Array [],
+]
+`;

package/src/families/internet_computer/account.ts

@@ -0,0 +1,38 @@
+import BigNumber from "bignumber.js";
+
+export function fromOperationExtraRaw(
+  extra: Record<string, any> | null | undefined,
+): Record<string, any> | null | undefined {
+  if (!extra) return extra;
+
+  const { gasLimit, gasPremium, gasFeeCap } = extra;
+
+  if (gasLimit !== undefined) extra = { ...extra, gasLimit: new BigNumber(gasLimit) };
+
+  if (gasPremium !== undefined) extra = { ...extra, gasPremium: new BigNumber(gasPremium) };
+
+  if (gasFeeCap !== undefined) extra = { ...extra, gasFeeCap: new BigNumber(gasFeeCap) };
+
+  return extra;
+}
+
+export function toOperationExtraRaw(
+  extra: Record<string, any> | null | undefined,
+): Record<string, any> | null | undefined {
+  if (!extra) return extra;
+
+  const { gasLimit, gasPremium, gasFeeCap } = extra;
+
+  if (gasLimit !== undefined) extra = { ...extra, gasLimit: gasLimit.toNumber() };
+
+  if (gasPremium !== undefined) extra = { ...extra, gasPremium: gasPremium.toFixed() };
+
+  if (gasFeeCap !== undefined) extra = { ...extra, gasFeeCap: gasFeeCap.toFixed() };
+
+  return extra;
+}
+
+export default {
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+};

package/src/families/internet_computer/bridge/account.ts

@@ -0,0 +1,239 @@
+import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import {
+  Account,
+  AccountBridge,
+  AccountLike,
+  BroadcastFnSignature,
+  Operation,
+  SignOperationEvent,
+  SignOperationFnSignature,
+} from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../types";
+import { getAccountShape } from "./bridgeHelpers/account";
+import BigNumber from "bignumber.js";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { getAddress, validateAddress, validateMemo } from "./bridgeHelpers/addresses";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { Observable } from "rxjs";
+import { withDevice } from "../../../hw/deviceAccess";
+import { encodeOperationId } from "../../../operation";
+import {
+  broadcastTxn,
+  getTxnExpirationDate,
+  getTxnMetadata,
+  getUnsignedTransaction,
+  signICPTransaction,
+} from "./bridgeHelpers/icpRosetta";
+import { getPath } from "../utils";
+import { InvalidMemoICP } from "../errors";
+
+const sync = makeSync({ getAccountShape });
+
+const createTransaction = (): Transaction => {
+  // log("debug", "[createTransaction] creating base tx");
+  return {
+    family: "internet_computer",
+    amount: new BigNumber(0),
+    fees: getEstimatedFees(),
+    recipient: "",
+    useAllAmount: false,
+  };
+};
+
+const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
+  // log("debug", "[prepareTransaction] start fn");
+
+  const { address } = getAddress(a);
+  const { recipient } = t;
+
+  let amount: BigNumber = t.amount;
+  if (recipient && address) {
+    // log("debug", "[prepareTransaction] fetching estimated fees");
+
+    if ((await validateAddress(recipient)).isValid && (await validateAddress(address)).isValid) {
+      if (t.useAllAmount) {
+        amount = a.spendableBalance.minus(t.fees);
+        return { ...t, amount };
+      }
+    }
+  }
+
+  // log("debug", "[prepareTransaction] finish fn");
+  return t;
+};
+
+const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance } = a;
+  const { address } = getAddress(a);
+  const { recipient, useAllAmount } = t;
+  let { amount } = t;
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!(await validateAddress(recipient)).isValid) {
+    errors.recipient = new InvalidAddress();
+  } else if (recipient.toLowerCase() === address.toLowerCase()) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!(await validateAddress(address)).isValid) {
+    errors.sender = new InvalidAddress();
+  }
+
+  if (!validateMemo(t.memo).isValid) {
+    errors.transaction = new InvalidMemoICP();
+  }
+
+  // This is the worst case scenario (the tx won't cost more than this value)
+  const estimatedFees = t.fees;
+
+  let totalSpent: BigNumber;
+
+  if (useAllAmount) {
+    totalSpent = a.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    } else if (totalSpent.gt(a.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+const estimateMaxSpendable = async ({
+  account,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const balance = account.balance;
+
+  let maxSpendable = balance.minus(transaction?.fees ?? getEstimatedFees());
+
+  if (maxSpendable.isLessThan(0)) {
+    maxSpendable = new BigNumber(0);
+  }
+
+  return maxSpendable;
+};
+
+const signOperation: SignOperationFnSignature<Transaction> = ({
+  account,
+  deviceId,
+  transaction,
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          // log("debug", "[signOperation] start fn");
+
+          const { recipient, amount } = transaction;
+          const { id: accountId, xpub } = account;
+          const { address, derivationPath } = getAddress(account);
+          const fee = transaction.fees;
+
+          const { unsignedTxn, payloads } = await getUnsignedTransaction(transaction, account);
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const { signedTxn } = await signICPTransaction({
+            unsignedTxn,
+            transport,
+            path: getPath(derivationPath),
+            payloads,
+            pubkey: xpub ?? "",
+          });
+
+          const { hash } = await getTxnMetadata(signedTxn);
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          const operation: Operation = {
+            id: encodeOperationId(accountId, hash, "OUT"),
+            hash,
+            type: "OUT",
+            senders: [address],
+            recipients: [recipient],
+            accountId,
+            value: amount.plus(fee),
+            fee,
+            blockHash: null,
+            blockHeight: null,
+            date: new Date(),
+            extra: {
+              memo: transaction.memo,
+            },
+          };
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: signedTxn,
+              expirationDate: getTxnExpirationDate(unsignedTxn),
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+const receive = makeAccountBridgeReceive();
+
+const broadcast: BroadcastFnSignature = async ({ signedOperation: { signature, operation } }) => {
+  // log("debug", "[broadcast] start fn");
+
+  await broadcastTxn(signature);
+
+  const result = { ...operation };
+
+  return result;
+};
+
+export const accountBridge: AccountBridge<Transaction> = {
+  sync,
+  updateTransaction: defaultUpdateTransaction,
+  createTransaction,
+  prepareTransaction,
+  getTransactionStatus,
+  estimateMaxSpendable,
+  receive,
+  signOperation,
+  broadcast,
+};

package/src/families/internet_computer/bridge/bridgeHelpers/account.ts

@@ -0,0 +1,125 @@
+import { GetAccountShape } from "../../../../bridge/jsHelpers";
+import { decodeAccountId, encodeAccountId } from "../../../../account";
+import { log } from "@ledgerhq/logs";
+import { fetchBalances, fetchBlockHeight, fetchTxns } from "./api";
+import { flatMap } from "lodash";
+import { Account, Operation } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { ICPRosettaGetTxnsHistoryResponse } from "./icpRosetta/types";
+import { ICP_FEES } from "../../consts";
+import { encodeOperationId } from "../../../../operation";
+import { normalizeEpochTimestamp } from "../../utils";
+
+const mapTxToOps = (accountId: string, address: string, fee = ICP_FEES) => {
+  return (txInfo: ICPRosettaGetTxnsHistoryResponse["transactions"][0]): Operation[] => {
+    const ops: Operation[] = [];
+    const ownerOperation = txInfo.transaction.operations.find(
+      cur => cur.account.address === address,
+    );
+    const counterOperation = txInfo.transaction.operations.find(
+      cur => cur.account.address !== address,
+    );
+
+    if (!ownerOperation || !counterOperation) return ops;
+
+    const timeStamp = txInfo.transaction.metadata.timestamp;
+    const amount = BigNumber(ownerOperation.amount.value);
+    const hash = txInfo.transaction.transaction_identifier.hash;
+    const fromAccount = amount.isPositive()
+      ? counterOperation.account.address
+      : ownerOperation.account.address;
+    const toAccount = amount.isNegative()
+      ? counterOperation.account.address
+      : ownerOperation.account.address;
+    const memo = txInfo.transaction.metadata.memo.toString();
+    const blockHeight = txInfo.transaction.metadata.block_height;
+
+    const date = new Date(normalizeEpochTimestamp(timeStamp.toString()));
+    const value = amount.abs();
+    const feeToUse = BigNumber(fee);
+
+    const isSending = amount.isNegative();
+    const isReceiving = amount.isPositive();
+
+    if (isSending) {
+      ops.push({
+        id: encodeOperationId(accountId, hash, "OUT"),
+        hash,
+        type: "OUT",
+        value: value.plus(feeToUse),
+        fee: feeToUse,
+        blockHeight,
+        blockHash: null,
+        accountId,
+        senders: [fromAccount],
+        recipients: [toAccount],
+        date,
+        extra: {
+          memo,
+        },
+      });
+    }
+
+    if (isReceiving) {
+      ops.push({
+        id: encodeOperationId(accountId, hash, "IN"),
+        hash,
+        type: "IN",
+        value,
+        fee: feeToUse,
+        blockHeight,
+        blockHash: null,
+        accountId,
+        senders: [fromAccount],
+        recipients: [toAccount],
+        date,
+        extra: {
+          memo,
+        },
+      });
+    }
+
+    return ops;
+  };
+};
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, currency, derivationMode, rest = {}, initialAccount } = info;
+  const publicKey = reconciliatePublicKey(rest.publicKey, initialAccount);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  log("debug", `Generation account shape for ${address}`);
+
+  const blockHeight = await fetchBlockHeight();
+  const balanceResp = await fetchBalances(address);
+  const balance = balanceResp.balances[0];
+
+  const txns = await fetchTxns(address);
+  const result: Partial<Account> = {
+    id: accountId,
+    balance: BigNumber(balance.value),
+    spendableBalance: BigNumber(balance.value),
+    operations: flatMap(txns.transactions.reverse(), mapTxToOps(accountId, address)),
+    blockHeight: blockHeight.current_block_identifier.index,
+    operationsCount: txns.transactions.length,
+    xpub: publicKey,
+  };
+
+  return result;
+};
+
+function reconciliatePublicKey(publicKey?: string, initialAccount?: Account): string {
+  if (publicKey) return publicKey;
+  if (initialAccount) {
+    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
+    return xpubOrAddress;
+  }
+  throw new Error("publicKey wasn't properly restored");
+}

package/src/families/internet_computer/bridge/bridgeHelpers/addresses.ts

@@ -0,0 +1,31 @@
+import { log } from "@ledgerhq/logs";
+import { Account, Address } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { MAX_MEMO_VALUE } from "../../consts";
+import { fetchBalances } from "./api";
+
+export const getAddress = (a: Account): Address =>
+  a.freshAddresses.length > 0
+    ? a.freshAddresses[0]
+    : { address: a.freshAddress, derivationPath: a.freshAddressPath };
+
+export async function validateAddress(address: string): Promise<{ isValid: boolean }> {
+  try {
+    const res = await fetchBalances(address);
+    if (!res.balances) throw Error(res.details?.error_message);
+    return { isValid: true };
+  } catch (e: any) {
+    log("error", e.message ?? "Failed to validate address");
+    return { isValid: false };
+  }
+}
+
+export function validateMemo(memo?: string): { isValid: boolean } {
+  const res = BigNumber(memo ?? 0);
+
+  if (res.isNaN() || res.lt(0) || res.gt(BigNumber(MAX_MEMO_VALUE))) {
+    return { isValid: false };
+  }
+
+  return { isValid: true };
+}

package/src/families/internet_computer/bridge/bridgeHelpers/api.ts

@@ -0,0 +1,92 @@
+import { log } from "@ledgerhq/logs";
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { getEnv } from "../../../../env";
+import network from "@ledgerhq/live-network/network";
+import { ICP_BLK_NAME_ROSETTA, ICP_NET_ID_ROSETTA } from "../../consts";
+import {
+  ICPRosettaBlockHeightResponse,
+  ICPRosettaGetBalancesResponse,
+  ICPRosettaGetTxnsHistoryResponse,
+} from "./icpRosetta/types";
+
+const getICPURL = (path?: string): string => {
+  const baseUrl = getEnv("API_ICP_ENDPOINT");
+  if (!baseUrl) throw new Error("API base URL not available");
+
+  return `${baseUrl}${path ? path : ""}`;
+};
+
+const ICPFetchWrapper = async <T>(path: string, body: any) => {
+  const url = getICPURL(path);
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const opts: AxiosRequestConfig = {
+    method: "POST",
+    data: body,
+    url,
+  };
+  const rawResponse = await network(opts);
+  if (rawResponse && rawResponse.data && rawResponse.data.details?.error_message) {
+    log("error", rawResponse.data.details?.error_message);
+  }
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const { data } = rawResponse as AxiosResponse<T>;
+
+  log("http", url);
+  return data;
+};
+
+export const getICPRosettaNetworkIdentifier = () => {
+  return {
+    network_identifier: {
+      blockchain: ICP_BLK_NAME_ROSETTA,
+      network: ICP_NET_ID_ROSETTA,
+    },
+  };
+};
+
+export const fetchBlockHeight = async (): Promise<ICPRosettaBlockHeightResponse> => {
+  const data = await ICPFetchWrapper<ICPRosettaBlockHeightResponse>(
+    "network/status",
+    getICPRosettaNetworkIdentifier(),
+  );
+  return data;
+};
+
+export const fetchBalances = async (accountId: string): Promise<ICPRosettaGetBalancesResponse> => {
+  const body = {
+    ...getICPRosettaNetworkIdentifier(),
+    account_identifier: {
+      address: accountId,
+      metadata: {},
+    },
+  };
+  const data = await ICPFetchWrapper<ICPRosettaGetBalancesResponse>("account/balance", body);
+  return data;
+};
+
+export const fetchTxns = async (accountId: string): Promise<ICPRosettaGetTxnsHistoryResponse> => {
+  const body = {
+    ...getICPRosettaNetworkIdentifier(),
+    account_identifier: {
+      address: accountId,
+      metadata: {},
+    },
+  };
+  const data = await ICPFetchWrapper<ICPRosettaGetTxnsHistoryResponse>("search/transactions", body);
+  return data;
+};
+
+export const constructionInvoke = async <TRequest, TResponse>(
+  opts: TRequest,
+  method: string,
+): Promise<TResponse> => {
+  const body: TRequest = {
+    ...opts,
+  };
+
+  const data = await ICPFetchWrapper<TResponse>(`construction/${method}`, body);
+
+  return data;
+};

package/src/families/internet_computer/bridge/bridgeHelpers/fee.ts

@@ -0,0 +1,6 @@
+import BigNumber from "bignumber.js";
+import { ICP_FEES } from "../../consts";
+
+export function getEstimatedFees(): BigNumber {
+  return new BigNumber(ICP_FEES);
+}