@ledgerhq/coin-canton 0.5.0 → 0.5.1-nightly.0

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

@@ -1,25 +1,16 @@
 import { AccountBridge } from "@ledgerhq/types-live";
 import { Transaction } from "../types";
-import { craftTransaction, estimateFees } from "../common-logic";
-import { getNextSequence } from "../network/node";
+import { estimateFees } from "../common-logic";
 import BigNumber from "bignumber.js";
+import { updateTransaction } from "./updateTransaction";
 
 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()) };
+  let fee = transaction.fee;
+  if (!fee || fee.eq(0)) {
+    fee = BigNumber((await estimateFees(account.currency)).toString());
   }
-
-  return transaction;
+  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,10 +1,11 @@
 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";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { combine, craftTransaction, getNextValidSequence } from "../common-logic";
-import { Transaction, CantonSigner, BoilerplateNativeTransaction } from "../types";
+import { combine, craftTransaction } from "../common-logic";
+import { Transaction, CantonSigner } from "../types";
 
 export const buildSignOperation =
   (signerContext: SignerContext<CantonSigner>): AccountBridge<Transaction>["signOperation"] =>
@@ -20,30 +21,36 @@ export const buildSignOperation =
             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 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 { nativeTransaction, serializedTransaction } = await craftTransaction(
-              {
-                address: account.freshAddress,
-                publicKey,
-              },
+            const { hash, serializedTransaction } = await craftTransaction(
+              account.currency,
               {
-                recipient: transaction.recipient,
-                amount: transaction.amount,
-                fee: fee,
+                address: partyId,
               },
+              params,
             );
+            const transactionSignature = await signer.signTransaction(derivationPath, hash);
 
-            const transactionSignature = await signer.signTransaction(
-              derivationPath,
-              serializedTransaction,
-            );
-
-            return combine(serializedTransaction, transactionSignature);
+            return combine(serializedTransaction, `${transactionSignature}__PARTY__${partyId}`);
           });
 
           o.next({
@@ -64,7 +71,6 @@ export const buildSignOperation =
             senders: [account.freshAddress],
             recipients: [transaction.recipient],
             date: new Date(),
-            transactionSequenceNumber: nextSequenceNumber,
             extra: {},
           };
 

package/src/bridge/sync.integ.test.ts

@@ -0,0 +1,180 @@
+import BigNumber from "bignumber.js";
+import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import {
+  getDerivationModesForCurrency,
+  getDerivationScheme,
+  runDerivationScheme,
+} from "@ledgerhq/coin-framework/derivation";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { Account, Operation } from "@ledgerhq/types-live";
+import coinConfig from "../config";
+import * as gateway from "../network/gateway";
+import { getAccountShape } from "./sync";
+
+const TEST_ADDRESS =
+  "b6400f93ea1c74aea86be39b0ccc846fc5de01f12b2ad0d7c31848d6fb6eb6d9::1220c81315e2bf2524a9141bcc6cbf19b61c151e0dcaa95343c0ccf53aed7415c4ec";
+const currency = getCryptoCurrencyById("canton_network");
+const derivationMode = getDerivationModesForCurrency(currency)[0];
+const derivationPath = runDerivationScheme(
+  getDerivationScheme({ derivationMode, currency }),
+  currency,
+  {
+    account: 0,
+  },
+);
+const ACCOUNT_SHAPE_INFO: AccountShapeInfo = {
+  address: TEST_ADDRESS,
+  currency,
+  derivationMode,
+  derivationPath,
+  index: 0,
+};
+
+describe("sync (devnet)", () => {
+  beforeAll(async () => {
+    coinConfig.setCoinConfig(() => ({
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
+      useGateway: true,
+      networkType: "devnet",
+      status: {
+        type: "active",
+      },
+    }));
+  });
+
+  describe("getAccountShape", () => {
+    it("should fetch account shape for a valid address", async () => {
+      const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+      expect(result.xpub).toBe(TEST_ADDRESS.replace(/:/g, "_"));
+      expect(result.blockHeight).toBeGreaterThan(0);
+      expect(result.balance).toBeDefined();
+      expect(result.spendableBalance).toBeDefined();
+      expect(result.operations).toBeDefined();
+      expect(result.operationsCount).toBeGreaterThanOrEqual(0);
+
+      expect(result.balance).toBeInstanceOf(Object);
+      expect(result.balance?.toNumber).toBeDefined();
+      expect(result.spendableBalance).toBeInstanceOf(Object);
+      expect(result.spendableBalance?.toNumber).toBeDefined();
+
+      expect(result.spendableBalance?.toNumber()).toBeLessThanOrEqual(
+        result.balance?.toNumber() || 0,
+      );
+    });
+
+    it("should handle address with colons correctly", async () => {
+      const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
+
+      expect(result.xpub).toBe(TEST_ADDRESS.replace(/:/g, "_"));
+    });
+
+    it("should merge operations correctly with initial account", async () => {
+      const operations: Operation[] = [
+        {
+          id: "test-op-1",
+          hash: "test-hash-1",
+          accountId: "test-account",
+          type: "OUT" as const,
+          value: new BigNumber(1000000),
+          fee: new BigNumber(100000),
+          blockHash: "block-hash-1",
+          blockHeight: 100,
+          senders: [TEST_ADDRESS],
+          recipients: ["recipient-1"],
+          date: new Date("2023-01-01"),
+          transactionSequenceNumber: 100,
+          extra: { uid: "uid-1" },
+        },
+      ];
+
+      const result = await getAccountShape(
+        {
+          ...ACCOUNT_SHAPE_INFO,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          initialAccount: { operations } as Account,
+        },
+        { paginationConfig: {} },
+      );
+
+      expect(result.operations).toBeDefined();
+      expect(result.operationsCount).toBeGreaterThanOrEqual(1);
+      const initialOp = result.operations?.find(op => op.id === "test-op-1");
+      expect(initialOp).toBeDefined();
+    });
+
+    it("should take locked balance into account when calculating spendable balance", async () => {
+      const mockGetBalance = jest.spyOn(gateway, "getBalance");
+
+      mockGetBalance.mockResolvedValue([
+        {
+          instrument_id: "Amulet",
+          amount: 1000000,
+          locked: true,
+        },
+      ]);
+
+      const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
+
+      expect(result.balance?.toNumber()).toBe(1000000);
+      expect(result.spendableBalance?.toNumber()).toBe(0);
+
+      mockGetBalance.mockRestore();
+    });
+
+    it("should call getOperations with correct cursor based with initial account", async () => {
+      const mockGetOperations = jest.spyOn(gateway, "getOperations");
+      const operation: Operation = {
+        id: "test-op-1",
+        hash: "test-hash-1",
+        accountId: "test-account",
+        type: "OUT" as const,
+        value: new BigNumber(1000000),
+        fee: new BigNumber(100000),
+        blockHash: "block-hash-1",
+        blockHeight: 100,
+        senders: [TEST_ADDRESS],
+        recipients: ["recipient-1"],
+        date: new Date("2023-01-01"),
+        transactionSequenceNumber: 100,
+        extra: { uid: "uid-1" },
+      };
+
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const initialAccount = { operations: [operation] } as Account;
+
+      const result = await getAccountShape(
+        {
+          ...ACCOUNT_SHAPE_INFO,
+          initialAccount,
+        },
+        { paginationConfig: {} },
+      );
+
+      expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
+        cursor: (operation.blockHeight || 0) + 1,
+        limit: 100,
+      });
+      expect(result.operations).toBeDefined();
+      expect(result.operationsCount).toBeGreaterThan(1);
+    });
+
+    it("should call getOperations with cursor 0 when no initial account", async () => {
+      const mockGetOperations = jest.spyOn(gateway, "getOperations");
+
+      const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
+
+      expect(result.operations).toBeDefined();
+      expect(result.operationsCount).toBeGreaterThanOrEqual(1);
+
+      expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
+        cursor: 0,
+        limit: 100,
+      });
+
+      mockGetOperations.mockRestore();
+    });
+  });
+});