@ledgerhq/coin-canton 0.10.0 → 0.11.0-nightly.20251126023856

package/src/helpers.test.ts

@@ -0,0 +1,361 @@
+import BigNumber from "bignumber.js";
+import { TokenAccount } from "@ledgerhq/types-live";
+import { isAccountEmpty } from "./helpers";
+import { CantonAccount } from "./types";
+import { createMockAccount } from "./test/fixtures";
+
+describe("isAccountEmpty", () => {
+  const createCantonAccount = (overrides: Partial<CantonAccount> = {}): CantonAccount => {
+    const baseAccount = createMockAccount(overrides);
+    return {
+      ...baseAccount,
+      cantonResources: {
+        instrumentUtxoCounts: {},
+        pendingTransferProposals: [],
+        ...overrides.cantonResources,
+      },
+    };
+  };
+
+  describe("when account is not of type Account", () => {
+    it("should return false for TokenAccount", () => {
+      const tokenAccount: TokenAccount = {
+        type: "TokenAccount",
+        id: "token-account-id",
+        parentId: "parent-account-id",
+        token: {
+          type: "TokenCurrency",
+          id: "token-id",
+          contractAddress: "0x123",
+          name: "Test Token",
+          ticker: "TEST",
+          decimals: 18,
+          parentCurrency: {
+            id: "ethereum",
+            type: "CryptoCurrency",
+            name: "Ethereum",
+            ticker: "ETH",
+            family: "evm",
+            units: [],
+            explorerViews: [],
+          },
+        },
+        balance: new BigNumber(0),
+        spendableBalance: new BigNumber(0),
+        operationsCount: 0,
+        operations: [],
+        pendingOperations: [],
+        balanceHistoryCache: {
+          HOUR: { latestDate: null, balances: [] },
+          DAY: { latestDate: null, balances: [] },
+          WEEK: { latestDate: null, balances: [] },
+        },
+        swapHistory: [],
+        creationDate: new Date(),
+        balanceHistory: [],
+      };
+
+      expect(isAccountEmpty(tokenAccount)).toBe(false);
+    });
+  });
+
+  describe("when account is not a Canton account", () => {
+    it("should return false for non-Canton account", () => {
+      const nonCantonAccount = createMockAccount({
+        currency: {
+          ...createMockAccount().currency,
+          family: "ethereum",
+        },
+      });
+
+      expect(isAccountEmpty(nonCantonAccount)).toBe(false);
+    });
+  });
+
+  describe("when account is a Canton account", () => {
+    it("should return true for empty account (zero operations, zero balance, no subAccounts, no pending proposals)", () => {
+      const emptyAccount = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(emptyAccount)).toBe(true);
+    });
+
+    it("should return false when account has operations", () => {
+      const accountWithOperations = createCantonAccount({
+        operationsCount: 1,
+        balance: new BigNumber(0),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithOperations)).toBe(false);
+    });
+
+    it("should return false when account has non-zero balance", () => {
+      const accountWithBalance = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(100),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithBalance)).toBe(false);
+    });
+
+    it("should return false when account has subAccounts", () => {
+      const accountWithSubAccounts = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: [
+          {
+            type: "TokenAccount",
+            id: "token-account-id",
+            parentId: "parent-id",
+            token: {
+              type: "TokenCurrency",
+              id: "token-id",
+              contractAddress: "0x123",
+              name: "Test Token",
+              ticker: "TEST",
+              decimals: 18,
+              parentCurrency: createMockAccount().currency,
+            },
+            balance: new BigNumber(0),
+            spendableBalance: new BigNumber(0),
+            operationsCount: 0,
+            operations: [],
+            pendingOperations: [],
+            balanceHistoryCache: {
+              HOUR: { latestDate: null, balances: [] },
+              DAY: { latestDate: null, balances: [] },
+              WEEK: { latestDate: null, balances: [] },
+            },
+            swapHistory: [],
+            creationDate: new Date(),
+            balanceHistory: [],
+          },
+        ],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithSubAccounts)).toBe(false);
+    });
+
+    it("should return false when account has pending transfer proposals", () => {
+      const accountWithPendingProposals = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [
+            {
+              contract_id: "contract-123",
+              sender: "sender-address",
+              receiver: "receiver-address",
+              instrument_id: "instrument-123",
+              amount: "100",
+              memo: "test memo",
+              expires_at_micros: Date.now() * 1000 + 86400000000,
+            },
+          ],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithPendingProposals)).toBe(false);
+    });
+
+    it("should return false when account has operations and balance", () => {
+      const accountWithBoth = createCantonAccount({
+        operationsCount: 5,
+        balance: new BigNumber(1000),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithBoth)).toBe(false);
+    });
+
+    it("should return false when account has operations and subAccounts", () => {
+      const accountWithOperationsAndSubAccounts = createCantonAccount({
+        operationsCount: 2,
+        balance: new BigNumber(0),
+        subAccounts: [
+          {
+            type: "TokenAccount",
+            id: "token-account-id",
+            parentId: "parent-id",
+            token: {
+              type: "TokenCurrency",
+              id: "token-id",
+              contractAddress: "0x123",
+              name: "Test Token",
+              ticker: "TEST",
+              decimals: 18,
+              parentCurrency: createMockAccount().currency,
+            },
+            balance: new BigNumber(0),
+            spendableBalance: new BigNumber(0),
+            operationsCount: 0,
+            operations: [],
+            pendingOperations: [],
+            balanceHistoryCache: {
+              HOUR: { latestDate: null, balances: [] },
+              DAY: { latestDate: null, balances: [] },
+              WEEK: { latestDate: null, balances: [] },
+            },
+            swapHistory: [],
+            creationDate: new Date(),
+            balanceHistory: [],
+          },
+        ],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithOperationsAndSubAccounts)).toBe(false);
+    });
+
+    it("should return false when account has balance and pending proposals", () => {
+      const accountWithBalanceAndProposals = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(500),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [
+            {
+              contract_id: "contract-456",
+              sender: "sender-address",
+              receiver: "receiver-address",
+              instrument_id: "instrument-456",
+              amount: "50",
+              memo: "test memo",
+              expires_at_micros: Date.now() * 1000 + 86400000000, // 1 day from now
+            },
+          ],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithBalanceAndProposals)).toBe(false);
+    });
+
+    it("should return false when account has all non-empty indicators", () => {
+      const fullyUsedAccount = createCantonAccount({
+        operationsCount: 10,
+        balance: new BigNumber(10000),
+        subAccounts: [
+          {
+            type: "TokenAccount",
+            id: "token-account-id",
+            parentId: "parent-id",
+            token: {
+              type: "TokenCurrency",
+              id: "token-id",
+              contractAddress: "0x123",
+              name: "Test Token",
+              ticker: "TEST",
+              decimals: 18,
+              parentCurrency: createMockAccount().currency,
+            },
+            balance: new BigNumber(100),
+            spendableBalance: new BigNumber(100),
+            operationsCount: 5,
+            operations: [],
+            pendingOperations: [],
+            balanceHistoryCache: {
+              HOUR: { latestDate: null, balances: [] },
+              DAY: { latestDate: null, balances: [] },
+              WEEK: { latestDate: null, balances: [] },
+            },
+            swapHistory: [],
+            creationDate: new Date(),
+            balanceHistory: [],
+          },
+        ],
+        cantonResources: {
+          instrumentUtxoCounts: {
+            "instrument-1": 5,
+            "instrument-2": 3,
+          },
+          pendingTransferProposals: [
+            {
+              contract_id: "contract-789",
+              sender: "sender-address",
+              receiver: "receiver-address",
+              instrument_id: "instrument-789",
+              amount: "200",
+              memo: "test memo",
+              expires_at_micros: Date.now() * 1000 + 86400000000, // 1 day from now
+            },
+          ],
+        },
+      });
+
+      expect(isAccountEmpty(fullyUsedAccount)).toBe(false);
+    });
+
+    it("should handle undefined subAccounts", () => {
+      const accountWithUndefinedSubAccounts = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: undefined,
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithUndefinedSubAccounts)).toBe(true);
+    });
+
+    it("should handle empty subAccounts array", () => {
+      const accountWithEmptySubAccounts = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithEmptySubAccounts)).toBe(true);
+    });
+
+    it("should handle empty pendingTransferProposals array", () => {
+      const accountWithEmptyProposals = createCantonAccount({
+        operationsCount: 0,
+        balance: new BigNumber(0),
+        subAccounts: [],
+        cantonResources: {
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      });
+
+      expect(isAccountEmpty(accountWithEmptyProposals)).toBe(true);
+    });
+  });
+});

package/src/helpers.ts

@@ -0,0 +1,31 @@
+import type { AccountLike } from "@ledgerhq/types-live";
+import { isCantonAccount } from "./bridge/serialization";
+import { CantonAccount } from "./types";
+
+export function isCantonAccountEmpty(
+  account: Pick<CantonAccount, "operationsCount" | "balance" | "subAccounts" | "cantonResources">,
+): boolean {
+  return (
+    account.operationsCount === 0 &&
+    account.balance.isZero() &&
+    !account.subAccounts?.length &&
+    !account.cantonResources?.pendingTransferProposals?.length
+  );
+}
+
+/**
+ * Check if a Canton account is empty (has no operations, no balance, and no pending transfer proposals)
+ * @param account - The account to check (must be a Canton account)
+ * @returns true if the account is empty, false otherwise
+ */
+export function isAccountEmpty(account: AccountLike): boolean {
+  if (account.type !== "Account") {
+    return false;
+  }
+
+  if (!isCantonAccount(account)) {
+    return false;
+  }
+
+  return isCantonAccountEmpty(account);
+}

package/src/index.ts

@@ -2,3 +2,5 @@ export * from "./types";
 
 export { createBridges } from "./bridge/index";
 export type { CantonCoinConfig } from "./config";
+export { isAccountEmpty } from "./helpers";
+export { isCantonAccount } from "./bridge/serialization";

package/src/network/gateway.ts

@@ -58,6 +58,25 @@ export type PrepareTransferRequest = {
   reason?: string;
 };
 
+export type PrepareTransferInstructionRequest = {
+  type:
+    | "accept-transfer-instruction"
+    | "reject-transfer-instruction"
+    | "withdraw-transfer-instruction";
+  contract_id: string;
+  reason?: string;
+};
+
+export type TransferProposal = {
+  contract_id: string;
+  sender: string;
+  receiver: string;
+  amount: string;
+  instrument_id: string;
+  memo: string;
+  expires_at_micros: number;
+};
+
 type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
@@ -380,6 +399,22 @@ export async function submit(
   return data;
 }
 
+export async function prepare(
+  currency: CryptoCurrency,
+  partyId: string,
+  params: PrepareTransferRequest | PrepareTransferInstructionRequest,
+) {
+  const { data } = await gatewayNetwork<
+    PrepareTransferResponse,
+    PrepareTransferRequest | PrepareTransferInstructionRequest
+  >({
+    method: "POST",
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
+    data: params,
+  });
+  return data;
+}
+
 export async function getBalance(currency: CryptoCurrency, partyId: string) {
   const { data } = await gatewayNetwork<GetBalanceResponse>({
     method: "GET",
@@ -502,13 +537,15 @@ export async function prepareTransferRequest(
   partyId: string,
   params: PrepareTransferRequest,
 ) {
-  const { data } = await gatewayNetwork<PrepareTransferResponse, PrepareTransferRequest>({
-    method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
-    data: params,
-  });
+  return prepare(currency, partyId, params);
+}
 
-  return data;
+export async function prepareTransferInstruction(
+  currency: CryptoCurrency,
+  partyId: string,
+  params: PrepareTransferInstructionRequest,
+) {
+  return prepare(currency, partyId, params);
 }
 
 export async function getLedgerEnd(currency: CryptoCurrency): Promise<number> {
@@ -553,6 +590,15 @@ export async function submitPreApprovalTransaction(
   } satisfies PreApprovalResult;
 }
 
+export async function submitTransferInstruction(
+  currency: CryptoCurrency,
+  partyId: string,
+  serialized: string,
+  signature: string,
+) {
+  return submit(currency, partyId, serialized, signature);
+}
+
 type GetTransferPreApprovalResponse = {
   contract_id: string;
   receiver: string;
@@ -569,3 +615,11 @@ export async function getTransferPreApproval(currency: CryptoCurrency, partyId:
   });
   return data;
 }
+
+export async function getPendingTransferProposals(currency: CryptoCurrency, partyId: string) {
+  const { data } = await gatewayNetwork<TransferProposal[]>({
+    method: "GET",
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transfer-proposals?timestamp=${Date.now()}`,
+  });
+  return data;
+}

package/src/types/bridge.ts

@@ -16,6 +16,7 @@ import type {
   CantonAuthorizeProgress,
   CantonAuthorizeResult,
 } from "./onboard";
+import type { TransferProposal } from "../network/gateway";
 
 export interface CantonCurrencyBridge extends CurrencyBridge {
   onboardAccount: (
@@ -29,6 +30,18 @@ export interface CantonCurrencyBridge extends CurrencyBridge {
     creatableAccount: Account,
     partyId: string,
   ) => Observable<CantonAuthorizeProgress | CantonAuthorizeResult>;
+  transferInstruction: (
+    currency: CryptoCurrency,
+    deviceId: string,
+    account: Account,
+    partyId: string,
+    contractId: string,
+    type:
+      | "accept-transfer-instruction"
+      | "reject-transfer-instruction"
+      | "withdraw-transfer-instruction",
+    reason?: string,
+  ) => Promise<void>;
 }
 
 export type NetworkInfo = {
@@ -64,9 +77,11 @@ export type TransactionStatusRaw = TransactionStatusCommonRaw;
 
 export type CantonResources = {
   instrumentUtxoCounts: Record<string, number>;
+  pendingTransferProposals: TransferProposal[];
 };
 export type CantonResourcesRaw = {
   instrumentUtxoCounts: Record<string, number>;
+  pendingTransferProposals: TransferProposal[];
 };
 
 export type CantonAccount = Account & {