@ledgerhq/coin-canton 0.5.0-nightly.4 → 0.5.0-nightly.5

package/src/bridge/onboard.ts

@@ -2,10 +2,9 @@ import { Observable } from "rxjs";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
 import { getDerivationModesForCurrency } from "@ledgerhq/coin-framework/derivation";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getAccountShape } from "./sync";
 import { CantonAccount, CantonSigner } from "../types";
-import type { Account } from "@ledgerhq/types-live";
+import type { Account, DerivationMode } from "@ledgerhq/types-live";
 import {
   prepareOnboarding,
   submitOnboarding,
@@ -25,6 +24,7 @@ import {
   PrepareTransactionResponse,
 } from "../types/onboard";
 import resolver from "../signer";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 async function _getKeypair(
   signerContext: SignerContext<CantonSigner>,
@@ -37,14 +37,12 @@ async function _getKeypair(
   });
 }
 
-const currency = getCryptoCurrencyById("canton_network");
-const derivationMode = getDerivationModesForCurrency(currency)[0];
-
 export const isAccountOnboarded = async (
+  currency: CryptoCurrency,
   publicKey: string,
 ): Promise<{ isOnboarded: boolean; party_id?: string }> => {
   try {
-    const { party_id } = await getPartyByPubKey(publicKey);
+    const { party_id } = await getPartyByPubKey(currency, publicKey);
 
     if (party_id) {
       return { isOnboarded: true, party_id };
@@ -60,6 +58,7 @@ export const isAccountOnboarded = async (
 export const buildOnboardAccount =
   (signerContext: SignerContext<CantonSigner>) =>
   (
+    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
   ): Observable<CantonOnboardProgress | CantonOnboardResult> =>
@@ -68,6 +67,7 @@ export const buildOnboardAccount =
         observer.next({
           status: OnboardStatus.INIT,
         });
+        const derivationMode = getDerivationModesForCurrency(currency)[0];
         const getAddress = resolver(signerContext);
         const { address, publicKey } = await getAddress(deviceId, {
           path: derivationPath,
@@ -79,9 +79,15 @@ export const buildOnboardAccount =
           status: OnboardStatus.PREPARE,
         });
 
-        const { party_id: partyId } = await isAccountOnboarded(publicKey);
+        const { party_id: partyId } = await isAccountOnboarded(currency, publicKey);
         if (partyId) {
-          const account = await createAccount({ address, derivationPath, partyId });
+          const account = await createAccount({
+            address,
+            derivationPath,
+            partyId,
+            currency,
+            derivationMode,
+          });
           observer.next({
             partyId,
             account,
@@ -90,7 +96,7 @@ export const buildOnboardAccount =
           return;
         }
 
-        const preparedTransaction = await prepareOnboarding(publicKey, "ed25519");
+        const preparedTransaction = await prepareOnboarding(currency, publicKey, "ed25519");
 
         observer.next({
           status: OnboardStatus.SIGN,
@@ -105,6 +111,7 @@ export const buildOnboardAccount =
         });
 
         const result = await submitOnboarding(
+          currency,
           { public_key: publicKey, public_key_type: "ed25519" },
           preparedTransaction,
           signature,
@@ -114,6 +121,8 @@ export const buildOnboardAccount =
               address,
               derivationPath,
               partyId: preparedTransaction.party_id,
+              currency,
+              derivationMode,
             });
             observer.next({
               partyId: preparedTransaction.party_id,
@@ -132,6 +141,8 @@ export const buildOnboardAccount =
             address,
             derivationPath,
             partyId: result.party.party_id,
+            currency,
+            derivationMode,
           });
           observer.next({
             partyId: result.party.party_id,
@@ -154,6 +165,7 @@ export const buildOnboardAccount =
 export const buildAuthorizePreapproval =
   (signerContext: SignerContext<CantonSigner>) =>
   (
+    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
     partyId: string,
@@ -164,8 +176,10 @@ export const buildAuthorizePreapproval =
           status: PreApprovalStatus.PREPARE,
         });
 
-        const preparedTransaction: PrepareTransactionResponse =
-          await preparePreApprovalTransaction(partyId);
+        const preparedTransaction: PrepareTransactionResponse = await preparePreApprovalTransaction(
+          currency,
+          partyId,
+        );
 
         observer.next({
           status: PreApprovalStatus.SIGN,
@@ -180,6 +194,7 @@ export const buildAuthorizePreapproval =
         });
 
         const { isApproved } = await submitPreApprovalTransaction(
+          currency,
           partyId,
           preparedTransaction,
           signature,
@@ -195,7 +210,7 @@ export const buildAuthorizePreapproval =
 
         const handleTapRequest = async () => {
           try {
-            const { serialized, hash } = await prepareTapRequest({
+            const { serialized, hash } = await prepareTapRequest(currency, {
               partyId,
             });
 
@@ -212,7 +227,7 @@ export const buildAuthorizePreapproval =
                 status: PreApprovalStatus.SUBMIT,
               });
 
-              await submitTapRequest({
+              await submitTapRequest(currency, {
                 partyId,
                 serialized,
                 signature,
@@ -244,11 +259,15 @@ const createAccount = async ({
   address,
   partyId,
   derivationPath,
+  currency,
+  derivationMode,
   index = 0,
 }: {
   address: string;
   derivationPath: string;
   partyId: string;
+  currency: CryptoCurrency;
+  derivationMode: DerivationMode;
   index?: number;
 }): Promise<Partial<Account>> => {
   const accountShape = await getAccountShape(

package/src/bridge/prepareTransaction.ts

@@ -10,7 +10,7 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
 ) => {
   let fee = transaction.fee;
   if (!fee || fee.eq(0)) {
-    fee = BigNumber((await estimateFees("")).toString());
+    fee = BigNumber((await estimateFees(account.currency)).toString());
   }
   return updateTransaction(transaction, { fee });
 };

package/src/bridge/signOperation.ts

@@ -1,4 +1,5 @@
 import { Observable } from "rxjs";
+import BigNumber from "bignumber.js";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import { AccountBridge, Operation } from "@ledgerhq/types-live";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
@@ -22,18 +23,30 @@ export const buildSignOperation =
 
           const signature = await signerContext(deviceId, async signer => {
             const { freshAddressPath: derivationPath } = account;
-            const partyId = account.freshAddress.replace("__", "::");
+            const partyId = (account as unknown as { cantonResources: { partyId: string } })
+              .cantonResources.partyId;
+            const params: {
+              recipient?: string;
+              amount: BigNumber;
+              tokenId: string;
+              expireInSeconds: number;
+              memo?: string;
+            } = {
+              recipient: transaction.recipient,
+              amount: transaction.amount,
+              expireInSeconds: 60 * 60,
+              tokenId: "Amulet",
+            };
+            if (transaction.memo) {
+              params.memo = transaction.memo;
+            }
 
             const { hash, serializedTransaction } = await craftTransaction(
+              account.currency,
               {
                 address: partyId,
               },
-              {
-                recipient: transaction.recipient,
-                amount: transaction.amount,
-                expireInSeconds: 60 * 60,
-                tokenId: "Amulet",
-              },
+              params,
             );
             const transactionSignature = await signer.signTransaction(derivationPath, hash);
 

package/src/bridge/sync.ts

@@ -1,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import { Operation } from "@ledgerhq/types-live";
+import { Operation, OperationType } from "@ledgerhq/types-live";
 import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
@@ -18,11 +18,17 @@ const txInfoToOperationAdapter =
       recipients,
       transaction_timestamp,
       fee: { value: fee },
-      transfers: [{ value: transferValue }],
+      transfers: [{ value: transferValue, details }],
     } = txInfo;
-    const type = senders.includes(partyId) ? "OUT" : "IN";
+    let type: OperationType = "UNKNOWN";
+    if (txInfo.type === "Send") {
+      type = senders.includes(partyId) ? "OUT" : "IN";
+    } else if (txInfo.type === "Receive") {
+      type = "IN";
+    }
     const value = new BigNumber(transferValue);
     const feeValue = new BigNumber(fee);
+    const memo = details.metadata.reason;
 
     const op: Operation = {
       id: encodeOperationId(accountId, transaction_hash, type),
@@ -39,6 +45,7 @@ const txInfoToOperationAdapter =
       transactionSequenceNumber: height,
       extra: {
         uid,
+        memo,
       },
     };
 
@@ -50,9 +57,7 @@ const filterOperations = (
   accountId: string,
   partyId: string,
 ): Operation[] => {
-  return transactions
-    .filter(tx => tx.type === "Receive" || tx.type === "Send")
-    .map(txInfoToOperationAdapter(accountId, partyId));
+  return transactions.map(txInfoToOperationAdapter(accountId, partyId));
 };
 
 export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
@@ -75,22 +80,18 @@ export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
     derivationMode,
   });
 
-  // blockheight retrieval
-  const blockHeight = await getLedgerEnd();
-
   // Account info retrieval + spendable balance calculation
   // const accountInfo = await getAccountInfo(address);
-  const balances = await getBalance(partyId);
+  const balances = await getBalance(currency, partyId);
 
-  // TODO change to balance.instrument_id === "Amulet" after update on backend
-  const balanceData = balances.find(balance => balance.instrument_id.includes("Amulet")) || {
+  const balanceData = balances.find(balance => balance.instrument_id === "Amulet") || {
     instrument_id: "Amulet",
     amount: 0,
     locked: false,
   };
 
   const balance = new BigNumber(balanceData.amount);
-  const reserveMin = coinConfig.getCoinConfig().minReserve || 0;
+  const reserveMin = coinConfig.getCoinConfig(currency).minReserve || 0;
   const lockedAmount = balanceData.locked ? balance : new BigNumber(0);
   const spendableBalance = BigNumber.max(
     0,
@@ -100,10 +101,12 @@ export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
   // Tx history fetching
   const oldOperations = initialAccount?.operations || [];
   const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-  const transactionData = await getOperations(partyId, {
+  const transactionData = await getOperations(currency, partyId, {
     cursor: startAt,
     limit: 100,
   });
+  // blockheight retrieval
+  const blockHeight = await getLedgerEnd(currency);
 
   const newOperations = filterOperations(transactionData.operations, accountId, partyId);
   const operations = mergeOps(oldOperations, newOperations);

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

@@ -1,23 +1,28 @@
 import { Balance } from "@ledgerhq/coin-framework/api/types";
 import { getBalance as gatewayGetBalance, type InstrumentBalance } from "../../network/gateway";
 import coinConfig from "../../config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
-const getNativeId = () => coinConfig.getCoinConfig().nativeInstrumentId;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
+const getNativeId = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).nativeInstrumentId;
 
-function adaptInstrument(instrument: InstrumentBalance): Balance {
+function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): Balance {
   return {
     value: BigInt(instrument.amount),
     locked: instrument.locked === true ? BigInt(instrument.amount) : BigInt(0),
     asset:
-      getNativeId() === instrument.instrument_id
+      getNativeId(currency) === instrument.instrument_id
         ? { type: "native" }
         : { type: "token", assetReference: instrument.instrument_id },
   };
 }
 
-export async function getBalance(partyId: string): Promise<Balance[]> {
-  if (useGateway())
-    return (await gatewayGetBalance(partyId)).map(instrument => adaptInstrument(instrument));
+export async function getBalance(currency: CryptoCurrency, partyId: string): Promise<Balance[]> {
+  if (useGateway(currency))
+    return (await gatewayGetBalance(currency, partyId)).map(instrument =>
+      adaptInstrument(currency, instrument),
+    );
   else throw new Error("Not implemented");
 }

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

@@ -2,6 +2,11 @@ import { getBalance as getBalanceFromNetwork } from "../../network/gateway";
 import * as coinConfigModule from "../../config";
 import { getBalance } from "./getBalance";
 import { Balance } from "@ledgerhq/coin-framework/api/types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
 
 jest.mock("../../network/gateway", () => ({
   getBalance: jest.fn(),
@@ -35,9 +40,9 @@ describe("getBalance", () => {
 
     (getBalanceFromNetwork as jest.Mock).mockResolvedValue(mockInstruments);
 
-    const result = await getBalance("party-id");
+    const result = await getBalance(mockCurrency, "party-id");
 
-    expect(getBalanceFromNetwork).toHaveBeenCalledWith("party-id");
+    expect(getBalanceFromNetwork).toHaveBeenCalledWith(mockCurrency, "party-id");
     expect(result).toEqual<Balance[]>([
       {
         value: BigInt(1000),
@@ -57,7 +62,7 @@ describe("getBalance", () => {
       useGateway: false,
     } as any);
 
-    await expect(getBalance("party-id")).rejects.toThrow("Not implemented");
+    await expect(getBalance(mockCurrency, "party-id")).rejects.toThrow("Not implemented");
     expect(getBalanceFromNetwork).not.toHaveBeenCalled();
   });
 });

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

@@ -1,6 +1,7 @@
 import { lastBlock } from "./lastBlock";
 import { getLedgerEnd as gatewayGetLedgerEnd } from "../../network/gateway";
 import { getLedgerEnd as nodeGetLedgerEnd } from "../../network/node";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../../network/gateway", () => ({
   getLedgerEnd: jest.fn(),
@@ -18,6 +19,10 @@ jest.mock("../../config", () => ({
 
 import coinConfig from "../../config";
 
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
+
 describe("lastBlock", () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -27,7 +32,7 @@ describe("lastBlock", () => {
     (coinConfig.getCoinConfig as jest.Mock).mockReturnValue({ useGateway: true });
     (gatewayGetLedgerEnd as jest.Mock).mockResolvedValue(100);
 
-    const result = await lastBlock();
+    const result = await lastBlock(mockCurrency);
 
     expect(result).toEqual({ height: 100 });
     expect(gatewayGetLedgerEnd).toHaveBeenCalledTimes(1);
@@ -38,7 +43,7 @@ describe("lastBlock", () => {
     (coinConfig.getCoinConfig as jest.Mock).mockReturnValue({ useGateway: false });
     (nodeGetLedgerEnd as jest.Mock).mockResolvedValue(200);
 
-    const result = await lastBlock();
+    const result = await lastBlock(mockCurrency);
 
     expect(result).toEqual({ height: 200 });
     expect(nodeGetLedgerEnd).toHaveBeenCalledTimes(1);

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

@@ -2,11 +2,13 @@ import type { BlockInfo } from "@ledgerhq/coin-framework/api/index";
 import { getLedgerEnd as nodeGetLedgerEnd } from "../../network/node";
 import { getLedgerEnd } from "../../network/gateway";
 import coinConfig from "../../config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
 
-export async function lastBlock(): Promise<BlockInfo> {
+export async function lastBlock(currency: CryptoCurrency): Promise<BlockInfo> {
   return {
-    height: useGateway() ? await getLedgerEnd() : await nodeGetLedgerEnd(),
+    height: useGateway(currency) ? await getLedgerEnd(currency) : await nodeGetLedgerEnd(),
   };
 }

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

@@ -1,6 +1,6 @@
 import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
 import { getOperations } from "../../network/gateway";
-import coinConfig from "../../config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 /**
  * Returns list of operations associated to an account.
@@ -10,10 +10,11 @@ import coinConfig from "../../config";
  * Impl to finalize when backend is ready
  */
 export async function listOperations(
+  currency: CryptoCurrency,
   partyId: string,
   page: Pagination,
 ): Promise<[Operation[], string]> {
-  const { operations, next } = await getOperations(partyId, {
+  const { operations, next } = await getOperations(currency, partyId, {
     cursor: page.pagingToken !== undefined ? parseInt(page.pagingToken) : undefined,
     minOffset: page.minHeight,
     limit: page.limit,

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

@@ -1,6 +1,7 @@
 import { submit } from "../../network/gateway";
 import * as coinConfigModule from "../../config";
 import { broadcast } from "./broadcast";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../../network/gateway", () => ({
   submit: jest.fn(),
@@ -11,6 +12,10 @@ const mockSerialized = JSON.stringify({
   signature: "signature__PARTY__alice:123",
 });
 
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
+
 describe("broadcast", () => {
   const mockGetCoinConfig = jest.spyOn(coinConfigModule.default, "getCoinConfig");
 
@@ -25,9 +30,9 @@ describe("broadcast", () => {
 
     (submit as jest.Mock).mockResolvedValue({ update_id: "my-update-id" });
 
-    const result = await broadcast(mockSerialized);
+    const result = await broadcast(mockCurrency, mockSerialized);
 
-    expect(submit).toHaveBeenCalledWith("alice:123", "serialized-tx", "signature");
+    expect(submit).toHaveBeenCalledWith(mockCurrency, "alice:123", "serialized-tx", "signature");
     expect(result).toEqual("my-update-id");
   });
 
@@ -36,7 +41,7 @@ describe("broadcast", () => {
       useGateway: false,
     } as any);
 
-    await expect(broadcast(mockSerialized)).rejects.toThrow("Not implemented");
+    await expect(broadcast(mockCurrency, mockSerialized)).rejects.toThrow("Not implemented");
     expect(submit).not.toHaveBeenCalled();
   });
 });

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

@@ -1,11 +1,14 @@
 import coinConfig from "../../config";
 import { submit } from "../../network/gateway";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
 
-export async function broadcast(signedTx: string): Promise<string> {
+export async function broadcast(currency: CryptoCurrency, signedTx: string): Promise<string> {
   const parsed: { serialized: string; signature: string } = JSON.parse(signedTx);
   const [sig, party] = parsed.signature.split("__PARTY__");
-  if (useGateway()) return (await submit(party, parsed.serialized, sig)).update_id;
+  if (useGateway(currency))
+    return (await submit(currency, party, parsed.serialized, sig)).update_id;
   else throw new Error("Not implemented");
 }

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

@@ -1,7 +1,13 @@
 import BigNumber from "bignumber.js";
-import { prepareTransferRequest, PrepareTransferResponse } from "../../network/gateway";
+import {
+  PrepareTransferRequest,
+  prepareTransferRequest,
+  PrepareTransferResponse,
+} from "../../network/gateway";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export async function craftTransaction(
+  currency: CryptoCurrency,
   account: {
     address: string;
     nextSequenceNumber?: number;
@@ -12,19 +18,30 @@ export async function craftTransaction(
     amount: BigNumber;
     tokenId: string;
     expireInSeconds: number;
+    memo?: string;
   },
 ): Promise<{
   nativeTransaction: PrepareTransferResponse;
   serializedTransaction: string;
   hash: string;
 }> {
-  const { serialized, json, hash } = await prepareTransferRequest(account.address, {
+  const params: PrepareTransferRequest = {
     recipient: transaction.recipient || "",
-    amount: transaction.amount.toNumber(),
-    type: "token-transfer-request",
+    amount: transaction.amount.toString(),
+    type: "token-transfer-request" as const,
     execute_before_secs: transaction.expireInSeconds,
     instrument_id: transaction.tokenId,
-  });
+  };
+
+  if (transaction.memo) {
+    params.reason = transaction.memo;
+  }
+
+  const { serialized, json, hash } = await prepareTransferRequest(
+    currency,
+    account.address,
+    params,
+  );
 
   return {
     nativeTransaction: json,

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

@@ -1,8 +1,8 @@
 import coinConfig from "../../config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const feeValue = () => coinConfig.getCoinConfig().fee ?? 10_000;
+const feeValue = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).fee ?? 1;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function estimateFees(serializedTransaction: string): Promise<bigint> {
-  return Promise.resolve(BigInt(feeValue())); // TODO replace with real implementation
+export async function estimateFees(currency: CryptoCurrency): Promise<bigint> {
+  return Promise.resolve(BigInt(feeValue(currency)));
 }