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

package/src/bridge/onboard.ts

@@ -1,6 +1,10 @@
 import { Observable } from "rxjs";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { CantonSigner } from "../types/signer";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import { getDerivationModesForCurrency } from "@ledgerhq/coin-framework/derivation";
+import { getAccountShape } from "./sync";
+import { CantonAccount, CantonSigner } from "../types";
+import type { Account, DerivationMode } from "@ledgerhq/types-live";
 import {
   prepareOnboarding,
   submitOnboarding,
@@ -19,8 +23,10 @@ import {
   CantonPreApprovalResult,
   PrepareTransactionResponse,
 } from "../types/onboard";
+import resolver from "../signer";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-async function getKeypair(
+async function _getKeypair(
   signerContext: SignerContext<CantonSigner>,
   deviceId: string,
   derivationPath: string,
@@ -32,25 +38,27 @@ async function getKeypair(
 }
 
 export const isAccountOnboarded = async (
+  currency: CryptoCurrency,
   publicKey: string,
-): Promise<false | { party_id: 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 { party_id };
+      return { isOnboarded: true, party_id };
     } else {
-      return false;
+      return { isOnboarded: false };
     }
   } catch (err) {
     log("[isAccountOnboarded] Error checking party status (likely not onboarded):", err);
-    return false;
+    return { isOnboarded: false };
   }
 };
 
 export const buildOnboardAccount =
   (signerContext: SignerContext<CantonSigner>) =>
   (
+    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
   ): Observable<CantonOnboardProgress | CantonOnboardResult> =>
@@ -59,22 +67,36 @@ export const buildOnboardAccount =
         observer.next({
           status: OnboardStatus.INIT,
         });
-        const keypair = await getKeypair(signerContext, deviceId, derivationPath);
+        const derivationMode = getDerivationModesForCurrency(currency)[0];
+        const getAddress = resolver(signerContext);
+        const { address, publicKey } = await getAddress(deviceId, {
+          path: derivationPath,
+          currency,
+          derivationMode: derivationMode || "",
+        });
 
         observer.next({
           status: OnboardStatus.PREPARE,
         });
 
-        const isOnboardedResult = await isAccountOnboarded(keypair.publicKey);
-        if (isOnboardedResult && isOnboardedResult.party_id) {
+        const { party_id: partyId } = await isAccountOnboarded(currency, publicKey);
+        if (partyId) {
+          const account = await createAccount({
+            address,
+            derivationPath,
+            partyId,
+            currency,
+            derivationMode,
+          });
           observer.next({
-            partyId: isOnboardedResult.party_id,
+            partyId,
+            account,
           });
           observer.complete();
           return;
         }
 
-        const preparedTransaction = await prepareOnboarding(keypair.publicKey, "ed25519");
+        const preparedTransaction = await prepareOnboarding(currency, publicKey, "ed25519");
 
         observer.next({
           status: OnboardStatus.SIGN,
@@ -89,26 +111,44 @@ export const buildOnboardAccount =
         });
 
         const result = await submitOnboarding(
-          { public_key: keypair.publicKey, public_key_type: "ed25519" },
+          currency,
+          { public_key: publicKey, public_key_type: "ed25519" },
           preparedTransaction,
           signature,
-        ).catch(err => {
+        ).catch(async err => {
           if (err.type === "PARTY_ALREADY_EXISTS") {
+            const account = await createAccount({
+              address,
+              derivationPath,
+              partyId: preparedTransaction.party_id,
+              currency,
+              derivationMode,
+            });
             observer.next({
               partyId: preparedTransaction.party_id,
+              account,
             });
             return observer.complete();
           }
           throw err;
         });
 
-        observer.next({
-          status: OnboardStatus.SUCCESS,
-        });
-
-        observer.next({
-          partyId: result?.party?.party_id || "unknown",
-        });
+        if (result) {
+          observer.next({
+            status: OnboardStatus.SUCCESS,
+          });
+          const account = await createAccount({
+            address,
+            derivationPath,
+            partyId: result.party.party_id,
+            currency,
+            derivationMode,
+          });
+          observer.next({
+            partyId: result.party.party_id,
+            account,
+          });
+        }
 
         observer.complete();
       }
@@ -125,6 +165,7 @@ export const buildOnboardAccount =
 export const buildAuthorizePreapproval =
   (signerContext: SignerContext<CantonSigner>) =>
   (
+    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
     partyId: string,
@@ -135,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,
@@ -151,6 +194,7 @@ export const buildAuthorizePreapproval =
         });
 
         const { isApproved } = await submitPreApprovalTransaction(
+          currency,
           partyId,
           preparedTransaction,
           signature,
@@ -164,38 +208,35 @@ export const buildAuthorizePreapproval =
           isApproved,
         });
 
-        // TODO: remove after demo
         const handleTapRequest = async () => {
           try {
-            observer.next({
-              status: PreApprovalStatus.PREPARE,
-            });
-
-            const { serialized, hash } = await prepareTapRequest({
-              partyId,
-            });
-
-            observer.next({
-              status: PreApprovalStatus.SIGN,
-            });
-
-            const signature = await signerContext(deviceId, signer =>
-              signer.signTransaction(derivationPath, hash),
-            );
-
-            observer.next({
-              status: PreApprovalStatus.SUBMIT,
-            });
-
-            await submitTapRequest({
+            const { serialized, hash } = await prepareTapRequest(currency, {
               partyId,
-              serialized,
-              signature,
             });
 
-            observer.next({
-              status: PreApprovalStatus.SUCCESS,
-            });
+            if (serialized && hash) {
+              observer.next({
+                status: PreApprovalStatus.SIGN,
+              });
+
+              const signature = await signerContext(deviceId, signer =>
+                signer.signTransaction(derivationPath, hash),
+              );
+
+              observer.next({
+                status: PreApprovalStatus.SUBMIT,
+              });
+
+              await submitTapRequest(currency, {
+                partyId,
+                serialized,
+                signature,
+              });
+
+              observer.next({
+                status: PreApprovalStatus.SUCCESS,
+              });
+            }
           } catch (err) {
             // Tap request failure should not break the pre-approval flow
           }
@@ -214,7 +255,58 @@ export const buildAuthorizePreapproval =
       );
     });
 
-const log = (message: string, ...rest: any[]) => {
+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(
+    {
+      address,
+      currency,
+      derivationMode,
+      derivationPath,
+      index,
+      rest: {
+        cantonResources: {
+          partyId,
+        },
+      },
+    },
+    { paginationConfig: {} },
+  );
+
+  const account: Partial<CantonAccount> = {
+    ...accountShape,
+    type: "Account",
+    xpub: partyId.replace(/:/g, "_"),
+    index,
+    // operations: [],
+    currency,
+    derivationMode,
+    lastSyncDate: new Date(),
+    pendingOperations: [],
+    seedIdentifier: address,
+    balanceHistoryCache: emptyHistoryCache,
+    cantonResources: {
+      partyId,
+    },
+  };
+
+  return account;
+};
+
+const log = (message: string, ...rest: unknown[]) => {
   // eslint-disable-next-line no-console
   console.log(message, ...rest);
 };

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/serialization.ts

@@ -0,0 +1,36 @@
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import type {
+  CantonAccount,
+  CantonAccountRaw,
+  CantonResources,
+  CantonResourcesRaw,
+} from "../types";
+
+function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
+  const { partyId } = r;
+  return {
+    partyId,
+  };
+}
+function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
+  const { partyId } = r;
+  return {
+    partyId,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  const cantonAccount = account as CantonAccount;
+  const cantonAccountRaw = accountRaw as CantonAccountRaw;
+  if (cantonAccount.cantonResources) {
+    cantonAccountRaw.cantonResources = toResourcesRaw(cantonAccount.cantonResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account): void {
+  const cantonResourcesRaw = (accountRaw as CantonAccountRaw).cantonResources;
+  const cantonAccount = account as CantonAccount;
+  if (cantonResourcesRaw) {
+    cantonAccount.cantonResources = fromResourcesRaw(cantonResourcesRaw);
+  }
+}

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.integ.test.ts

@@ -110,7 +110,7 @@ describe("sync (devnet)", () => {
 
       mockGetBalance.mockResolvedValue([
         {
-          instrument_id: "canton_network",
+          instrument_id: "Amulet",
           amount: 1000000,
           locked: true,
         },
@@ -167,7 +167,7 @@ describe("sync (devnet)", () => {
       const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
 
       expect(result.operations).toBeDefined();
-      expect(result.operationsCount).toBeGreaterThan(1);
+      expect(result.operationsCount).toBeGreaterThanOrEqual(1);
 
       expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
         cursor: 0,

package/src/bridge/sync.ts

@@ -1,14 +1,14 @@
 import BigNumber from "bignumber.js";
-import { Operation } from "@ledgerhq/types-live";
-import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+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 { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
-
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
+import { CantonAccount } from "../types";
 import coinConfig from "../config";
 
 const txInfoToOperationAdapter =
-  (accountId: string, address: string) =>
+  (accountId: string, partyId: string) =>
   (txInfo: OperationInfo): Operation => {
     const {
       transaction_hash,
@@ -18,11 +18,17 @@ const txInfoToOperationAdapter =
       recipients,
       transaction_timestamp,
       fee: { value: fee },
-      transfers: [{ value: transferValue }],
+      transfers: [{ value: transferValue, details }],
     } = txInfo;
-    const type = senders.includes(address) ? "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,
       },
     };
 
@@ -48,42 +55,43 @@ const txInfoToOperationAdapter =
 const filterOperations = (
   transactions: OperationInfo[],
   accountId: string,
-  address: string,
+  partyId: string,
 ): Operation[] => {
-  return transactions
-    .filter(tx => tx.type === "Receive" || tx.type === "Send")
-    .map(txInfoToOperationAdapter(accountId, address));
+  return transactions.map(txInfoToOperationAdapter(accountId, partyId));
 };
 
-export const getAccountShape: GetAccountShape = async info => {
-  const { address, initialAccount, currency, derivationMode } = info;
-  // TODO: we need better solution ?
-  const xpubOrAddress = address?.replace(/:/g, "_") || "";
+export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
+  const { address, initialAccount, currency, derivationMode, derivationPath, rest } = info;
+
+  const xpubOrAddress = (
+    (initialAccount && initialAccount.id && decodeAccountId(initialAccount.id).xpubOrAddress) ||
+    ""
+  ).replace(/:/g, "_");
+  const partyId =
+    rest?.cantonResources?.partyId ||
+    initialAccount?.cantonResources?.partyId ||
+    xpubOrAddress.replace(/_/g, ":");
 
   const accountId = encodeAccountId({
     type: "js",
     version: "2",
     currencyId: currency.id,
     xpubOrAddress,
-    derivationMode: "",
+    derivationMode,
   });
 
-  // blockheight retrieval
-  const blockHeight = await getLedgerEnd();
-
   // Account info retrieval + spendable balance calculation
   // const accountInfo = await getAccountInfo(address);
-  const balances = await getBalance(address);
+  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,
@@ -93,16 +101,14 @@ export const getAccountShape: GetAccountShape = async info => {
   // Tx history fetching
   const oldOperations = initialAccount?.operations || [];
   const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-  const transactionData = await getOperations(address, {
+  const transactionData = await getOperations(currency, partyId, {
     cursor: startAt,
     limit: 100,
   });
+  // blockheight retrieval
+  const blockHeight = await getLedgerEnd(currency);
 
-  const newOperations = filterOperations(
-    transactionData.operations,
-    accountId,
-    address.replace(/_/g, ":"),
-  );
+  const newOperations = filterOperations(transactionData.operations, accountId, partyId);
   const operations = mergeOps(oldOperations, newOperations);
 
   // We return the new account shape
@@ -114,6 +120,11 @@ export const getAccountShape: GetAccountShape = async info => {
     spendableBalance,
     operations,
     operationsCount: operations.length,
+    freshAddress: address,
+    freshAddressPath: derivationPath,
+    cantonResources: {
+      partyId,
+    },
   };
 
   return shape;

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(),
   };
 }