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

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/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,23 @@ export async function craftTransaction(
   transaction: {
     recipient?: string;
     amount: BigNumber;
-    fee?: BigNumber;
+    tokenId: string;
+    expireInSeconds: number;
   },
 ): Promise<{
-  nativeTransaction: BoilerplateNativeTransaction;
+  nativeTransaction: PrepareTransferResponse;
   serializedTransaction: 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 } = 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,
   };
 }

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

@@ -1,15 +1,26 @@
 import coinConfig from "../config";
+import { generateMockKeyPair } from "../test/cantonTestUtils";
 import {
   getLedgerEnd,
   prepareOnboarding,
   getBalance,
-  getTransactions,
+  getOperations,
   getPartyById,
   getPartyByPubKey,
+  submitOnboarding,
+  prepareTapRequest,
+  submitTapRequest,
+  preparePreApprovalTransaction,
+  submitPreApprovalTransaction,
 } from "./gateway";
 
 describe("gateway (devnet)", () => {
-  beforeAll(() => {
+  let onboardedAccount: {
+    keyPair: ReturnType<typeof generateMockKeyPair>;
+    partyId: string;
+  } | null = null;
+
+  beforeAll(async () => {
     coinConfig.setCoinConfig(() => ({
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       useGateway: true,
@@ -18,18 +29,63 @@ describe("gateway (devnet)", () => {
         type: "active",
       },
     }));
-  });
+  }, 60000);
+
+  const getOnboardedAccount = () => {
+    if (!onboardedAccount) {
+      throw new Error("Shared onboarded account not available. Check beforeAll setup.");
+    }
+    return onboardedAccount;
+  };
 
   describe("prepareOnboarding", () => {
     it("should prepare onboarding", async () => {
-      const response = await prepareOnboarding(
-        "c59f7f29374d24506dd6490a5db472cf00958e195e146f3dc9c97f96d5c51097",
-        "ed25519",
-      );
+      // GIVEN
+      const keyPair = generateMockKeyPair();
+
+      // Save onboarded account for all tests that need a valid party ID
+      onboardedAccount = {
+        keyPair,
+        partyId: "", // set in next test
+      };
+
+      // WHEN
+      const response = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+
+      // THEN
       expect(response).toHaveProperty("party_id");
       expect(response).toHaveProperty("party_name");
       expect(response).toHaveProperty("public_key_fingerprint");
-      expect(response).toHaveProperty("topology_transactions_hash");
+      expect(response).toHaveProperty("transactions");
+      expect(response.transactions).toHaveProperty("combined_hash");
+      expect(response.party_name).toBe(keyPair.publicKeyHex);
+
+      expect(response.public_key_fingerprint).toBe(keyPair.fingerprint);
+    }, 30000);
+  });
+
+  describe("submitOnboarding", () => {
+    it("should submit onboarding with proper signature", async () => {
+      // GIVEN
+      const { keyPair } = getOnboardedAccount();
+      const prepareRequest = { public_key: keyPair.publicKeyHex, public_key_type: "ed25519" };
+      const prepareResponse = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+      const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
+
+      // WHEN
+      const response = await submitOnboarding(prepareRequest, prepareResponse, signature);
+
+      // Save onboarded account for all tests that need a valid party ID
+      onboardedAccount = {
+        keyPair,
+        partyId: response.party.party_id,
+      };
+
+      // THEN
+      expect(response).toHaveProperty("party");
+      expect(response.party).toHaveProperty("party_id");
+      expect(response.party).toHaveProperty("public_key");
+      expect(response.party.public_key).toBe(keyPair.publicKeyHex);
     }, 30000);
   });
 
@@ -42,12 +98,13 @@ describe("gateway (devnet)", () => {
 
   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);
+      const { partyId } = getOnboardedAccount();
+      const balance = await getBalance(partyId);
+      expect(balance.length).toBeGreaterThanOrEqual(0);
+      if (balance.length > 0) {
+        expect(balance[0].amount).toBeGreaterThanOrEqual(0);
+        expect(balance[0]).toHaveProperty("instrument_id");
+      }
     });
   });
 
@@ -67,12 +124,94 @@ describe("gateway (devnet)", () => {
     });
   });
 
-  describe("getTransactions", () => {
+  describe("getOperations", () => {
     it("should return user transactions", async () => {
-      const { transactions } = await getTransactions(
+      const { operations } = await getOperations(
         "party-5f29bb32e9939939::12202becd8062a1d170209956cfd977fca76fcb4d2a892d08c77a7483f35a11d6440",
       );
-      expect(transactions.length).toBeGreaterThanOrEqual(0);
+      expect(operations.length).toBeGreaterThanOrEqual(0);
     });
   });
+
+  describe("prepareTapRequest", () => {
+    it("should prepare tap request for onboarded party", async () => {
+      // GIVEN
+      const { partyId } = getOnboardedAccount();
+      const amount = 1000;
+
+      // WHEN
+      const response = await prepareTapRequest({ partyId, amount });
+
+      // THEN
+      expect(response).toHaveProperty("serialized");
+      expect(response).toHaveProperty("hash");
+      expect(typeof response.serialized).toBe("string");
+      expect(typeof response.hash).toBe("string");
+    }, 30000);
+  });
+
+  describe("submitTapRequest", () => {
+    it("should submit tap request with proper signature", async () => {
+      // GIVEN
+      const { keyPair, partyId } = getOnboardedAccount();
+      const tapPrepareResponse = await prepareTapRequest({
+        partyId,
+        amount: 1000,
+      });
+      const tapSignature = keyPair.sign(tapPrepareResponse.hash);
+
+      // WHEN
+      const response = await submitTapRequest({
+        partyId,
+        serialized: tapPrepareResponse.serialized,
+        signature: tapSignature,
+      });
+
+      // THEN
+      expect(response).toHaveProperty("submission_id");
+      expect(response).toHaveProperty("update_id");
+      expect(typeof response.submission_id).toBe("string");
+      expect(typeof response.update_id).toBe("string");
+    }, 30000);
+  });
+
+  describe("preparePreApprovalTransaction", () => {
+    it("should prepare pre-approval transaction for onboarded party", async () => {
+      // GIVEN
+      const { partyId } = getOnboardedAccount();
+
+      // WHEN
+      const response = await preparePreApprovalTransaction(partyId);
+
+      // THEN
+      expect(response).toHaveProperty("serialized");
+      expect(response).toHaveProperty("hash");
+      expect(typeof response.serialized).toBe("string");
+      expect(typeof response.hash).toBe("string");
+    }, 30000);
+  });
+
+  describe("submitPreApprovalTransaction", () => {
+    it("should submit pre-approval transaction with proper signature", async () => {
+      // GIVEN
+      const { keyPair, partyId } = getOnboardedAccount();
+      const preparedTransaction = await preparePreApprovalTransaction(partyId);
+      const preApprovalSignature = keyPair.sign(preparedTransaction.hash);
+
+      // WHEN
+      const response = await submitPreApprovalTransaction(
+        partyId,
+        preparedTransaction,
+        preApprovalSignature,
+      );
+
+      // THEN
+      expect(response).toHaveProperty("isApproved");
+      expect(response).toHaveProperty("submissionId");
+      expect(response).toHaveProperty("updateId");
+      expect(response.isApproved).toBe(true);
+      expect(typeof response.submissionId).toBe("string");
+      expect(typeof response.updateId).toBe("string");
+    }, 30000);
+  });
 });