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

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);
+  });
 });

package/src/network/gateway.ts

@@ -1,11 +1,37 @@
 import network from "@ledgerhq/live-network";
+import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
+import {
+  PrepareTransactionRequest,
+  PrepareTransactionResponse,
+  SubmitTransactionRequest,
+  SubmitTransactionResponse,
+  PreApprovalResult,
+} from "../types/onboard";
 
 type OnboardingPrepareResponse = {
   party_id: string;
   party_name: string;
   public_key_fingerprint: string;
-  topology_transactions_hash: string;
+  transactions: {
+    namespace_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    party_to_key_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    party_to_participant_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    combined_hash: string;
+  };
 };
 
 type OnboardingPrepareRequest = {
@@ -13,6 +39,31 @@ type OnboardingPrepareRequest = {
   public_key_type: string;
 };
 
+export type PrepareTransferResponse = {
+  hash: string;
+  json: any; // The actual structure is complex, using any for now
+  serialized: string;
+};
+
+export type PrepareTransferRequest = {
+  type: "token-transfer-request";
+  amount: number;
+  recipient: string;
+  execute_before_secs: number;
+  instrument_id: string;
+  reason?: string;
+};
+
+export type PrepareTapRequest = {
+  type: "tap-request";
+  amount: number;
+};
+
+export type PreparePreapprovalRequest = {
+  type: "transfer-pre-approval-proposal";
+  receiver: string;
+};
+
 type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
@@ -31,7 +82,7 @@ type TransactionSubmitRequest = {
   signature: string;
 };
 
-type TransactionSubmitResponse = { updateId: string };
+type TransactionSubmitResponse = { update_id: string };
 
 export type InstrumentBalance = {
   instrument_id: string;
@@ -63,6 +114,9 @@ export type CreatedEvent = BaseEvent & {
   };
   signatories: string[];
   observers: string[];
+  details: {
+    createArguments: { fields: unknown[] };
+  };
 };
 
 type ExercisedEvent = BaseEvent & {
@@ -90,21 +144,165 @@ export type TxInfo = {
   trace_context: string;
 };
 
+export type OperationInfo =
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Initialize";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Initialize";
+          value: string;
+          asset: string;
+          details: {
+            type: "pre-approval";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "token";
+        issuer: string;
+      };
+      details: {
+        type: "pre-approval";
+      };
+    }
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Receive";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Receive";
+          value: string;
+          asset: string;
+          details: {
+            type: "tap";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "native";
+        issuer: null;
+      };
+      details: {
+        type: "tap";
+      };
+    }
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Send";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Send";
+          value: string;
+          asset: string;
+          details: {
+            type: "transfer";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "native";
+        issuer: null;
+      };
+      details: {
+        type: "transfer";
+      };
+    };
+
 const getGatewayUrl = () => coinConfig.getCoinConfig().gatewayUrl;
-const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-live-devnet-prd";
+const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-devnet-stg";
+
+const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
+  const API_KEY = getEnv("CANTON_API_KEY");
+  return network<T, U>({
+    ...req,
+    headers: {
+      ...(req.headers || {}),
+      ...(API_KEY && { "X-Ledger-Canton-Api-Key": API_KEY }),
+    },
+  });
+};
 
 export async function prepareOnboarding(
   pubKey: string,
   pubKeyType: string,
 ): Promise<OnboardingPrepareResponse> {
-  const { data } = await network<OnboardingPrepareResponse>({
+  const gatewayUrl = getGatewayUrl();
+  const nodeId = getNodeId();
+  const fullUrl = `${gatewayUrl}/v1/node/${nodeId}/onboarding/prepare`;
+
+  const { data } = await gatewayNetwork<OnboardingPrepareResponse, OnboardingPrepareRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/prepare`,
+    url: fullUrl,
     data: {
       public_key: pubKey,
       public_key_type: pubKeyType,
-    } satisfies OnboardingPrepareRequest,
+    },
   });
+
   return data;
 }
 
@@ -113,58 +311,56 @@ export async function submitOnboarding(
   prepareResponse: OnboardingPrepareResponse,
   signature: string,
 ) {
-  const { data } = await network<OnboardingSubmitResponse>({
+  const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
     method: "POST",
     url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/submit`,
     data: {
       prepare_request: prepareRequest,
       prepare_response: prepareResponse,
       signature,
-    } satisfies OnboardingSubmitRequest,
+    },
   });
   return data;
 }
 
-export async function submit(serializedTx: string, signature: string) {
-  const { data } = await network<TransactionSubmitResponse>({
+export async function submit(partyId: string, serialized: string, signature: string) {
+  const { data } = await gatewayNetwork<TransactionSubmitResponse, TransactionSubmitRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/transaction/submit`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
     data: {
-      serialized: serializedTx,
+      serialized,
       signature,
-    } satisfies TransactionSubmitRequest,
+    },
   });
   return data;
 }
 
 export async function getBalance(partyId: string): Promise<InstrumentBalance[]> {
-  const { data } = await network<InstrumentBalance[]>({
+  const { data } = await gatewayNetwork<InstrumentBalance[]>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/balance`,
+    // TODO: we need better solution ?
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/balance`,
   });
   return data;
 }
 
 export async function getPartyById(partyId: string): Promise<PartyInfo> {
-  return await getParty(partyId, "ID");
+  return await getParty(partyId, "party-id");
 }
 
 export async function getPartyByPubKey(pubKey: string): Promise<PartyInfo> {
-  return await getParty(pubKey, "PK");
+  return await getParty(pubKey, "public-key");
 }
 
-async function getParty(identifier: string, by: "ID" | "PK"): Promise<PartyInfo> {
-  const { data } = await network<PartyInfo>({
+async function getParty(identifier: string, by: "party-id" | "public-key"): Promise<PartyInfo> {
+  const { data } = await gatewayNetwork<PartyInfo>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}`,
-    data: {
-      by,
-    },
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}?by=${by}`,
   });
   return data;
 }
 
-export async function getTransactions(
+export async function getOperations(
   partyId: string,
   options?: {
     cursor?: number | undefined;
@@ -174,23 +370,134 @@ export async function getTransactions(
   },
 ): Promise<{
   next: number;
-  transactions: TxInfo[];
+  operations: OperationInfo[];
 }> {
-  const { data } = await network<{
+  const { data } = await gatewayNetwork<{
     next: number;
-    transactions: TxInfo[];
+    operations: OperationInfo[];
   }>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transactions`,
-    data: options,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/operations`,
+    params: options,
+  });
+  return data;
+}
+
+type PrepareTapRequestRequest = {
+  partyId: string;
+  amount?: number;
+};
+
+type PrepareTapRequestResponse = {
+  serialized: "string";
+  json: null;
+  hash: "string";
+};
+
+enum TransactionType {
+  TAP_REQUEST = "tap-request",
+  TRANSFER_PRE_APPROVAL_PROPOSAL = "transfer-pre-approval-proposal",
+}
+
+export async function prepareTapRequest({
+  partyId,
+  amount = 1000000,
+}: PrepareTapRequestRequest): Promise<PrepareTapRequestResponse> {
+  const { data } = await gatewayNetwork<
+    PrepareTapRequestResponse,
+    { amount: number; type: string }
+  >({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: {
+      amount: parseInt(amount.toString(), 10), // Convert to integer to avoid scientific notation
+      type: TransactionType.TAP_REQUEST,
+    },
+  });
+  return data;
+}
+
+type SubmitTapRequestRequest = {
+  partyId: string;
+  serialized: string;
+  signature: string;
+};
+
+type SubmitTapRequestResponse = {
+  submission_id: string;
+  update_id: string;
+};
+
+export async function submitTapRequest({
+  partyId,
+  serialized,
+  signature,
+}: SubmitTapRequestRequest): Promise<SubmitTapRequestResponse> {
+  const { data } = await gatewayNetwork<
+    SubmitTapRequestResponse,
+    Omit<SubmitTapRequestRequest, "partyId">
+  >({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    data: {
+      serialized,
+      signature,
+    },
+  });
+  return data;
+}
+
+export async function prepareTransferRequest(
+  partyId: string,
+  params: PrepareTransferRequest,
+): Promise<PrepareTransferResponse> {
+  const { data } = await network<PrepareTransferResponse>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: params,
   });
   return data;
 }
 
 export async function getLedgerEnd(): Promise<number> {
-  const { data } = await network<number>({
+  const { data } = await gatewayNetwork<number>({
     method: "GET",
     url: `${getGatewayUrl()}/v1/node/${getNodeId()}/ledger-end`,
   });
   return data;
 }
+
+export async function preparePreApprovalTransaction(
+  partyId: string,
+): Promise<PrepareTransactionResponse> {
+  const { data } = await gatewayNetwork<PrepareTransactionResponse, PrepareTransactionRequest>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: {
+      type: TransactionType.TRANSFER_PRE_APPROVAL_PROPOSAL,
+      receiver: partyId,
+    },
+  });
+  return data;
+}
+
+export async function submitPreApprovalTransaction(
+  partyId: string,
+  { serialized }: PrepareTransactionResponse,
+  signature: string,
+): Promise<PreApprovalResult> {
+  const { data } = await gatewayNetwork<SubmitTransactionResponse, SubmitTransactionRequest>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    data: {
+      serialized,
+      signature,
+    },
+  });
+
+  return {
+    isApproved: true,
+    submissionId: data.submission_id,
+    updateId: data.update_id,
+  };
+}