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

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,113 @@ 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);
+
+  // TODO change to balance.instrument_id === "Amulet" after update on backend
+  const balanceData = balances.find(balance => balance.instrument_id.includes("Amulet")) || {
+    instrument_id: "Amulet",
+    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: startAt,
+    limit: 100,
   });
-  const newOperations = filterOperations(newTransactions, accountId, address);
-  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const newOperations = filterOperations(
+    transactionData.operations,
+    accountId,
+    address.replace(/_/g, ":"),
+  );
+  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);
 };

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

@@ -1,12 +1,7 @@
 import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
-import { CreatedEvent, getTransactions, TxInfo } from "../../network/gateway";
+import { getOperations } from "../../network/gateway";
 import coinConfig from "../../config";
 
-const getNativeContractId = () =>
-  coinConfig.getCoinConfig().nativeInstrumentId !== undefined
-    ? coinConfig.getCoinConfig().nativeInstrumentId?.split(".")[0]
-    : "";
-
 /**
  * Returns list of operations associated to an account.
  * @param partyId Account partyId
@@ -18,37 +13,31 @@ export async function listOperations(
   partyId: string,
   page: Pagination,
 ): Promise<[Operation[], string]> {
-  const { transactions, next } = await getTransactions(partyId, {
+  const { operations, next } = await getOperations(partyId, {
     cursor: page.pagingToken !== undefined ? parseInt(page.pagingToken) : undefined,
     minOffset: page.minHeight,
     limit: page.limit,
   });
   const ops: Operation[] = [];
-  for (const tx of transactions) {
-    for (let i = 0; i < tx.events.length; i++) {
-      const event: CreatedEvent = tx.events[i]["CantonCreatedEvent"] as CreatedEvent;
-      if (event && event.template_id.module_name === "Splice.Amulet") {
-        ops.push({
-          id: tx.update_id + "-" + i,
-          type: event.signatories.includes(partyId) ? "OUT" : "IN",
-          value: BigInt(0), // to be finalized when details are available on backend
-          senders: event.signatories.includes(partyId) ? [partyId] : [],
-          recipients: event.signatories.includes(partyId) ? [] : [partyId],
-          asset:
-            event.contract_id === getNativeContractId()
-              ? { type: "native" }
-              : { type: "token", assetReference: event.contract_id },
-          tx: {
-            hash: tx.update_id,
-            fees: BigInt(0), // to be finalized when details are available on backend
-            date: new Date(tx.record_time.seconds),
-            block: {
-              height: tx.offset,
-              time: new Date(tx.effective_at.seconds),
-            },
+  for (const tx of operations) {
+    if (tx.type === "Send") {
+      ops.push({
+        id: tx.uid,
+        type: tx.senders.includes(partyId) ? "OUT" : "IN",
+        value: BigInt(tx.transfers[0].value),
+        senders: tx.senders,
+        recipients: tx.recipients,
+        asset: tx.asset,
+        tx: {
+          hash: tx.block.hash,
+          fees: BigInt(tx.fee.value),
+          date: new Date(tx.transaction_timestamp),
+          block: {
+            height: tx.block.height,
+            time: new Date(tx.block.time),
           },
-        });
-      }
+        },
+      });
     }
   }
   return [ops, next + ""];

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

@@ -8,7 +8,7 @@ jest.mock("../../network/gateway", () => ({
 
 const mockSerialized = JSON.stringify({
   serialized: "serialized-tx",
-  signature: "signature",
+  signature: "signature__PARTY__alice:123",
 });
 
 describe("broadcast", () => {
@@ -23,11 +23,11 @@ describe("broadcast", () => {
       useGateway: true,
     } as any);
 
-    (submit as jest.Mock).mockResolvedValue({ updateId: "my-update-id" });
+    (submit as jest.Mock).mockResolvedValue({ update_id: "my-update-id" });
 
     const result = await broadcast(mockSerialized);
 
-    expect(submit).toHaveBeenCalledWith("serialized-tx", "signature");
+    expect(submit).toHaveBeenCalledWith("alice:123", "serialized-tx", "signature");
     expect(result).toEqual("my-update-id");
   });
 

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

@@ -5,6 +5,7 @@ const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
 
 export async function broadcast(signedTx: string): Promise<string> {
   const parsed: { serialized: string; signature: string } = JSON.parse(signedTx);
-  if (useGateway()) return (await submit(parsed.serialized, parsed.signature)).updateId;
+  const [sig, party] = parsed.signature.split("__PARTY__");
+  if (useGateway()) return (await submit(party, parsed.serialized, sig)).update_id;
   else throw new Error("Not implemented");
 }

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

@@ -3,25 +3,15 @@ import { combine } from "./combine";
 describe("combine", () => {
   it("responds with a Stringify version of the payload to broadcast", () => {
     // GIVEN
-    const transaction = {
-      transaction: {
-        serialized: "SERIALIZED",
-        json: "JSON",
-        hash: "HASH",
-      },
-    };
+    const transaction = "0x000000001";
     const signature = "SIGNATURE";
 
     // WHEN
-    const result = combine(JSON.stringify(transaction), signature);
+    const result = combine(transaction, signature);
 
     // THEN
     expect(JSON.parse(result)).toEqual({
-      transaction: {
-        serialized: "SERIALIZED",
-        json: "JSON",
-        hash: "HASH",
-      },
+      serialized: "0x000000001",
       signature: "SIGNATURE",
     });
   });

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

@@ -1,9 +1,7 @@
 // Combines signature with raw transaction
-export function combine(transaction: string, signature: string): string {
-  const tx = JSON.parse(transaction);
-
+export function combine(serialized: string, signature: string): string {
   return JSON.stringify({
-    ...tx,
+    serialized,
     signature,
   });
 }

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

@@ -1,7 +1,5 @@
 import BigNumber from "bignumber.js";
-import { BoilerplateNativeTransaction } from "../../types";
-
-const encodeNativeTx = (nativeTx: BoilerplateNativeTransaction) => JSON.stringify(nativeTx);
+import { prepareTransferRequest, PrepareTransferResponse } from "../../network/gateway";
 
 export async function craftTransaction(
   account: {
@@ -12,25 +10,25 @@ export async function craftTransaction(
   transaction: {
     recipient?: string;
     amount: BigNumber;
-    fee?: BigNumber;
+    tokenId: string;
+    expireInSeconds: number;
   },
 ): Promise<{
-  nativeTransaction: BoilerplateNativeTransaction;
+  nativeTransaction: PrepareTransferResponse;
   serializedTransaction: string;
+  hash: string;
 }> {
-  const nativeTransaction: BoilerplateNativeTransaction = {
-    TransactionType: "Payment",
-    Account: account.address,
-    Amount: transaction.amount.toString(),
-    Destination: transaction.recipient || "",
-    Fee: transaction.fee?.toString() || "0",
-    Sequence: account.nextSequenceNumber || 0,
-  };
-
-  const serializedTransaction = encodeNativeTx(nativeTransaction);
+  const { serialized, json, hash } = await prepareTransferRequest(account.address, {
+    recipient: transaction.recipient || "",
+    amount: transaction.amount.toNumber(),
+    type: "token-transfer-request",
+    execute_before_secs: transaction.expireInSeconds,
+    instrument_id: transaction.tokenId,
+  });
 
   return {
-    nativeTransaction,
-    serializedTransaction,
+    nativeTransaction: json,
+    serializedTransaction: serialized,
+    hash,
   };
 }