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

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

@@ -0,0 +1,219 @@
+import { firstValueFrom, toArray } from "rxjs";
+import { generateMockKeyPair, createMockSigner } from "../test/cantonTestUtils";
+import { buildOnboardAccount, isAccountOnboarded, buildAuthorizePreapproval } from "./onboard";
+import {
+  OnboardStatus,
+  PreApprovalStatus,
+  CantonOnboardProgress,
+  CantonOnboardResult,
+  CantonPreApprovalProgress,
+  CantonPreApprovalResult,
+} from "../types/onboard";
+import coinConfig from "../config";
+
+describe("onboard (devnet)", () => {
+  const mockDeviceId = "test-device-id";
+  const mockDerivationPath = "44'/6767'/0'/0'/0'";
+
+  let onboardedAccount: {
+    keyPair: ReturnType<typeof generateMockKeyPair>;
+    mockSigner: ReturnType<typeof createMockSigner>;
+    mockSignerContext: jest.Mock;
+    onboardResult: CantonOnboardResult;
+  } | null = null;
+
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
+      useGateway: true,
+      networkType: "devnet",
+      status: {
+        type: "active",
+      },
+    }));
+  });
+
+  const getOnboardedAccount = () => {
+    if (!onboardedAccount) {
+      throw new Error(
+        "onboardedAccount is null. Ensure isAccountOnboarded test runs first to set it.",
+      );
+    }
+    return onboardedAccount;
+  };
+
+  describe("isAccountOnboarded", () => {
+    it("should return true for onboarded account", async () => {
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+      const mockSigner = createMockSigner(keyPair);
+      const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
+        return callback(mockSigner);
+      });
+
+      const onboardObservable = buildOnboardAccount(mockSignerContext);
+      const onboardValues = await firstValueFrom(
+        onboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
+      );
+      const onboardResult = onboardValues.find(
+        (value): value is CantonOnboardResult => "partyId" in value,
+      );
+
+      if (!onboardResult) {
+        throw new Error("Failed to onboard account for shared test data");
+      }
+
+      // Save onboarded account for all tests that need a valid party ID
+      onboardedAccount = {
+        keyPair,
+        mockSigner,
+        mockSignerContext,
+        onboardResult,
+      };
+
+      // WHEN
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
+
+      // THEN
+      expect(result).not.toBe(false);
+      if (typeof result === "object") {
+        expect(result.party_id).toBeDefined();
+        expect(result.party_id).toBe(onboardResult!.partyId);
+      }
+    }, 30000);
+
+    it("should return false for non-onboarded account with fresh keypair", async () => {
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+
+      // WHEN
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
+
+      // THEN
+      expect(result).toBe(false);
+    }, 15000);
+
+    it("should handle errors gracefully when checking non-existent party", async () => {
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+
+      // WHEN
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
+
+      // THEN
+      expect(result).toBe(false);
+    }, 15000);
+  });
+
+  describe("buildOnboardAccount", () => {
+    it("should complete full onboarding flow with fresh keypair", async () => {
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+      const mockSigner = createMockSigner(keyPair);
+      const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
+        return callback(mockSigner);
+      });
+      const onboardObservable = buildOnboardAccount(mockSignerContext);
+
+      // WHEN
+      const allValues = await firstValueFrom(
+        onboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
+      );
+      const progressValues = allValues.filter(
+        (value): value is CantonOnboardProgress => "status" in value && !("partyId" in value),
+      );
+      const resultValues = allValues.filter(
+        (value): value is CantonOnboardResult => "partyId" in value,
+      );
+
+      // THEN
+      // Check expected status progression
+      expect(progressValues.some(p => p.status === OnboardStatus.INIT)).toBe(true);
+      expect(progressValues.some(p => p.status === OnboardStatus.PREPARE)).toBe(true);
+      expect(progressValues.some(p => p.status === OnboardStatus.SIGN)).toBe(true);
+      expect(progressValues.some(p => p.status === OnboardStatus.SUBMIT)).toBe(true);
+
+      // Check final result
+      expect(resultValues.length).toBeGreaterThan(0);
+      const finalResult = resultValues[resultValues.length - 1];
+      expect(finalResult.partyId).toBeDefined();
+      expect(typeof finalResult.partyId).toBe("string");
+
+      expect(mockSignerContext).toHaveBeenCalled();
+    }, 30000);
+
+    it("should complete full onboarding flow with already onboarded account", async () => {
+      // GIVEN
+      const { keyPair, mockSignerContext, onboardResult: firstResult } = getOnboardedAccount();
+      const secondOnboardObservable = buildOnboardAccount(mockSignerContext);
+
+      // WHEN
+      const secondOnboardValues = await firstValueFrom(
+        secondOnboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
+      );
+      const secondResult = secondOnboardValues.find(
+        (value): value is CantonOnboardResult => "partyId" in value,
+      );
+
+      // THEN
+      expect(secondResult).toBeDefined();
+      expect(secondResult!.partyId).toBe(firstResult.partyId);
+      expect(typeof secondResult!.partyId).toBe("string");
+    }, 30000);
+  });
+
+  describe("buildAuthorizePreapproval", () => {
+    it("should complete preapproval flow for onboarded account", async () => {
+      // GIVEN
+      const { mockSignerContext, onboardResult } = getOnboardedAccount();
+      const preapprovalObservable = buildAuthorizePreapproval(mockSignerContext);
+
+      // WHEN
+      const preapprovalValues = await firstValueFrom(
+        preapprovalObservable(mockDeviceId, mockDerivationPath, onboardResult.partyId).pipe(
+          toArray(),
+        ),
+      );
+
+      const progressValues = preapprovalValues.filter(
+        (value): value is CantonPreApprovalProgress =>
+          "status" in value && !("isApproved" in value),
+      );
+      const resultValues = preapprovalValues.filter(
+        (value): value is CantonPreApprovalResult => "isApproved" in value,
+      );
+
+      // THEN
+      // Check expected status progression
+      expect(progressValues.some(p => p.status === PreApprovalStatus.PREPARE)).toBe(true);
+      expect(progressValues.some(p => p.status === PreApprovalStatus.SIGN)).toBe(true);
+      expect(progressValues.some(p => p.status === PreApprovalStatus.SUBMIT)).toBe(true);
+
+      // Check final result (should be approved)
+      expect(resultValues.length).toBeGreaterThan(0);
+      const finalResult = resultValues[resultValues.length - 1];
+      expect(finalResult.isApproved).toBe(true);
+      expect(typeof finalResult.isApproved).toBe("boolean");
+    }, 30000);
+
+    it("should handle invalid party ID gracefully", async () => {
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+      const mockSigner = createMockSigner(keyPair);
+      const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
+        return callback(mockSigner);
+      });
+      const preapprovalObservable = buildAuthorizePreapproval(mockSignerContext);
+
+      // WHEN & THEN
+      try {
+        await firstValueFrom(
+          preapprovalObservable(mockDeviceId, mockDerivationPath, "invalid-party-id-123"),
+        );
+        expect(true).toBe(true);
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    }, 30000);
+  });
+});

package/src/bridge/onboard.ts

@@ -0,0 +1,220 @@
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { CantonSigner } from "../types/signer";
+import {
+  prepareOnboarding,
+  submitOnboarding,
+  getPartyByPubKey,
+  preparePreApprovalTransaction,
+  submitPreApprovalTransaction,
+  prepareTapRequest,
+  submitTapRequest,
+} from "../network/gateway";
+import {
+  OnboardStatus,
+  PreApprovalStatus,
+  CantonOnboardProgress,
+  CantonOnboardResult,
+  CantonPreApprovalProgress,
+  CantonPreApprovalResult,
+  PrepareTransactionResponse,
+} from "../types/onboard";
+
+async function getKeypair(
+  signerContext: SignerContext<CantonSigner>,
+  deviceId: string,
+  derivationPath: string,
+) {
+  return signerContext(deviceId, async signer => {
+    const { publicKey, address } = await signer.getAddress(derivationPath);
+    return { signer, publicKey: publicKey.replace("0x", ""), address };
+  });
+}
+
+export const isAccountOnboarded = async (
+  publicKey: string,
+): Promise<false | { party_id: string }> => {
+  try {
+    const { party_id } = await getPartyByPubKey(publicKey);
+
+    if (party_id) {
+      return { party_id };
+    } else {
+      return false;
+    }
+  } catch (err) {
+    log("[isAccountOnboarded] Error checking party status (likely not onboarded):", err);
+    return false;
+  }
+};
+
+export const buildOnboardAccount =
+  (signerContext: SignerContext<CantonSigner>) =>
+  (
+    deviceId: string,
+    derivationPath: string,
+  ): Observable<CantonOnboardProgress | CantonOnboardResult> =>
+    new Observable(observer => {
+      async function main() {
+        observer.next({
+          status: OnboardStatus.INIT,
+        });
+        const keypair = await getKeypair(signerContext, deviceId, derivationPath);
+
+        observer.next({
+          status: OnboardStatus.PREPARE,
+        });
+
+        const isOnboardedResult = await isAccountOnboarded(keypair.publicKey);
+        if (isOnboardedResult && isOnboardedResult.party_id) {
+          observer.next({
+            partyId: isOnboardedResult.party_id,
+          });
+          observer.complete();
+          return;
+        }
+
+        const preparedTransaction = await prepareOnboarding(keypair.publicKey, "ed25519");
+
+        observer.next({
+          status: OnboardStatus.SIGN,
+        });
+
+        const signature = await signerContext(deviceId, signer =>
+          signer.signTransaction(derivationPath, preparedTransaction.transactions.combined_hash),
+        );
+
+        observer.next({
+          status: OnboardStatus.SUBMIT,
+        });
+
+        const result = await submitOnboarding(
+          { public_key: keypair.publicKey, public_key_type: "ed25519" },
+          preparedTransaction,
+          signature,
+        ).catch(err => {
+          if (err.type === "PARTY_ALREADY_EXISTS") {
+            observer.next({
+              partyId: preparedTransaction.party_id,
+            });
+            return observer.complete();
+          }
+          throw err;
+        });
+
+        observer.next({
+          status: OnboardStatus.SUCCESS,
+        });
+
+        observer.next({
+          partyId: result?.party?.party_id || "unknown",
+        });
+
+        observer.complete();
+      }
+
+      main().then(
+        () => observer.complete(),
+        error => {
+          log("[onboardAccount] Error:", error);
+          observer.error(error);
+        },
+      );
+    });
+
+export const buildAuthorizePreapproval =
+  (signerContext: SignerContext<CantonSigner>) =>
+  (
+    deviceId: string,
+    derivationPath: string,
+    partyId: string,
+  ): Observable<CantonPreApprovalProgress | CantonPreApprovalResult> =>
+    new Observable(observer => {
+      async function main() {
+        observer.next({
+          status: PreApprovalStatus.PREPARE,
+        });
+
+        const preparedTransaction: PrepareTransactionResponse =
+          await preparePreApprovalTransaction(partyId);
+
+        observer.next({
+          status: PreApprovalStatus.SIGN,
+        });
+
+        const signature = await signerContext(deviceId, signer =>
+          signer.signTransaction(derivationPath, preparedTransaction.hash),
+        );
+
+        observer.next({
+          status: PreApprovalStatus.SUBMIT,
+        });
+
+        const { isApproved } = await submitPreApprovalTransaction(
+          partyId,
+          preparedTransaction,
+          signature,
+        );
+
+        observer.next({
+          status: PreApprovalStatus.SUCCESS,
+        });
+
+        observer.next({
+          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({
+              partyId,
+              serialized,
+              signature,
+            });
+
+            observer.next({
+              status: PreApprovalStatus.SUCCESS,
+            });
+          } catch (err) {
+            // Tap request failure should not break the pre-approval flow
+          }
+        };
+        await handleTapRequest();
+
+        observer.complete();
+      }
+
+      main().then(
+        () => observer.complete(),
+        error => {
+          log("[buildAuthorizePreapproval] Error:", error);
+          observer.error(error);
+        },
+      );
+    });
+
+const log = (message: string, ...rest: any[]) => {
+  // 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("")).toString());
   }
-
-  return transaction;
+  return updateTransaction(transaction, { fee });
 };

package/src/bridge/signOperation.ts

@@ -3,8 +3,8 @@ 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 +20,24 @@ 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.freshAddress.replace("__", "::");
 
-            const { nativeTransaction, serializedTransaction } = await craftTransaction(
+            const { hash, serializedTransaction } = await craftTransaction(
               {
-                address: account.freshAddress,
-                publicKey,
+                address: partyId,
               },
               {
                 recipient: transaction.recipient,
                 amount: transaction.amount,
-                fee: fee,
+                expireInSeconds: 60 * 60,
+                tokenId: "Amulet",
               },
             );
+            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 +58,6 @@ export const buildSignOperation =
             senders: [account.freshAddress],
             recipients: [transaction.recipient],
             date: new Date(),
-            transactionSequenceNumber: nextSequenceNumber,
             extra: {},
           };