@ledgerhq/coin-canton 0.7.0 → 0.8.0-nightly.1

package/src/bridge/sync.ts

@@ -1,11 +1,14 @@
 import BigNumber from "bignumber.js";
 import { Operation, OperationType } from "@ledgerhq/types-live";
-import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
-import { CantonAccount } from "../types";
 import coinConfig from "../config";
+import resolver from "../signer";
+import { CantonAccount, CantonSigner } from "../types";
+import { isAccountOnboarded, isAccountAuthorized } from "./onboard";
 
 const txInfoToOperationAdapter =
   (accountId: string, partyId: string) =>
@@ -30,7 +33,6 @@ const txInfoToOperationAdapter =
     } else if (txInfo.type === "Initialize") {
       type = "PRE_APPROVAL";
     }
-
     const value = new BigNumber(transferValue);
     const feeValue = new BigNumber(fee);
     const memo = details.metadata.reason;
@@ -65,76 +67,92 @@ const filterOperations = (
   return transactions.map(txInfoToOperationAdapter(accountId, partyId));
 };
 
-export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
-  const { address, initialAccount, currency, derivationMode, derivationPath, rest } = info;
-
-  const xpubOrAddress = (
-    (initialAccount?.id && decodeAccountId(initialAccount.id).xpubOrAddress) ||
-    ""
-  ).replace(/:/g, "_");
-  const partyId =
-    rest?.cantonResources?.partyId ||
-    initialAccount?.cantonResources?.partyId ||
-    xpubOrAddress.replace(/_/g, ":");
-
-  const accountId = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress,
-    derivationMode,
-  });
-
-  // Account info retrieval + spendable balance calculation
-  // const accountInfo = await getAccountInfo(address);
-  const balances = await getBalance(currency, partyId);
-
-  const balanceData = balances.find(
-    balance => balance.instrument_id === coinConfig.getCoinConfig(currency).nativeInstrumentId,
-  ) || {
-    instrument_id: coinConfig.getCoinConfig(currency).nativeInstrumentId,
-    amount: 0,
-    locked: false,
-  };
+export function makeGetAccountShape(
+  signerContext: SignerContext<CantonSigner>,
+): GetAccountShape<CantonAccount> {
+  return async info => {
+    const { address, currency, derivationMode, derivationPath, initialAccount } = info;
+
+    let xpubOrAddress = initialAccount?.xpub || "";
+
+    if (!xpubOrAddress) {
+      const getAddress = resolver(signerContext);
+      const { publicKey } = await getAddress(info.deviceId || "", {
+        path: derivationPath,
+        currency: currency,
+        derivationMode: derivationMode,
+        verify: false,
+      });
+
+      const { isOnboarded, partyId } = await isAccountOnboarded(currency, publicKey);
+      if (isOnboarded && partyId) {
+        xpubOrAddress = partyId;
+      }
+    }
 
-  const balance = new BigNumber(balanceData.amount);
-  const reserveMin = coinConfig.getCoinConfig(currency).minReserve || 0;
-  const lockedAmount = balanceData.locked ? balance : new BigNumber(0);
-  const spendableBalance = BigNumber.max(
-    0,
-    balance.minus(lockedAmount).minus(BigNumber(reserveMin)),
-  );
-
-  let operations: Operation[] = [];
-  // Tx history fetching if xpubOrAddress is not empty
-  if (xpubOrAddress) {
-    const oldOperations = initialAccount?.operations || [];
-    const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-    const transactionData = await getOperations(currency, partyId, {
-      cursor: startAt,
-      limit: 100,
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: xpubOrAddress,
+      derivationMode,
     });
 
-    const newOperations = filterOperations(transactionData.operations, accountId, partyId);
-    operations = mergeOps(oldOperations, newOperations);
-  }
-  // blockheight retrieval
-  const blockHeight = await getLedgerEnd(currency);
-  // We return the new account shape
-  const shape = {
-    id: accountId,
-    xpub: xpubOrAddress,
-    blockHeight,
-    balance,
-    spendableBalance,
-    operations,
-    operationsCount: operations.length,
-    freshAddress: address,
-    freshAddressPath: derivationPath,
-    cantonResources: {
-      partyId,
-    },
-  };
+    const { nativeInstrumentId } = coinConfig.getCoinConfig(currency);
+    const balances = xpubOrAddress ? await getBalance(currency, xpubOrAddress) : [];
 
-  return shape;
-};
+    const balancesData = (balances || []).reduce(
+      (acc, { amount, instrument_id, locked }) => {
+        acc[instrument_id] = { amount, locked };
+        return acc;
+      },
+      {} as Record<string, { amount: string; locked: boolean }>,
+    );
+
+    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.amount || "0");
+    const lockedAmount = new BigNumber(balancesData[`Locked${nativeInstrumentId}`]?.amount || "0");
+    const totalBalance = unlockedAmount.plus(lockedAmount);
+    const reserveMin = new BigNumber(coinConfig.getCoinConfig(currency).minReserve || 0);
+    const spendableBalance = BigNumber.max(0, unlockedAmount.minus(reserveMin));
+
+    let operations: Operation[] = [];
+    if (xpubOrAddress) {
+      const oldOperations = initialAccount?.operations || [];
+      const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+      const transactionData = await getOperations(currency, xpubOrAddress, {
+        cursor: startAt,
+        limit: 100,
+      });
+      const newOperations = filterOperations(transactionData.operations, accountId, xpubOrAddress);
+      operations = mergeOps(oldOperations, newOperations);
+    }
+
+    const isAuthorized = await isAccountAuthorized(operations, xpubOrAddress);
+    const used = isAuthorized && totalBalance.gt(0);
+
+    const blockHeight = await getLedgerEnd(currency);
+
+    const creationDate =
+      operations.length > 0
+        ? new Date(Math.min(...operations.map(op => op.date.getTime())))
+        : new Date();
+
+    const shape = {
+      id: accountId,
+      type: "Account" as const,
+      balance: totalBalance,
+      blockHeight,
+      creationDate,
+      lastSyncDate: new Date(),
+      freshAddress: address,
+      seedIdentifier: address,
+      operations,
+      operationsCount: operations.length,
+      spendableBalance,
+      xpub: xpubOrAddress,
+      used,
+    };
+
+    return shape;
+  };
+}

package/src/common-logic/utils.test.ts

@@ -0,0 +1,108 @@
+import { isRecipientValid, validateTag } from "./utils";
+import BigNumber from "bignumber.js";
+
+describe("utils", () => {
+  describe("isRecipientValid", () => {
+    it("should return true for valid Canton addresses", () => {
+      const validAddresses = [
+        "abc::123",
+        "hello::1",
+        "test123::456",
+        "a::0",
+        "party::999",
+        "user123::42",
+        "canton_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z::123",
+        "test::123456789",
+        "abc::abc", // letters after ::
+        "test::ABC123", // mixed case letters and numbers
+        "user::a1b2c3", // alphanumeric after ::
+        "contract::XyZ789", // mixed case with numbers
+      ];
+
+      validAddresses.forEach(address => {
+        expect(isRecipientValid(address)).toBe(true);
+      });
+    });
+
+    it("should return false for invalid Canton addresses", () => {
+      const invalidAddresses = [
+        "", // empty string
+        "::123", // no characters before ::
+        "abc::", // no characters after ::
+        "abc:123", // single colon instead of double
+        "abc::", // empty after ::
+        "::", // only colons
+        "abc", // no colons
+        "123", // no colons
+        "abc::123.456", // decimal numbers
+        "abc::-123", // negative numbers
+        "abc::+123", // positive sign
+        "abc:: 123", // space before alphanumeric
+        "abc::123 ", // space after alphanumeric
+        "abc:: 123", // space after ::
+        "abc::123-abc", // dash in alphanumeric part
+        "abc::123_abc", // underscore in alphanumeric part
+        "abc::123.abc", // dot in alphanumeric part
+        "abc::123 abc", // space in alphanumeric part
+        "abc::", // empty after ::
+      ];
+
+      invalidAddresses.forEach(address => {
+        expect(isRecipientValid(address)).toBe(false);
+      });
+    });
+
+    it("should handle edge cases", () => {
+      expect(isRecipientValid("a::1")).toBe(true); // minimum valid case with number
+      expect(isRecipientValid("a::a")).toBe(true); // minimum valid case with letter
+      expect(isRecipientValid("1::1")).toBe(true); // number before ::
+      expect(isRecipientValid("1::a")).toBe(true); // number before ::, letter after
+      expect(isRecipientValid("_::1")).toBe(true); // underscore before ::
+      expect(isRecipientValid("_::a")).toBe(true); // underscore before ::, letter after
+      expect(isRecipientValid("-::1")).toBe(true); // dash before ::
+      expect(isRecipientValid("-::a")).toBe(true); // dash before ::, letter after
+      expect(isRecipientValid(".::1")).toBe(true); // dot before ::
+      expect(isRecipientValid(".::a")).toBe(true); // dot before ::, letter after
+    });
+
+    it("should handle addresses with spaces and multiple colons", () => {
+      // These are valid according to our regex but might not be ideal Canton addresses
+      expect(isRecipientValid(" abc::123")).toBe(true); // space before address
+      expect(isRecipientValid(" abc::abc")).toBe(true); // space before address with letters
+      expect(isRecipientValid("abc ::123")).toBe(true); // space before ::
+      expect(isRecipientValid("abc ::abc")).toBe(true); // space before :: with letters
+      expect(isRecipientValid("abc::123::456")).toBe(true); // multiple ::
+      expect(isRecipientValid("abc::abc::def")).toBe(true); // multiple :: with letters
+    });
+  });
+
+  describe("validateTag", () => {
+    it("should return true for valid tags", () => {
+      const validTags = [
+        new BigNumber(1),
+        new BigNumber(42),
+        new BigNumber(4294967295), // UINT32_MAX
+        new BigNumber(0),
+      ];
+
+      validTags.forEach(tag => {
+        expect(validateTag(tag)).toBe(true);
+      });
+    });
+
+    it("should return false for invalid tags", () => {
+      const invalidTags = [
+        new BigNumber(-1), // negative
+        new BigNumber(4294967296), // greater than UINT32_MAX
+        new BigNumber(1.5), // decimal
+        new BigNumber(NaN), // NaN
+        new BigNumber(Infinity), // Infinity
+        new BigNumber(-Infinity), // -Infinity
+      ];
+
+      invalidTags.forEach(tag => {
+        expect(validateTag(tag)).toBe(false);
+      });
+    });
+  });
+});

package/src/common-logic/utils.ts

@@ -8,6 +8,9 @@ export const validateTag = (tag: BigNumber) => {
   );
 };
 
+const CANTON_ADDRESS_REGEX = /^.+::[a-zA-Z0-9]+$/;
+
 export function isRecipientValid(recipient: string): boolean {
-  return recipient.length > 0;
+  // Canton address format: at least 1 character :: at least 1 alphanumeric character
+  return CANTON_ADDRESS_REGEX.test(recipient);
 }

package/src/config.ts

@@ -7,7 +7,7 @@ export type CantonConfig = {
   gatewayUrl?: string;
   // TODELETE
   minReserve?: number;
-  networkType: "mainnet" | "devnet" | "localnet";
+  networkType: "mainnet" | "devnet" | "testnet" | "localnet";
   useGateway?: boolean;
   nativeInstrumentId: string;
   fee?: number;

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

@@ -12,6 +12,7 @@ import {
   submitTapRequest,
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
+  type OnboardingPrepareResponse,
 } from "./gateway";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
@@ -25,6 +26,8 @@ describe("gateway (devnet)", () => {
     partyId: string;
   } | null = null;
 
+  let prepareResponse: OnboardingPrepareResponse | null = null;
+
   beforeAll(async () => {
     coinConfig.setCoinConfig(() => ({
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
@@ -35,7 +38,7 @@ describe("gateway (devnet)", () => {
         type: "active",
       },
     }));
-  }, 60000);
+  });
 
   const getOnboardedAccount = () => {
     if (!onboardedAccount) {
@@ -56,7 +59,7 @@ describe("gateway (devnet)", () => {
       };
 
       // WHEN
-      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex, "ed25519");
+      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex);
 
       // THEN
       expect(response).toHaveProperty("party_id");
@@ -68,30 +71,26 @@ describe("gateway (devnet)", () => {
       expect(typeof response.party_name).toBe("string");
 
       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(
-        mockCurrency,
-        keyPair.publicKeyHex,
-        "ed25519",
-      );
+      // Save prepare response for next test
+      prepareResponse = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex);
       const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
 
       // WHEN
       const response = await submitOnboarding(
         mockCurrency,
-        prepareRequest,
+        keyPair.publicKeyHex,
         prepareResponse,
         signature,
       );
 
-      // Save onboarded account for all tests that need a valid party ID
+      // Save onboarded account for next tests that need a valid party ID
       onboardedAccount = {
         keyPair,
         partyId: response.party.party_id,
@@ -103,6 +102,31 @@ describe("gateway (devnet)", () => {
       expect(response.party).toHaveProperty("public_key");
       expect(response.party.public_key).toBe(keyPair.publicKeyHex);
     }, 30000);
+
+    const testIfPrepared = prepareResponse ? it.skip : it;
+    testIfPrepared(
+      "should not throw when already onboarded",
+      async () => {
+        // GIVEN
+        const { keyPair } = getOnboardedAccount();
+        const signature = keyPair.sign(prepareResponse!.transactions.combined_hash);
+
+        // WHEN
+        const response = await submitOnboarding(
+          mockCurrency,
+          keyPair.publicKeyHex,
+          prepareResponse!,
+          signature,
+        );
+
+        // 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,
+    );
   });
 
   describe("getLedgerEnd", () => {
@@ -125,17 +149,20 @@ describe("gateway (devnet)", () => {
   });
 
   describe("getPartyById", () => {
-    it.skip("should return party info", async () => {
-      const party = await getPartyById(mockCurrency, "4f2e1485107adf5f");
+    it("should return party info", async () => {
+      const party = await getPartyById(
+        mockCurrency,
+        "ldg::12208b12fa34be8a079bcbb68bba828e58313046c4208855b39885fab48661322e68",
+      );
       expect(party).toBeDefined();
     });
   });
 
   describe("getPartyByPubKey", () => {
-    it.skip("should return party info", async () => {
+    it("should return party info", async () => {
       const party = await getPartyByPubKey(
         mockCurrency,
-        "122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
+        "c5cdb19624833f9a929a0125978c886ec4297320c14cea6bf667dc1d23a8e650",
       );
       expect(party).toBeDefined();
     });
@@ -153,7 +180,7 @@ describe("gateway (devnet)", () => {
   });
 
   describe("prepareTapRequest", () => {
-    it("should prepare tap request for onboarded party", async () => {
+    it.skip("should prepare tap request for onboarded party", async () => {
       // GIVEN
       const { partyId } = getOnboardedAccount();
       const amount = 1000;
@@ -166,11 +193,11 @@ describe("gateway (devnet)", () => {
       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 () => {
+    it.skip("should submit tap request with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
       const tapPrepareResponse = await prepareTapRequest(mockCurrency, {
@@ -191,7 +218,7 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("update_id");
       expect(typeof response.submission_id).toBe("string");
       expect(typeof response.update_id).toBe("string");
-    }, 30000);
+    });
   });
 
   describe("preparePreApprovalTransaction", () => {
@@ -207,7 +234,7 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("hash");
       expect(typeof response.serialized).toBe("string");
       expect(typeof response.hash).toBe("string");
-    }, 30000);
+    });
   });
 
   describe("submitPreApprovalTransaction", () => {
@@ -232,6 +259,6 @@ describe("gateway (devnet)", () => {
       expect(response.isApproved).toBe(true);
       expect(typeof response.submissionId).toBe("string");
       expect(typeof response.updateId).toBe("string");
-    }, 30000);
+    });
   });
 });

package/src/network/gateway.test.ts

@@ -0,0 +1,66 @@
+import { getBalance, type GetBalanceResponse, type InstrumentBalance } from "./gateway";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import coinConfig from "../config";
+
+jest.mock("@ledgerhq/live-network", () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+import network from "@ledgerhq/live-network";
+
+const mockBalances: InstrumentBalance[] = [
+  {
+    instrument_id: "Amulet",
+    amount: "10000000000000000000000000000000000000000",
+    locked: false,
+  },
+  {
+    instrument_id: "LockedAmulet",
+    amount: "5000000000000000000000000000000000000000",
+    locked: true,
+  },
+];
+
+describe("getBalance", () => {
+  const mockCurrency = {
+    id: "canton_network",
+  } as unknown as CryptoCurrency;
+
+  const mockNetwork = network as jest.MockedFunction<typeof network>;
+
+  beforeAll(() => {
+    coinConfig.setCoinConfig(() => ({
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
+      useGateway: true,
+      networkType: "devnet",
+      nativeInstrumentId: "Amulet",
+      status: {
+        type: "active",
+      },
+    }));
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return an array of balances (backwards compatibility)", async () => {
+    mockNetwork.mockResolvedValue({ data: mockBalances, status: 200 });
+    const result = await getBalance(mockCurrency, "test-party-id");
+
+    expect(result).toEqual(mockBalances);
+  });
+
+  it("should return and object with balances property", async () => {
+    const mockResponse: GetBalanceResponse = {
+      at_round: 123,
+      balances: mockBalances,
+    };
+
+    mockNetwork.mockResolvedValue({ data: mockResponse, status: 200 });
+    const result = await getBalance(mockCurrency, "test-party-id");
+
+    expect(result).toEqual(mockResponse.balances);
+  });
+});