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

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

@@ -4,7 +4,7 @@ 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 { Transaction, CantonSigner } from "../types";
 
 export const buildSignOperation =
   (signerContext: SignerContext<CantonSigner>): AccountBridge<Transaction>["signOperation"] =>
@@ -34,7 +34,8 @@ export const buildSignOperation =
               {
                 recipient: transaction.recipient,
                 amount: transaction.amount,
-                fee: fee,
+                expireInSeconds: 60 * 60 * 24,
+                tokenId: "Amulet",
               },
             );
 

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: "canton_network",
+          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).toBeGreaterThan(1);
+
+      expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
+        cursor: 0,
+        limit: 100,
+      });
+
+      mockGetOperations.mockRestore();
+    });
+  });
+});

package/src/bridge/sync.ts

@@ -2,101 +2,109 @@ import BigNumber from "bignumber.js";
 import { Operation } from "@ledgerhq/types-live";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { getTransactions } from "../network/indexer";
-import { getAccountInfo, getLedgerEnd } from "../network/node";
+import { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
 
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { BoilerplateOperation } from "../network/types";
 import coinConfig from "../config";
 
-const operationAdapter =
+const txInfoToOperationAdapter =
   (accountId: string, address: string) =>
-  ({
-    meta: { delivered_amount },
-    tx: { Fee, hash, inLedger, date, Account, Destination, Sequence },
-  }: BoilerplateOperation) => {
-    const type = Account === address ? "OUT" : "IN";
-    let value =
-      delivered_amount && typeof delivered_amount === "string"
-        ? new BigNumber(delivered_amount)
-        : new BigNumber(0);
-    const feeValue = new BigNumber(Fee);
-
-    if (type === "OUT") {
-      if (!Number.isNaN(feeValue)) {
-        value = value.plus(feeValue);
-      }
-    }
+  (txInfo: OperationInfo): Operation => {
+    const {
+      transaction_hash,
+      uid,
+      block: { height, hash },
+      senders,
+      recipients,
+      transaction_timestamp,
+      fee: { value: fee },
+      transfers: [{ value: transferValue }],
+    } = txInfo;
+
+    const type = senders.includes(address) ? "OUT" : "IN";
+    const value = new BigNumber(transferValue);
+    const feeValue = new BigNumber(fee);
 
     const op: Operation = {
-      id: encodeOperationId(accountId, hash, type),
-      hash: hash,
+      id: encodeOperationId(accountId, transaction_hash, type),
+      hash: transaction_hash,
       accountId,
       type,
       value,
       fee: feeValue,
-      blockHash: null,
-      blockHeight: inLedger,
-      senders: [Account],
-      recipients: [Destination],
-      date: new Date(),
-      transactionSequenceNumber: Sequence,
-      extra: {},
+      blockHash: hash,
+      blockHeight: height,
+      senders,
+      recipients,
+      date: new Date(transaction_timestamp),
+      transactionSequenceNumber: height,
+      extra: {
+        uid,
+      },
     };
 
     return op;
   };
 
 const filterOperations = (
-  transactions: BoilerplateOperation[],
+  transactions: OperationInfo[],
   accountId: string,
   address: string,
-) => {
+): Operation[] => {
   return transactions
-    .filter(
-      ({ tx, meta }: BoilerplateOperation) =>
-        tx.TransactionType === "Payment" && typeof meta.delivered_amount === "string",
-    )
-    .map(operationAdapter(accountId, address))
-    .filter((op): op is Operation => Boolean(op));
+    .filter(tx => tx.type === "Receive" || tx.type === "Send")
+    .map(txInfoToOperationAdapter(accountId, address));
 };
 
 export const getAccountShape: GetAccountShape = async info => {
   const { address, initialAccount, currency, derivationMode } = info;
+  // TODO: we need better solution ?
+  const xpubOrAddress = address?.replace(/:/g, "_") || "";
 
   const accountId = encodeAccountId({
     type: "js",
     version: "2",
     currencyId: currency.id,
-    xpubOrAddress: address,
-    derivationMode,
+    xpubOrAddress,
+    derivationMode: "",
   });
 
   // blockheight retrieval
   const blockHeight = await getLedgerEnd();
 
   // Account info retrieval + spendable balance calculation
-  const accountInfo = await getAccountInfo(address);
-  const balance = new BigNumber(accountInfo.account_data.Balance);
+  // const accountInfo = await getAccountInfo(address);
+  const balances = await getBalance(address);
+
+  const balanceData = balances.find(balance => balance.instrument_id === "canton_network") || {
+    instrument_id: "canton_network",
+    amount: 0,
+    locked: false,
+  };
+
+  const balance = new BigNumber(balanceData.amount);
   const reserveMin = coinConfig.getCoinConfig().minReserve || 0;
-  const spendableBalance = new BigNumber(accountInfo.account_data.Balance).minus(
-    BigNumber(reserveMin),
+  const lockedAmount = balanceData.locked ? balance : new BigNumber(0);
+  const spendableBalance = BigNumber.max(
+    0,
+    balance.minus(lockedAmount).minus(BigNumber(reserveMin)),
   );
 
   // Tx history fetching
   const oldOperations = initialAccount?.operations || [];
   const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-  const newTransactions = await getTransactions(address, {
-    from: startAt,
-    size: 100,
+  const transactionData = await getOperations(address, {
+    cursor: 0,
+    limit: 100,
   });
-  const newOperations = filterOperations(newTransactions, accountId, address);
-  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const newOperations = filterOperations(transactionData.operations, accountId, address);
+  const operations = mergeOps(oldOperations, newOperations);
 
   // We return the new account shape
   const shape = {
     id: accountId,
-    xpub: address,
+    xpub: xpubOrAddress,
     blockHeight,
     balance,
     spendableBalance,

package/src/bridge/updateTransaction.ts

@@ -8,10 +8,5 @@ import type { Transaction } from "../types";
 // NOTE: here is an example transaction updater function
 // in this case, it resets fee to null depending on the patch content
 export const updateTransaction: AccountBridge<Transaction>["updateTransaction"] = (tx, patch) => {
-  // eslint-disable-next-line no-constant-condition
-  if (patch.recipient === "boilerplate1" || true) {
-    patch = { ...patch, fee: null };
-  }
-
   return defaultUpdateTransaction(tx, patch);
 };