@ledgerhq/coin-concordium 0.2.0-nightly.20251209140356

package/src/bridge/sync.ts

@@ -0,0 +1,106 @@
+import BigNumber from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getTransactions } from "../network/indexer";
+import { getAccountInfo, getBlockHeight } from "../network/node";
+
+import { ConcordiumOperation } from "../network/types";
+import coinConfig from "../config";
+
+const operationAdapter =
+  (accountId: string, address: string) =>
+  ({
+    meta: { delivered_amount },
+    tx: { Fee, hash, inLedger, date, Account, Destination, Sequence },
+  }: ConcordiumOperation) => {
+    const type = Account === address ? "OUT" : "IN";
+    let value =
+      delivered_amount && typeof delivered_amount === "string"
+        ? new BigNumber(delivered_amount)
+        : new BigNumber(0);
+    const feeValue = new BigNumber(Fee);
+
+    if (type === "OUT") {
+      if (!Number.isNaN(feeValue)) {
+        value = value.plus(feeValue);
+      }
+    }
+
+    const op: Operation = {
+      id: encodeOperationId(accountId, hash, type),
+      hash: hash,
+      accountId,
+      type,
+      value,
+      fee: feeValue,
+      blockHash: null,
+      blockHeight: inLedger,
+      senders: [Account],
+      recipients: [Destination],
+      date: new Date(),
+      transactionSequenceNumber: new BigNumber(Sequence),
+      extra: {},
+    };
+
+    return op;
+  };
+
+const filterOperations = (
+  transactions: ConcordiumOperation[],
+  accountId: string,
+  address: string,
+) => {
+  return transactions
+    .filter(
+      ({ tx, meta }: ConcordiumOperation) =>
+        tx.TransactionType === "Payment" && typeof meta.delivered_amount === "string",
+    )
+    .map(operationAdapter(accountId, address))
+    .filter((op): op is Operation => Boolean(op));
+};
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  // blockheight retrieval
+  const blockHeight = await getBlockHeight();
+
+  // Account info retrieval + spendable balance calculation
+  const accountInfo = await getAccountInfo(address);
+  const balance = new BigNumber(accountInfo.account_data.Balance);
+  const reserveMin = coinConfig.getCoinConfig().minReserve;
+  const spendableBalance = new BigNumber(accountInfo.account_data.Balance).minus(reserveMin);
+
+  // Tx history fetching
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+  const newTransactions = await getTransactions(address, {
+    from: startAt,
+    size: 100,
+  });
+  const newOperations = filterOperations(newTransactions, accountId, address);
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  // We return the new account shape
+  const shape = {
+    id: accountId,
+    xpub: address,
+    blockHeight,
+    balance,
+    spendableBalance,
+    operations,
+    operationsCount: operations.length,
+  };
+
+  return shape;
+};

package/src/bridge/transaction.ts

@@ -0,0 +1,61 @@
+import { BigNumber } from "bignumber.js";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization/transaction";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { Transaction, TransactionRaw } from "../types";
+
+export const formatTransaction = (
+  { amount, recipient, fee, useAllAmount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}
+TO ${recipient}
+with fee=${
+  !fee
+    ? "?"
+    : formatCurrencyUnit(getAccountCurrency(account).units[0], fee, {
+        showCode: true,
+        disableRounding: true,
+      })
+}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    fee: tr.fee ? new BigNumber(tr.fee) : null,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    fee: t.fee ? t.fee.toString() : null,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/bridge/updateTransaction.ts

@@ -0,0 +1,17 @@
+import { updateTransaction as defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { AccountBridge } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+
+// NOTE: this method is optional, use defaultUpdateTransaction
+// acts as a middleware to update the transaction patch object
+
+// NOTE: here is an example transaction updater function
+// in this case, it resets fee to null depending on the patch content
+export const updateTransaction: AccountBridge<Transaction>["updateTransaction"] = (tx, patch) => {
+  // eslint-disable-next-line no-constant-condition
+  if (patch.recipient === "concordium1" || true) {
+    patch = { ...patch, fee: null };
+  }
+
+  return defaultUpdateTransaction(tx, patch);
+};

package/src/common-logic/account/getBalance.ts

@@ -0,0 +1,8 @@
+import { Balance } from "@ledgerhq/coin-framework/api/types";
+import { getAccountInfo } from "../../network/node";
+
+// Could be getAccountInfo so it is used in both bridge and api
+export async function getBalance(address: string): Promise<Balance[]> {
+  const accountInfo = await getAccountInfo(address);
+  return [{ asset: { type: "native" }, value: BigInt(accountInfo.account_data.Balance) }];
+}

package/src/common-logic/account/getNextSequence.ts

@@ -0,0 +1,6 @@
+import { getNextSequence } from "../../network/node";
+
+// Could be getAccountInfo so it is used in both bridge and api
+export async function getNextValidSequence(address: string): Promise<number> {
+  return await getNextSequence(address);
+}

package/src/common-logic/common.ts

@@ -0,0 +1,8 @@
+import { BigNumber } from "bignumber.js";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+// NOTE: replace ripple by your currency id, it should be found in
+// libs/ledgerjs/packages/cryptoassets/src/currencies.ts
+const concordiumUnit = getCryptoCurrencyById("ripple").units[0];
+export const parseAPIValue = (value: string): BigNumber => parseCurrencyUnit(concordiumUnit, value);

package/src/common-logic/history/lastBlock.ts

@@ -0,0 +1,11 @@
+import type { BlockInfo } from "@ledgerhq/coin-framework/api/index";
+import { getLastBlock } from "../../network/node";
+
+export async function lastBlock(): Promise<BlockInfo> {
+  const result = await getLastBlock();
+  return {
+    height: result.blockHeight,
+    hash: result.blockHash,
+    time: new Date(result.timestamp),
+  };
+}

package/src/common-logic/history/listOperations.ts

@@ -0,0 +1,65 @@
+import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
+import { getTransactions } from "../../network/indexer";
+import { ConcordiumOperation } from "../../network/types";
+
+/**
+ * Returns list of operations associated to an account.
+ * @param address Account address
+ * @param pagination Pagination options
+ * @returns Operations found and the next "id" or "index" to use for pagination (i.e. `start` property).\
+ * If `0` is returns, no pagination needed.
+ * This "id" or "index" value, thus it has functional meaning, is different for each blockchain.
+ */
+export async function listOperations(
+  address: string,
+  page: Pagination,
+): Promise<[Operation[], string]> {
+  const transactions = await getTransactions(address, { from: page.minHeight });
+  return [transactions.map(convertToCoreOperation(address)), ""];
+}
+
+const convertToCoreOperation =
+  (address: string) =>
+  (operation: ConcordiumOperation): Operation => {
+    const {
+      meta: { delivered_amount },
+      tx: { Fee, hash, inLedger, date, Account, Destination },
+    } = operation;
+
+    const type = Account === address ? "OUT" : "IN";
+    let value =
+      delivered_amount && typeof delivered_amount === "string"
+        ? BigInt(delivered_amount)
+        : BigInt(0);
+
+    const feeValue = BigInt(Fee);
+    if (type === "OUT") {
+      if (!Number.isNaN(feeValue)) {
+        value = value + feeValue;
+      }
+    }
+
+    return {
+      /**
+       * Note: The operation ID must be concatenated with another
+       * value if the transaction hash is not enough to identify it
+       */
+      id: hash,
+      asset: { type: "native" },
+      tx: {
+        hash,
+        fees: feeValue,
+        date: new Date(date),
+        failed: false,
+        block: {
+          height: inLedger,
+          hash,
+          time: new Date(date),
+        },
+      },
+      type,
+      value,
+      senders: [Account],
+      recipients: [Destination],
+    };
+  };

package/src/common-logic/index.ts

@@ -0,0 +1,11 @@
+export { broadcast } from "./transaction/broadcast";
+export { combine } from "./transaction/combine";
+export { craftTransaction } from "./transaction/craftTransaction";
+export { estimateFees } from "./transaction/estimateFees";
+export { getBalance } from "./account/getBalance";
+export { lastBlock } from "./history/lastBlock";
+export { listOperations } from "./history/listOperations";
+export { isRecipientValid } from "./utils";
+export { getNextValidSequence } from "./account/getNextSequence";
+
+export { parseAPIValue } from "./common";

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

@@ -0,0 +1,6 @@
+import { submit } from "../../network/node";
+
+export async function broadcast(signedTx: string): Promise<string> {
+  const submittedPayment = await submit(signedTx);
+  return submittedPayment.tx_hash;
+}

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

@@ -0,0 +1,6 @@
+import { encode } from "../utils";
+
+// Combines signature with raw transaction
+export function combine(transaction: string, signature: string, publicKey?: string): string {
+  return encode(transaction, signature, publicKey || "");
+}

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

@@ -0,0 +1,36 @@
+import BigNumber from "bignumber.js";
+import { ConcordiumNativeTransaction } from "../../types";
+
+const encodeNativeTx = (nativeTx: ConcordiumNativeTransaction) => JSON.stringify(nativeTx);
+
+export async function craftTransaction(
+  account: {
+    address: string;
+    nextSequenceNumber?: number;
+    publicKey?: string;
+  },
+  transaction: {
+    recipient?: string;
+    amount: BigNumber;
+    fee?: BigNumber;
+  },
+): Promise<{
+  nativeTransaction: ConcordiumNativeTransaction;
+  serializedTransaction: string;
+}> {
+  const nativeTransaction: ConcordiumNativeTransaction = {
+    TransactionType: "Payment",
+    Account: account.address,
+    Amount: transaction.amount.toString(),
+    Destination: transaction.recipient || "",
+    Fee: transaction.fee?.toString() || "0",
+    Sequence: account.nextSequenceNumber || 0,
+  };
+
+  const serializedTransaction = encodeNativeTx(nativeTransaction);
+
+  return {
+    nativeTransaction,
+    serializedTransaction,
+  };
+}

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

@@ -0,0 +1,16 @@
+import { simulate } from "../../network/node";
+import { SimulationError } from "../../types/errors";
+
+export async function estimateFees(serializedTransaction: string): Promise<bigint> {
+  try {
+    // We call the node to do a dry run and estimate fees
+    return BigInt(await simulate(serializedTransaction));
+  } catch (e) {
+    // default value is required in case of simulation error, else user will encounter an error in the flow
+    if (e instanceof SimulationError) {
+      return BigInt(1000);
+    } else {
+      throw new Error("Unexpected error while estimating fees.");
+    }
+  }
+}

package/src/common-logic/utils.ts

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+
+export const UINT32_MAX = new BigNumber(2).pow(32).minus(1);
+
+export const validateTag = (tag: BigNumber) => {
+  return (
+    !tag.isNaN() && tag.isFinite() && tag.isInteger() && tag.isPositive() && tag.lte(UINT32_MAX)
+  );
+};
+
+export function isRecipientValid(recipient: string): boolean {
+  return recipient.length > 0;
+}
+
+export const encode = (transaction: string, signature: string, publicKey?: string) => {
+  // sample encoding
+  return `${transaction}${publicKey}${signature}encodedTx`;
+};

package/src/config.ts

@@ -0,0 +1,12 @@
+import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type ConcordiumConfig = {
+  nodeUrl: string;
+  minReserve: number;
+};
+
+export type ConcordiumCoinConfig = CurrencyConfig & ConcordiumConfig;
+
+const coinConfig = buildCoinConfig<ConcordiumCoinConfig>();
+
+export default coinConfig;

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";
+export type { ConcordiumCoinConfig } from "./config";

package/src/network/indexer.ts

@@ -0,0 +1,17 @@
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+import { AccountTxResponse } from "./types";
+
+export const getTransactions = async (
+  address: string,
+  params: { from: number; size?: number },
+): Promise<AccountTxResponse["transactions"]> => {
+  const { data } = await network<AccountTxResponse>({
+    // NOTE: add INDEXER_BOILERPLATE to libs/env/src/env.ts
+    // @ts-expect-error: add INDEXER_BOILERPLATE to libs/env/src/env.ts
+    url: `${getEnv("INDEXER_BOILERPLATE")}/account/${address}/transactions`,
+    method: "GET",
+  });
+
+  return data.transactions;
+};

package/src/network/mock-network.ts

@@ -0,0 +1,25 @@
+/*
+
+In a real use case you should use live-network library like this :
+
+import network from "@ledgerhq/live-network/network";
+
+
+instead of this mocked method
+
+*/
+
+export const network = (params: { url: string; method: "GET" | "POST" }) => {
+  switch (true) {
+    case params.url.includes("simulate"):
+      break;
+    case params.url.includes("submit"):
+      break;
+    case params.url.includes("account_info"):
+      break;
+    case params.url.includes("transactions"):
+      break;
+    default:
+      throw new Error("Mock network 404");
+  }
+};

package/src/network/node.ts

@@ -0,0 +1,94 @@
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+import { SimulationError } from "../types/errors";
+import coinConfig from "../config";
+import { AccountInfoResponse, SubmitReponse } from "./types";
+
+const getNodeUrl = () => coinConfig.getCoinConfig().nodeUrl;
+
+// NOTE: add NODE_BOILERPLATE to libs/env/src/env.ts
+
+// txPayload needs to be unsigned
+export const simulate = async (serializedTx: string): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/simulate`;
+  const { data } = await network({
+    url,
+    method: "POST",
+    data: {
+      txPayload: serializedTx,
+    },
+  });
+  if (data.error) {
+    throw new SimulationError();
+  }
+  return data.fees;
+};
+
+// can be called nonce or sequence
+export const getNextSequence = async (address: string): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/${address}/sequence`;
+  try {
+    const { data } = await network({
+      url,
+      method: "GET",
+    });
+    return data.sequence;
+  } catch (e) {
+    return 0;
+  }
+};
+
+export const getBlockHeight = async (): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/blockheight`;
+  const { data } = await network({
+    url,
+    method: "GET",
+  });
+  return data.blockHeight;
+};
+
+export const getLastBlock = async (): Promise<{
+  blockHeight: number;
+  blockHash: string;
+  timestamp: number;
+}> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/block/current`;
+  const { data } = await network({
+    url,
+    method: "GET",
+  });
+  return data;
+};
+
+export const submit = async (signedTx: string): Promise<SubmitReponse> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/submit`;
+  const { data } = await network<SubmitReponse>({
+    url,
+    method: "GET",
+  });
+  return data;
+};
+
+export const getAccountInfo = async (address: string): Promise<AccountInfoResponse> => {
+  const {
+    data: { result },
+  } = await network<{ result: AccountInfoResponse }>({
+    method: "POST",
+    url: getNodeUrl(),
+    data: {
+      method: "account_info",
+      params: [
+        {
+          account: address,
+        },
+      ],
+    },
+  });
+
+  return result;
+};

package/src/network/types.ts

@@ -0,0 +1,51 @@
+export type ConcordiumOperation = {
+  meta: {
+    delivered_amount: string;
+  };
+  tx: {
+    Account: string;
+    Amount: string;
+    Destination: string;
+    Fee: string;
+    Memo: string;
+    Sequence: number;
+    SigningPubKey: string;
+    TransactionType: string;
+    TxnSignature: string;
+    date: number;
+    hash: string;
+    inLedger: number;
+  };
+  validated: boolean;
+};
+
+export type ResponseStatus =
+  | { status: string; error?: never }
+  | {
+      status?: never;
+      error: string;
+    };
+export function isResponseStatus(obj: object): obj is ResponseStatus {
+  return "status" in obj || "error" in obj;
+}
+
+export type NewAccount = "NewAccount";
+export type AccountInfoResponse = {
+  account_data: {
+    Account: string;
+    Balance: string;
+  };
+  ledger_hash: string;
+  ledger_index: number;
+  validated: boolean;
+} & ResponseStatus;
+
+export type SubmitReponse = {
+  accepted: boolean;
+  tx_hash: string;
+};
+
+export type AccountTxResponse = {
+  account: string;
+  transactions: ConcordiumOperation[];
+} & ResponseStatus;

package/src/signer/getAddress.ts

@@ -0,0 +1,20 @@
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { ConcordiumAddress, ConcordiumSigner } from "../types";
+
+const getAddress = (signerContext: SignerContext<ConcordiumSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const { address, publicKey } = (await signerContext(deviceId, signer =>
+      signer.getAddress(path),
+    )) as ConcordiumAddress;
+
+    return {
+      path,
+      address,
+      publicKey,
+    };
+  };
+};
+
+export default getAddress;

package/src/signer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * This directory is the home for all types and logic based on Ledgers signer.
+ */
+
+import getAddress from "./getAddress";
+
+export default getAddress;

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,48 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+import type { Transaction } from "../types";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Transaction Type",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "Payment",
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) => formatDeviceAmount(account.currency, status.amount),
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatDeviceAmount(account.currency, status.estimatedFees),
+    },
+    {
+      title: "Destination",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Account",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Sign transaction",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});