@ledgerhq/coin-canton 0.4.0 → 0.4.1-nightly.0

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

@@ -1,64 +1,55 @@
 import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
-import { getTransactions } from "../../network/indexer";
-import { BoilerplateOperation } from "../../network/types";
+import { CreatedEvent, getTransactions, TxInfo } 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 address Account address
+ * @param partyId Account partyId
  * @param pagination Pagination options
  * @returns Operations found and the next "id" or "index" to use for pagination (i.e. `start` property).\
- * If `0` is returns, no pagination needed.
- * This "id" or "index" value, thus it has functional meaning, is different for each blockchain.
+ * Impl to finalize when backend is ready
  */
 export async function listOperations(
-  address: string,
+  partyId: string,
   page: Pagination,
 ): Promise<[Operation[], string]> {
-  const transactions = await getTransactions(address, { from: page.minHeight });
-  return [transactions.map(convertToCoreOperation(address)), ""];
-}
-
-const convertToCoreOperation =
-  (address: string) =>
-  (operation: BoilerplateOperation): Operation => {
-    const {
-      meta: { delivered_amount },
-      tx: { Fee, hash, inLedger, date, Account, Destination },
-    } = operation;
-
-    const type = Account === address ? "OUT" : "IN";
-    let value =
-      delivered_amount && typeof delivered_amount === "string"
-        ? BigInt(delivered_amount)
-        : BigInt(0);
-
-    const feeValue = BigInt(Fee);
-    if (type === "OUT") {
-      if (!Number.isNaN(feeValue)) {
-        value = value + feeValue;
+  const { transactions, next } = await getTransactions(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),
+            },
+          },
+        });
       }
     }
-
-    return {
-      /**
-       * Note: The operation ID must be concatenated with another
-       * value if the transaction hash is not enough to identify it
-       */
-      id: hash,
-      asset: { type: "native" },
-      tx: {
-        hash,
-        fees: feeValue,
-        date: new Date(date),
-        block: {
-          height: inLedger,
-          hash,
-          time: new Date(date),
-        },
-      },
-      type,
-      value,
-      senders: [Account],
-      recipients: [Destination],
-    };
-  };
+  }
+  return [ops, next + ""];
+}

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

@@ -0,0 +1,42 @@
+import { submit } from "../../network/gateway";
+import * as coinConfigModule from "../../config";
+import { broadcast } from "./broadcast";
+
+jest.mock("../../network/gateway", () => ({
+  submit: jest.fn(),
+}));
+
+const mockSerialized = JSON.stringify({
+  serialized: "serialized-tx",
+  signature: "signature",
+});
+
+describe("broadcast", () => {
+  const mockGetCoinConfig = jest.spyOn(coinConfigModule.default, "getCoinConfig");
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should broadcast", async () => {
+    mockGetCoinConfig.mockReturnValue({
+      useGateway: true,
+    } as any);
+
+    (submit as jest.Mock).mockResolvedValue({ updateId: "my-update-id" });
+
+    const result = await broadcast(mockSerialized);
+
+    expect(submit).toHaveBeenCalledWith("serialized-tx", "signature");
+    expect(result).toEqual("my-update-id");
+  });
+
+  it("should throw an error when useGateway is false (not implemented with node)", async () => {
+    mockGetCoinConfig.mockReturnValue({
+      useGateway: false,
+    } as any);
+
+    await expect(broadcast(mockSerialized)).rejects.toThrow("Not implemented");
+    expect(submit).not.toHaveBeenCalled();
+  });
+});

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

@@ -1,6 +1,10 @@
-import { submit } from "../../network/node";
+import coinConfig from "../../config";
+import { submit } from "../../network/gateway";
+
+const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
 
 export async function broadcast(signedTx: string): Promise<string> {
-  const submittedPayment = await submit(signedTx);
-  return submittedPayment.tx_hash;
+  const parsed: { serialized: string; signature: string } = JSON.parse(signedTx);
+  if (useGateway()) return (await submit(parsed.serialized, parsed.signature)).updateId;
+  else throw new Error("Not implemented");
 }

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

@@ -0,0 +1,28 @@
+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 signature = "SIGNATURE";
+
+    // WHEN
+    const result = combine(JSON.stringify(transaction), signature);
+
+    // THEN
+    expect(JSON.parse(result)).toEqual({
+      transaction: {
+        serialized: "SERIALIZED",
+        json: "JSON",
+        hash: "HASH",
+      },
+      signature: "SIGNATURE",
+    });
+  });
+});

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

@@ -1,6 +1,9 @@
-import { encode } from "../utils";
-
 // Combines signature with raw transaction
-export function combine(transaction: string, signature: string, publicKey?: string): string {
-  return encode(transaction, signature, publicKey || "");
+export function combine(transaction: string, signature: string): string {
+  const tx = JSON.parse(transaction);
+
+  return JSON.stringify({
+    ...tx,
+    signature,
+  });
 }

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

@@ -1,16 +1,4 @@
-import { simulate } from "../../network/node";
-import { SimulationError } from "../../types/errors";
-
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function estimateFees(serializedTransaction: string): Promise<bigint> {
-  try {
-    // We call the node to do a dry run and estimate fees
-    return BigInt(await simulate(serializedTransaction));
-  } catch (e) {
-    // default value is required in case of simulation error, else user will encounter an error in the flow
-    if (e instanceof SimulationError) {
-      return BigInt(1000);
-    } else {
-      throw new Error("Unexpected error while estimating fees.");
-    }
-  }
+  return Promise.resolve(BigInt(10_000)); // TODO replace with real implementation
 }

package/src/common-logic/utils.ts

@@ -11,8 +11,3 @@ export const validateTag = (tag: BigNumber) => {
 export function isRecipientValid(recipient: string): boolean {
   return recipient.length > 0;
 }
-
-export const encode = (transaction: string, signature: string, publicKey?: string) => {
-  // sample encoding
-  return `${transaction}${publicKey}${signature}encodedTx`;
-};

package/src/config.ts

@@ -1,16 +1,22 @@
-import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+import buildCoinConfig, { CoinConfig, type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export type CantonConfig = {
   nodeUrl?: string;
+  nodeId?: string;
   gatewayUrl?: string;
   // TODELETE
   minReserve?: number;
   networkType: "mainnet" | "devnet" | "localnet";
   useGateway?: boolean;
+  nativeInstrumentId?: string;
 };
 
 export type CantonCoinConfig = CurrencyConfig & CantonConfig;
 
-const coinConfig = buildCoinConfig<CantonCoinConfig>();
+const coinConfig: {
+  setCoinConfig: (config: CoinConfig<CantonCoinConfig>) => void;
+  getCoinConfig: (currency?: CryptoCurrency) => CantonCoinConfig;
+} = buildCoinConfig<CantonCoinConfig>();
 
 export default coinConfig;

package/src/network/gateway.integ.test.ts

@@ -1,32 +1,78 @@
 import coinConfig from "../config";
-import { getLedgerEnd, prepareOnboarding } from "./gateway";
+import {
+  getLedgerEnd,
+  prepareOnboarding,
+  getBalance,
+  getTransactions,
+  getPartyById,
+  getPartyByPubKey,
+} from "./gateway";
 
 describe("gateway (devnet)", () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
+      useGateway: true,
       networkType: "devnet",
       status: {
         type: "active",
       },
     }));
   });
+
   describe("prepareOnboarding", () => {
     it("should prepare onboarding", async () => {
       const response = await prepareOnboarding(
-        "0x043b462de34ec31fba274f2a381947aef26697912194312fc289c46cc1b2b4f6b00828dc1e4f96001b10463083edf85f2e0550862a3dc99ed411ca6d25f2bc19a8",
+        "c59f7f29374d24506dd6490a5db472cf00958e195e146f3dc9c97f96d5c51097",
         "ed25519",
       );
       expect(response).toHaveProperty("party_id");
       expect(response).toHaveProperty("party_name");
       expect(response).toHaveProperty("public_key_fingerprint");
       expect(response).toHaveProperty("topology_transactions_hash");
-    });
+    }, 30000);
   });
+
   describe("getLedgerEnd", () => {
     it("should return ledger end", async () => {
       const end = await getLedgerEnd();
       expect(end).toBeGreaterThanOrEqual(0);
     });
   });
+
+  describe("getBalance", () => {
+    it("should return user balance", async () => {
+      const balance = await getBalance(
+        "party-4f2e1485107adf5f::122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
+      );
+      expect(balance.length).toBeGreaterThanOrEqual(1);
+      expect(balance[0].amount).toBeGreaterThanOrEqual(0);
+      expect(balance[0].instrument_id.includes("Splice")).toBe(true);
+    });
+  });
+
+  describe("getPartyById", () => {
+    it.skip("should return party info", async () => {
+      const party = await getPartyById("4f2e1485107adf5f");
+      expect(party).toBeDefined();
+    });
+  });
+
+  describe("getPartyByPubKey", () => {
+    it.skip("should return party info", async () => {
+      const party = await getPartyByPubKey(
+        "122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
+      );
+      expect(party).toBeDefined();
+    });
+  });
+
+  describe("getTransactions", () => {
+    it("should return user transactions", async () => {
+      const { transactions } = await getTransactions(
+        "party-5f29bb32e9939939::12202becd8062a1d170209956cfd977fca76fcb4d2a892d08c77a7483f35a11d6440",
+      );
+      expect(transactions.length).toBeGreaterThanOrEqual(0);
+    });
+  });
 });

package/src/network/gateway.ts

@@ -26,8 +26,15 @@ type OnboardingSubmitResponse = {
   };
 };
 
-type InstrumentBalance = {
-  instrumentId: string;
+type TransactionSubmitRequest = {
+  serialized: string;
+  signature: string;
+};
+
+type TransactionSubmitResponse = { updateId: string };
+
+export type InstrumentBalance = {
+  instrument_id: string;
   amount: number;
   locked: boolean;
 };
@@ -44,46 +51,47 @@ type Timestamp = {
 
 type BaseEvent = {
   type: string;
-  contractId: string;
+  contract_id: string;
   details: string;
 };
 
-type CreatedEvent = BaseEvent & {
-  templateId: {
-    packageId: string;
-    moduleName: string;
-    entityName: string;
+export type CreatedEvent = BaseEvent & {
+  template_id: {
+    package_id: string;
+    module_name: string;
+    entity_name: string;
   };
   signatories: string[];
   observers: string[];
 };
 
 type ExercisedEvent = BaseEvent & {
-  templateId: {
+  template_id: {
     packageId: string;
     moduleName: string;
     entityName: string;
   };
   choice: string;
   consuming: boolean;
-  actingParties: string[];
+  acting_parties: string[];
 };
 
 type Event = BaseEvent | CreatedEvent | ExercisedEvent;
 
-type TxInfo = {
-  updateId: string;
-  commandId: string;
-  workflowId: string;
-  effectiveAt: Timestamp;
+export type TxInfo = {
+  update_id: string;
+  command_id: string;
+  workflow_id: string;
+  effective_at: Timestamp;
   offset: number;
-  synchronizerId: string;
-  recordTime: Timestamp;
-  events: Event[];
-  traceContext: string;
+  synchronizer_id: string;
+  record_time: Timestamp;
+  events: Record<string, Event>[];
+  trace_context: string;
 };
 
 const getGatewayUrl = () => coinConfig.getCoinConfig().gatewayUrl;
+const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-live-devnet-prd";
 
 export async function prepareOnboarding(
   pubKey: string,
@@ -91,7 +99,7 @@ export async function prepareOnboarding(
 ): Promise<OnboardingPrepareResponse> {
   const { data } = await network<OnboardingPrepareResponse>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/0/onboarding/prepare`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/prepare`,
     data: {
       public_key: pubKey,
       public_key_type: pubKeyType,
@@ -107,7 +115,7 @@ export async function submitOnboarding(
 ) {
   const { data } = await network<OnboardingSubmitResponse>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/0/onboarding/submit`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/submit`,
     data: {
       prepare_request: prepareRequest,
       prepare_response: prepareResponse,
@@ -117,23 +125,54 @@ export async function submitOnboarding(
   return data;
 }
 
+export async function submit(serializedTx: string, signature: string) {
+  const { data } = await network<TransactionSubmitResponse>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/transaction/submit`,
+    data: {
+      serialized: serializedTx,
+      signature,
+    } satisfies TransactionSubmitRequest,
+  });
+  return data;
+}
+
 export async function getBalance(partyId: string): Promise<InstrumentBalance[]> {
   const { data } = await network<InstrumentBalance[]>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/0/party/${partyId}/balance`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/balance`,
   });
   return data;
 }
 
-export async function getParty(partyId: string): Promise<PartyInfo> {
+export async function getPartyById(partyId: string): Promise<PartyInfo> {
+  return await getParty(partyId, "ID");
+}
+
+export async function getPartyByPubKey(pubKey: string): Promise<PartyInfo> {
+  return await getParty(pubKey, "PK");
+}
+
+async function getParty(identifier: string, by: "ID" | "PK"): Promise<PartyInfo> {
   const { data } = await network<PartyInfo>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/0/party/${partyId}`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}`,
+    data: {
+      by,
+    },
   });
   return data;
 }
 
-export async function getTransactions(partyId: string): Promise<{
+export async function getTransactions(
+  partyId: string,
+  options?: {
+    cursor?: number | undefined;
+    minOffset?: number | undefined;
+    maxOffset?: number | undefined;
+    limit?: number | undefined;
+  },
+): Promise<{
   next: number;
   transactions: TxInfo[];
 }> {
@@ -142,7 +181,8 @@ export async function getTransactions(partyId: string): Promise<{
     transactions: TxInfo[];
   }>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/0/party/${partyId}/transactions`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transactions`,
+    data: options,
   });
   return data;
 }
@@ -150,7 +190,7 @@ export async function getTransactions(partyId: string): Promise<{
 export async function getLedgerEnd(): Promise<number> {
   const { data } = await network<number>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/0/ledger-end`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/ledger-end`,
   });
   return data;
 }

package/src/network/node.integ.test.ts

@@ -1,7 +1,8 @@
 import coinConfig from "../config";
 import { getLedgerEnd } from "./node";
 
-describe("Node (localnet)", () => {
+// enable manually, as it requires a running node locally
+describe.skip("Node (localnet)", () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
       gatewayUrl: "http://gateway.url",
@@ -19,7 +20,8 @@ describe("Node (localnet)", () => {
   });
 });
 
-describe("Node (devnet)", () => {
+// enable manually, as it requires an auth token in env variable
+describe.skip("Node (devnet)", () => {
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
       nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com/v2",

package/src/types/bridge.ts

@@ -1,5 +1,4 @@
 import type { BigNumber } from "bignumber.js";
-import type { Unit } from "@ledgerhq/types-cryptoassets";
 import type {
   TransactionCommon,
   TransactionCommonRaw,