@ledgerhq/coin-concordium 0.2.0-nightly.20251209140356

package/src/api/index.ts

@@ -0,0 +1,88 @@
+import {
+  AlpacaApi,
+  Block,
+  BlockInfo,
+  Cursor,
+  Page,
+  Validator,
+  FeeEstimation,
+  Reward,
+  Stake,
+  TransactionIntent,
+  CraftedTransaction,
+} from "@ledgerhq/coin-framework/api/index";
+import BigNumber from "bignumber.js";
+import coinConfig, { type ConcordiumConfig } from "../config";
+import {
+  broadcast,
+  combine,
+  craftTransaction,
+  estimateFees,
+  getBalance,
+  getNextValidSequence,
+  lastBlock,
+  listOperations,
+} from "../common-logic";
+
+export function createApi(config: ConcordiumConfig): AlpacaApi {
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
+
+  return {
+    broadcast,
+    combine,
+    craftTransaction: craft,
+    craftRawTransaction: (
+      _transaction: string,
+      _sender: string,
+      _publicKey: string,
+      _sequence: bigint,
+    ): Promise<CraftedTransaction> => {
+      throw new Error("craftRawTransaction is not supported");
+    },
+    estimateFees: estimate,
+    getBalance,
+    lastBlock,
+    listOperations,
+    getBlock(_height): Promise<Block> {
+      throw new Error("getBlock is not supported");
+    },
+    getBlockInfo(_height: number): Promise<BlockInfo> {
+      throw new Error("getBlockInfo is not supported");
+    },
+    getStakes(_address: string, _cursor?: Cursor): Promise<Page<Stake>> {
+      throw new Error("getStakes is not supported");
+    },
+    getRewards(_address: string, _cursor?: Cursor): Promise<Page<Reward>> {
+      throw new Error("getRewards is not supported");
+    },
+    getValidators(_cursor?: Cursor): Promise<Page<Validator>> {
+      throw new Error("getValidators is not supported");
+    },
+  };
+}
+
+async function craft(transactionIntent: TransactionIntent): Promise<CraftedTransaction> {
+  const nextSequenceNumber = await getNextValidSequence(transactionIntent.sender);
+  const tx = await craftTransaction(
+    { address: transactionIntent.sender, nextSequenceNumber },
+    {
+      recipient: transactionIntent.recipient,
+      amount: new BigNumber(transactionIntent.amount.toString()),
+    },
+  );
+  return { transaction: tx.serializedTransaction };
+}
+
+async function estimate(transactionIntent: TransactionIntent): Promise<FeeEstimation> {
+  const { serializedTransaction } = await craftTransaction(
+    { address: transactionIntent.sender },
+    {
+      recipient: transactionIntent.recipient,
+      amount: new BigNumber(transactionIntent.amount.toString()),
+    },
+  );
+
+  const value = await estimateFees(serializedTransaction);
+
+  return { value };
+}

package/src/bridge/broadcast.test.ts

@@ -0,0 +1,36 @@
+import { Account, BroadcastArg } from "@ledgerhq/types-live";
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("../common-logic");
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcast as broadcastLogic } from "../common-logic";
+import { broadcast } from "./broadcast";
+
+describe("broadcast", () => {
+  let patchOperationSpy: jest.SpyInstance;
+  let broadcastSpy: jest.SpyInstance;
+  beforeEach(() => {
+    patchOperationSpy = jest.spyOn({ patchOperationWithHash }, "patchOperationWithHash");
+    broadcastSpy = jest.spyOn({ broadcastLogic }, "broadcastLogic");
+    broadcastSpy.mockResolvedValue("hash");
+  });
+
+  it("should broadcast", () => {
+    broadcast({
+      signedOperation: {
+        signature: undefined,
+        operation: undefined,
+      },
+    } as unknown as BroadcastArg<Account>);
+    expect(broadcastLogic).toHaveBeenCalledTimes(1);
+  });
+
+  it("should patch operation with hash", () => {
+    broadcast({
+      signedOperation: {
+        signature: undefined,
+        operation: undefined,
+      },
+    } as unknown as BroadcastArg<Account>);
+    expect(patchOperationSpy).toHaveBeenCalledWith(undefined, "hash");
+  });
+});

package/src/bridge/broadcast.ts

@@ -0,0 +1,11 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcast as broadcastLogic } from "../common-logic";
+import { Transaction } from "../types";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  const hash = await broadcastLogic(signature);
+  return patchOperationWithHash(operation, hash);
+};

package/src/bridge/createTransaction.test.ts

@@ -0,0 +1,12 @@
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { createTransaction } from "./createTransaction";
+
+describe("createTransaction", () => {
+  it("should create a 0 amount transaction", () => {
+    expect(createTransaction({} as AccountLike<Account>).amount.toNumber()).toEqual(0);
+  });
+
+  it("should create a transaction with concordium family", () => {
+    expect(createTransaction({} as AccountLike<Account>).family).toEqual("concordium");
+  });
+});

package/src/bridge/createTransaction.ts

@@ -0,0 +1,14 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+// We create an empty transaction that will be filled later
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  family: "concordium",
+  amount: new BigNumber(0),
+  recipient: "",
+  fee: null,
+  memo: undefined,
+  networkInfo: null,
+  feeCustomUnit: null,
+});

package/src/bridge/deviceTransactionConfig.test.ts

@@ -0,0 +1,20 @@
+import BigNumber from "bignumber.js";
+import getDeviceTransactionConfig from "./deviceTransactionConfig";
+
+describe("getDeviceTransactionConfig", () => {
+  it("should return amount field when it's more than 0", async () => {
+    const result = await getDeviceTransactionConfig({
+      transaction: {},
+      status: { amount: new BigNumber(1), estimatedFees: new BigNumber(0) },
+    } as any);
+    expect(result[0]).toEqual({ type: "amount", label: "Amount" });
+  });
+
+  it("should return fee field when it's more than 0", async () => {
+    const result = await getDeviceTransactionConfig({
+      transaction: {},
+      status: { amount: new BigNumber(0), estimatedFees: new BigNumber(1) },
+    } as any);
+    expect(result[0]).toEqual({ type: "fees", label: "Fees" });
+  });
+});

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,34 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Transaction, TransactionStatus } from "../types";
+
+// This method adds additional fields that need to be reviewed when signing a transaction on the device.
+async function getDeviceTransactionConfig({
+  transaction: {},
+  status: { amount, estimatedFees },
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Promise<Array<CommonDeviceTransactionField>> {
+  const fields: Array<CommonDeviceTransactionField> = [];
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,25 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
+import { Transaction } from "../types";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const newTransaction = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    // fee estimation might require a recipient to work, in that case, we use a dummy one
+    recipient: transaction?.recipient || getAbandonSeedAddress("concordium"),
+    amount: new BigNumber(0),
+  });
+  const status = await getTransactionStatus(mainAccount, newTransaction);
+  return BigNumber.max(0, account.spendableBalance.minus(status.estimatedFees));
+};

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,88 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  FeeRequired,
+  FeeTooHigh,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughSpendableBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { Transaction, TransactionStatus } from "../types";
+import { isRecipientValid } from "../common-logic/utils";
+import coinConfig from "../config";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  Account,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  // reserveAmount is the minimum amount of currency that an account must hold in order to stay activated
+  const reserveAmount = new BigNumber(coinConfig.getCoinConfig().minReserve);
+  const estimatedFees = new BigNumber(transaction.fee || 0);
+  const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
+  const amount = new BigNumber(transaction.amount);
+
+  if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+    // if the fee is more than 10 times the amount, we warn the user that fee is high compared to what he is sending
+    warnings.feeTooHigh = new FeeTooHigh();
+  }
+
+  if (!transaction.fee) {
+    // if the fee is not loaded, we can't do much
+    errors.fee = new FeeNotLoaded();
+  } else if (transaction.fee.eq(0)) {
+    // On some chains, 0 fee could still work so this is optional
+    errors.fee = new FeeRequired();
+  } else if (totalSpent.gt(account.balance.minus(reserveAmount))) {
+    // if the total spent is greater than the balance minus the reserve amount, tx is invalid
+    errors.amount = new NotEnoughSpendableBalance("", {
+      minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  } else if (transaction.recipient && transaction.amount.lt(reserveAmount)) {
+    // if we send an amount lower than reserve amount AND target account is new, we need to warn the user that the target account will not be activated
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  }
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired("");
+  } else if (account.freshAddress === transaction.recipient) {
+    // we want to prevent user from sending to themselves (even if it's technically feasible)
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isRecipientValid(transaction.recipient)) {
+    // We want to prevent user from sending to an invalid address
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!errors.amount && amount.eq(0)) {
+    // if the amount is 0, we prevent the user from sending the tx (even if it's technically feasible)
+    errors.amount = new AmountRequired();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/bridge/index.test.ts

@@ -0,0 +1,26 @@
+import { createBridges } from ".";
+
+describe("createBridges", () => {
+  it("has a currency bridge and an account bridge with required methods", () => {
+    expect(createBridges(undefined as any, {} as any)).toEqual({
+      accountBridge: {
+        broadcast: expect.any(Function),
+        createTransaction: expect.any(Function),
+        estimateMaxSpendable: expect.any(Function),
+        getSerializedAddressParameters: expect.any(Function),
+        getTransactionStatus: expect.any(Function),
+        prepareTransaction: expect.any(Function),
+        receive: expect.any(Function),
+        signOperation: expect.any(Function),
+        signRawOperation: expect.any(Function),
+        sync: expect.any(Function),
+        updateTransaction: expect.any(Function),
+      },
+      currencyBridge: {
+        preload: expect.any(Function),
+        hydrate: expect.any(Function),
+        scanAccounts: expect.any(Function),
+      },
+    });
+  });
+});

package/src/bridge/index.ts

@@ -0,0 +1,65 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  getSerializedAddressParameters,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import concordiumCoinConfig, { type ConcordiumCoinConfig } from "../config";
+import resolver from "../signer";
+import { ConcordiumSigner } from "../types";
+import type { Transaction } from "../types";
+import { broadcast } from "./broadcast";
+import { createTransaction } from "./createTransaction";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape } from "./sync";
+import { updateTransaction } from "./updateTransaction";
+
+export function createBridges(
+  signerContext: SignerContext<ConcordiumSigner>,
+  coinConfig: CoinConfig<ConcordiumCoinConfig>,
+) {
+  concordiumCoinConfig.setCoinConfig(coinConfig);
+
+  const getAddress = resolver(signerContext);
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+
+  const scanAccounts = makeScanAccounts({ getAccountShape, getAddressFn: getAddress });
+  const currencyBridge: CurrencyBridge = {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+
+  const signOperation = buildSignOperation(signerContext);
+  const sync = makeSync({ getAccountShape });
+  // we want one method per file
+  const accountBridge: AccountBridge<Transaction> = {
+    broadcast,
+    createTransaction,
+    updateTransaction,
+    // NOTE: use updateTransaction: defaultUpdateTransaction<Transaction>,
+    // if you don't need to update the transaction patch object
+    prepareTransaction,
+    getTransactionStatus,
+    estimateMaxSpendable,
+    sync,
+    receive,
+    signOperation,
+    signRawOperation: () => {
+      throw new Error("signRawOperation is not supported");
+    },
+    getSerializedAddressParameters,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,29 @@
+import BigNumber from "bignumber.js";
+import { Account } from "@ledgerhq/types-live";
+import { craftTransaction, estimateFees } from "../common-logic";
+import { getNextSequence } from "../network/node";
+import { Transaction } from "../types";
+import { prepareTransaction } from "./prepareTransaction";
+
+jest.mock("../network/node");
+jest.mock("../common-logic");
+
+describe("prepareTransaction", () => {
+  let estimateFeesSpy: jest.SpyInstance;
+  let getNextSequenceSpy: jest.SpyInstance;
+  let craftTransactionSpy: jest.SpyInstance;
+  beforeEach(() => {
+    getNextSequenceSpy = jest.spyOn({ getNextSequence }, "getNextSequence");
+    estimateFeesSpy = jest.spyOn({ estimateFees }, "estimateFees");
+    craftTransactionSpy = jest.spyOn({ craftTransaction }, "craftTransaction");
+    craftTransactionSpy.mockReturnValue({ serializedTransaction: "serialized" });
+  });
+
+  it("should update fee field if it's different", async () => {
+    getNextSequenceSpy.mockResolvedValue(42);
+    const oldTx = { fee: new BigNumber(0) };
+    estimateFeesSpy.mockResolvedValue(BigInt(1));
+    const newTx = await prepareTransaction({} as Account, oldTx as Transaction);
+    expect(newTx.fee).toEqual(new BigNumber(1));
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,25 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { Transaction } from "../types";
+import { craftTransaction, estimateFees } from "../common-logic";
+import { getNextSequence } from "../network/node";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const seq = await getNextSequence(account.freshAddress);
+
+  const craftedTransaction = await craftTransaction(
+    { address: account.freshAddress, nextSequenceNumber: seq },
+    { amount: transaction.amount, recipient: transaction.recipient },
+  );
+
+  const fee = await estimateFees(craftedTransaction.serializedTransaction);
+
+  if (transaction.fee !== new BigNumber(fee.toString())) {
+    return { ...transaction, fee: new BigNumber(fee.toString()) };
+  }
+
+  return transaction;
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,94 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge, Operation } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import BigNumber from "bignumber.js";
+import { combine, craftTransaction, getNextValidSequence } from "../common-logic";
+import { Transaction, ConcordiumSigner, ConcordiumNativeTransaction } from "../types";
+
+export const buildSignOperation =
+  (signerContext: SignerContext<ConcordiumSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({ account, deviceId, transaction }) =>
+    new Observable(o => {
+      async function main() {
+        const { fee } = transaction;
+        if (!fee) throw new FeeNotLoaded();
+
+        try {
+          // o observables allows to define steps of the signing process with the device
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const nextSequenceNumber = await getNextValidSequence(account.freshAddress);
+
+          const signature = await signerContext(deviceId, async signer => {
+            const { freshAddressPath: derivationPath } = account;
+            const { publicKey } = await signer.getAddress(derivationPath);
+
+            const { nativeTransaction, serializedTransaction } = await craftTransaction(
+              {
+                address: account.freshAddress,
+                publicKey,
+              },
+              {
+                recipient: transaction.recipient,
+                amount: transaction.amount,
+                fee: fee,
+              },
+            );
+
+            const transactionSignature = await signer.signTransaction(
+              derivationPath,
+              serializedTransaction,
+            );
+
+            return combine(serializedTransaction, transactionSignature, publicKey);
+          });
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          // We create an optimistic operation here, the framework will then replace this transaction with the one returned by the indexer
+          const hash = "";
+          const operation: Operation = {
+            id: encodeOperationId(account.id, hash, "OUT"),
+            hash,
+            accountId: account.id,
+            type: "OUT",
+            value: transaction.amount,
+            fee,
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            date: new Date(),
+            transactionSequenceNumber: new BigNumber(nextSequenceNumber),
+            extra: {},
+          };
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature,
+            },
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            throw new Error(
+              (e as Error & { data?: { resultMessage?: string } })?.data?.resultMessage,
+            );
+          }
+
+          throw e;
+        }
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });