@ledgerhq/coin-canton 0.5.0-nightly.5 → 0.5.0

package/src/api/getBalance.integ.test.ts

@@ -3,14 +3,15 @@ import { createApi } from ".";
 
 let api: AlpacaApi;
 
-describe.skip("devnet", () => {
+describe("devnet", () => {
   beforeAll(() => {
     api = createApi({
       nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com/v2",
       networkType: "devnet",
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       useGateway: true,
-      nativeInstrumentId: "Amulet",
+      nativeInstrumentId:
+        "6e9fc50fb94e56751b49f09ba2dc84da53a9d7cff08115ebb4f6b7a12d0c990c:Splice.Amulet:Amulet",
     });
   });
 
@@ -19,13 +20,9 @@ describe.skip("devnet", () => {
       const balance = await api.getBalance(
         "party-4f2e1485107adf5f::122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
       );
-      expect(balance.length).toBeGreaterThanOrEqual(0);
-      if (balance.length > 0) {
-        const nativeBalance = balance.find(b => b.asset.type === "native");
-        if (nativeBalance) {
-          expect(nativeBalance.value).toBeGreaterThanOrEqual(BigInt(0));
-        }
-      }
+      expect(balance.length).toBeGreaterThanOrEqual(1);
+      const nativeBalance = balance.find(b => b.asset.type === "native");
+      expect(nativeBalance?.value).toBeGreaterThanOrEqual(0);
     });
   });
 });

package/src/api/index.ts

@@ -2,42 +2,38 @@ import {
   AlpacaApi,
   Block,
   BlockInfo,
+  CraftedTransaction,
   Cursor,
   FeeEstimation,
   Page,
   Reward,
   Stake,
   TransactionIntent,
-  Operation,
-  Balance,
-  Pagination,
 } from "@ledgerhq/coin-framework/api/index";
 import coinConfig, { type CantonConfig } from "../config";
-import { combine } from "../common-logic/transaction/combine";
+import {
+  broadcast,
+  combine,
+  craftTransaction,
+  estimateFees,
+  getBalance,
+  getNextValidSequence,
+  lastBlock,
+  listOperations,
+} from "../common-logic";
+import BigNumber from "bignumber.js";
 
 export function createApi(config: CantonConfig): AlpacaApi {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
 
   return {
-    broadcast: (_tx: string): Promise<string> => {
-      throw new Error("broadcast is not supported");
-    },
+    broadcast,
     combine,
-    craftTransaction(_transactionIntent: TransactionIntent, _customFees?: FeeEstimation) {
-      throw new Error("craftTransaction is not supported");
-    },
-    estimateFees(_transactionIntent: TransactionIntent): Promise<FeeEstimation> {
-      throw new Error("estimateFees is not supported");
-    },
-    getBalance(_address: string): Promise<Balance[]> {
-      throw new Error("getBalance is not supported");
-    },
-    lastBlock(): Promise<BlockInfo> {
-      throw new Error("listOperations is not supported");
-    },
-    listOperations(_address: string, _pagination: Pagination): Promise<[Operation[], string]> {
-      throw new Error("listOperations is not supported");
-    },
+    craftTransaction: craft,
+    estimateFees: estimate,
+    getBalance,
+    lastBlock,
+    listOperations,
     getBlock(_height): Promise<Block> {
       throw new Error("getBlock is not supported");
     },
@@ -52,3 +48,29 @@ export function createApi(config: CantonConfig): AlpacaApi {
     },
   };
 }
+
+async function craft(transactionIntent: TransactionIntent): Promise<CraftedTransaction> {
+  const nextSequenceNumber = await getNextValidSequence(transactionIntent.sender);
+  const tx = await craftTransaction(
+    { address: transactionIntent.sender, nextSequenceNumber },
+    {
+      recipient: transactionIntent.recipient,
+      amount: new BigNumber(transactionIntent.amount.toString()),
+    },
+  );
+  return { transaction: tx.serializedTransaction };
+}
+
+async function estimate(transactionIntent: TransactionIntent): Promise<FeeEstimation> {
+  const { serializedTransaction } = await craftTransaction(
+    { address: transactionIntent.sender },
+    {
+      recipient: transactionIntent.recipient,
+      amount: new BigNumber(transactionIntent.amount.toString()),
+    },
+  );
+
+  const value = await estimateFees(serializedTransaction);
+
+  return { value };
+}

package/src/api/lastBlock.integ.test.ts

@@ -20,7 +20,7 @@ describe.skip("localnet", () => {
   });
 });
 
-describe.skip("devnet", () => {
+describe("devnet", () => {
   beforeAll(() => {
     api = createApi({
       nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com/v2",

package/src/api/listOperations.integ.test.ts

@@ -3,7 +3,7 @@ import { createApi } from ".";
 
 let api: AlpacaApi;
 
-describe.skip("devnet", () => {
+describe("devnet", () => {
   beforeAll(() => {
     api = createApi({
       nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com/v2",

package/src/bridge/broadcast.test.ts

@@ -4,11 +4,6 @@ jest.mock("@ledgerhq/coin-framework/operation");
 jest.mock("../common-logic");
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
 import { broadcast as broadcastLogic } from "../common-logic";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-const mockCurrency = {
-  id: "canton_network",
-} as unknown as CryptoCurrency;
 
 describe("broadcast", () => {
   let patchOperationSpy: jest.SpyInstance;
@@ -21,9 +16,6 @@ describe("broadcast", () => {
 
   it("should broadcast", () => {
     broadcast({
-      account: {
-        currency: mockCurrency,
-      },
       signedOperation: {
         signature: undefined,
         operation: undefined,
@@ -34,9 +26,6 @@ describe("broadcast", () => {
 
   it("should patch operation with hash", () => {
     broadcast({
-      account: {
-        currency: mockCurrency,
-      },
       signedOperation: {
         signature: undefined,
         operation: undefined,

package/src/bridge/broadcast.ts

@@ -4,10 +4,8 @@ import { broadcast as broadcastLogic } from "../common-logic";
 import { Transaction } from "../types";
 
 export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
-  account,
-  signedOperation,
+  signedOperation: { signature, operation },
 }) => {
-  const { operation, signature } = signedOperation;
-  const hash = await broadcastLogic(account.currency, signature);
+  const hash = await broadcastLogic(signature);
   return patchOperationWithHash(operation, hash);
 };

package/src/bridge/createTransaction.ts

@@ -8,7 +8,7 @@ export const createTransaction: AccountBridge<Transaction>["createTransaction"]
   amount: new BigNumber(0),
   recipient: "",
   fee: null,
-  memo: "",
+  memo: undefined,
   networkInfo: null,
   feeCustomUnit: null,
 });

package/src/bridge/getTransactionStatus.ts

@@ -25,7 +25,7 @@ export const getTransactionStatus: AccountBridge<
   const warnings: Record<string, Error> = {};
 
   // reserveAmount is the minimum amount of currency that an account must hold in order to stay activated
-  const reserveAmount = new BigNumber(coinConfig.getCoinConfig(account.currency).minReserve || 0);
+  const reserveAmount = new BigNumber(coinConfig.getCoinConfig().minReserve || 0);
   const estimatedFees = new BigNumber(transaction.fee || 0);
   const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
   const amount = new BigNumber(transaction.amount);

package/src/bridge/index.ts

@@ -21,7 +21,6 @@ import { buildSignOperation } from "./signOperation";
 import { getAccountShape } from "./sync";
 import { updateTransaction } from "./updateTransaction";
 import { buildOnboardAccount, buildAuthorizePreapproval } from "./onboard";
-import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
 
 export function createBridges(
   signerContext: SignerContext<CantonSigner>,
@@ -63,8 +62,6 @@ export function createBridges(
     sync,
     receive,
     signOperation,
-    assignToAccountRaw,
-    assignFromAccountRaw,
     getSerializedAddressParameters,
   };
 

package/src/bridge/onboard.integ.test.ts

@@ -10,14 +10,10 @@ import {
   CantonPreApprovalResult,
 } from "../types/onboard";
 import coinConfig from "../config";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-describe("onboard (devnet)", () => {
+describe("onboard integration tests", () => {
   const mockDeviceId = "test-device-id";
   const mockDerivationPath = "44'/6767'/0'/0'/0'";
-  const mockCurrency = {
-    id: "canton_network",
-  } as unknown as CryptoCurrency;
 
   let onboardedAccount: {
     keyPair: ReturnType<typeof generateMockKeyPair>;
@@ -57,7 +53,7 @@ describe("onboard (devnet)", () => {
 
       const onboardObservable = buildOnboardAccount(mockSignerContext);
       const onboardValues = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        onboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
       );
       const onboardResult = onboardValues.find(
         (value): value is CantonOnboardResult => "partyId" in value,
@@ -76,7 +72,7 @@ describe("onboard (devnet)", () => {
       };
 
       // WHEN
-      const result = await isAccountOnboarded(mockCurrency, keyPair.publicKeyHex);
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
 
       // THEN
       expect(result).not.toBe(false);
@@ -91,10 +87,10 @@ describe("onboard (devnet)", () => {
       const keyPair = generateMockKeyPair();
 
       // WHEN
-      const result = await isAccountOnboarded(mockCurrency, keyPair.publicKeyHex);
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
 
       // THEN
-      expect(result).toEqual({ isOnboarded: false });
+      expect(result).toBe(false);
     }, 15000);
 
     it("should handle errors gracefully when checking non-existent party", async () => {
@@ -102,10 +98,10 @@ describe("onboard (devnet)", () => {
       const keyPair = generateMockKeyPair();
 
       // WHEN
-      const result = await isAccountOnboarded(mockCurrency, keyPair.publicKeyHex);
+      const result = await isAccountOnboarded(keyPair.publicKeyHex);
 
       // THEN
-      expect(result).toEqual({ isOnboarded: false });
+      expect(result).toBe(false);
     }, 15000);
   });
 
@@ -121,7 +117,7 @@ describe("onboard (devnet)", () => {
 
       // WHEN
       const allValues = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        onboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
       );
       const progressValues = allValues.filter(
         (value): value is CantonOnboardProgress => "status" in value && !("partyId" in value),
@@ -153,7 +149,7 @@ describe("onboard (devnet)", () => {
 
       // WHEN
       const secondOnboardValues = await firstValueFrom(
-        secondOnboardObservable(mockCurrency, mockDeviceId, mockDerivationPath).pipe(toArray()),
+        secondOnboardObservable(mockDeviceId, mockDerivationPath).pipe(toArray()),
       );
       const secondResult = secondOnboardValues.find(
         (value): value is CantonOnboardResult => "partyId" in value,
@@ -174,12 +170,9 @@ describe("onboard (devnet)", () => {
 
       // WHEN
       const preapprovalValues = await firstValueFrom(
-        preapprovalObservable(
-          mockCurrency,
-          mockDeviceId,
-          mockDerivationPath,
-          onboardResult.partyId,
-        ).pipe(toArray()),
+        preapprovalObservable(mockDeviceId, mockDerivationPath, onboardResult.partyId).pipe(
+          toArray(),
+        ),
       );
 
       const progressValues = preapprovalValues.filter(
@@ -215,12 +208,7 @@ describe("onboard (devnet)", () => {
       // WHEN & THEN
       try {
         await firstValueFrom(
-          preapprovalObservable(
-            mockCurrency,
-            mockDeviceId,
-            mockDerivationPath,
-            "invalid-party-id-123",
-          ),
+          preapprovalObservable(mockDeviceId, mockDerivationPath, "invalid-party-id-123"),
         );
         expect(true).toBe(true);
       } catch (error) {

package/src/bridge/onboard.ts

@@ -1,10 +1,6 @@
 import { Observable } from "rxjs";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
-import { getDerivationModesForCurrency } from "@ledgerhq/coin-framework/derivation";
-import { getAccountShape } from "./sync";
-import { CantonAccount, CantonSigner } from "../types";
-import type { Account, DerivationMode } from "@ledgerhq/types-live";
+import { CantonSigner } from "../types/signer";
 import {
   prepareOnboarding,
   submitOnboarding,
@@ -23,10 +19,8 @@ import {
   CantonPreApprovalResult,
   PrepareTransactionResponse,
 } from "../types/onboard";
-import resolver from "../signer";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-async function _getKeypair(
+async function getKeypair(
   signerContext: SignerContext<CantonSigner>,
   deviceId: string,
   derivationPath: string,
@@ -38,27 +32,25 @@ async function _getKeypair(
 }
 
 export const isAccountOnboarded = async (
-  currency: CryptoCurrency,
   publicKey: string,
-): Promise<{ isOnboarded: boolean; party_id?: string }> => {
+): Promise<false | { party_id: string }> => {
   try {
-    const { party_id } = await getPartyByPubKey(currency, publicKey);
+    const { party_id } = await getPartyByPubKey(publicKey);
 
     if (party_id) {
-      return { isOnboarded: true, party_id };
+      return { party_id };
     } else {
-      return { isOnboarded: false };
+      return false;
     }
   } catch (err) {
     log("[isAccountOnboarded] Error checking party status (likely not onboarded):", err);
-    return { isOnboarded: false };
+    return false;
   }
 };
 
 export const buildOnboardAccount =
   (signerContext: SignerContext<CantonSigner>) =>
   (
-    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
   ): Observable<CantonOnboardProgress | CantonOnboardResult> =>
@@ -67,36 +59,22 @@ export const buildOnboardAccount =
         observer.next({
           status: OnboardStatus.INIT,
         });
-        const derivationMode = getDerivationModesForCurrency(currency)[0];
-        const getAddress = resolver(signerContext);
-        const { address, publicKey } = await getAddress(deviceId, {
-          path: derivationPath,
-          currency,
-          derivationMode: derivationMode || "",
-        });
+        const keypair = await getKeypair(signerContext, deviceId, derivationPath);
 
         observer.next({
           status: OnboardStatus.PREPARE,
         });
 
-        const { party_id: partyId } = await isAccountOnboarded(currency, publicKey);
-        if (partyId) {
-          const account = await createAccount({
-            address,
-            derivationPath,
-            partyId,
-            currency,
-            derivationMode,
-          });
+        const isOnboardedResult = await isAccountOnboarded(keypair.publicKey);
+        if (isOnboardedResult && isOnboardedResult.party_id) {
           observer.next({
-            partyId,
-            account,
+            partyId: isOnboardedResult.party_id,
           });
           observer.complete();
           return;
         }
 
-        const preparedTransaction = await prepareOnboarding(currency, publicKey, "ed25519");
+        const preparedTransaction = await prepareOnboarding(keypair.publicKey, "ed25519");
 
         observer.next({
           status: OnboardStatus.SIGN,
@@ -111,44 +89,26 @@ export const buildOnboardAccount =
         });
 
         const result = await submitOnboarding(
-          currency,
-          { public_key: publicKey, public_key_type: "ed25519" },
+          { public_key: keypair.publicKey, public_key_type: "ed25519" },
           preparedTransaction,
           signature,
-        ).catch(async err => {
+        ).catch(err => {
           if (err.type === "PARTY_ALREADY_EXISTS") {
-            const account = await createAccount({
-              address,
-              derivationPath,
-              partyId: preparedTransaction.party_id,
-              currency,
-              derivationMode,
-            });
             observer.next({
               partyId: preparedTransaction.party_id,
-              account,
             });
             return observer.complete();
           }
           throw err;
         });
 
-        if (result) {
-          observer.next({
-            status: OnboardStatus.SUCCESS,
-          });
-          const account = await createAccount({
-            address,
-            derivationPath,
-            partyId: result.party.party_id,
-            currency,
-            derivationMode,
-          });
-          observer.next({
-            partyId: result.party.party_id,
-            account,
-          });
-        }
+        observer.next({
+          status: OnboardStatus.SUCCESS,
+        });
+
+        observer.next({
+          partyId: result?.party?.party_id || "unknown",
+        });
 
         observer.complete();
       }
@@ -165,7 +125,6 @@ export const buildOnboardAccount =
 export const buildAuthorizePreapproval =
   (signerContext: SignerContext<CantonSigner>) =>
   (
-    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
     partyId: string,
@@ -176,10 +135,8 @@ export const buildAuthorizePreapproval =
           status: PreApprovalStatus.PREPARE,
         });
 
-        const preparedTransaction: PrepareTransactionResponse = await preparePreApprovalTransaction(
-          currency,
-          partyId,
-        );
+        const preparedTransaction: PrepareTransactionResponse =
+          await preparePreApprovalTransaction(partyId);
 
         observer.next({
           status: PreApprovalStatus.SIGN,
@@ -194,7 +151,6 @@ export const buildAuthorizePreapproval =
         });
 
         const { isApproved } = await submitPreApprovalTransaction(
-          currency,
           partyId,
           preparedTransaction,
           signature,
@@ -208,35 +164,38 @@ export const buildAuthorizePreapproval =
           isApproved,
         });
 
+        // TODO: remove after demo
         const handleTapRequest = async () => {
           try {
-            const { serialized, hash } = await prepareTapRequest(currency, {
+            observer.next({
+              status: PreApprovalStatus.PREPARE,
+            });
+
+            const { serialized, hash } = await prepareTapRequest({
+              partyId,
+            });
+
+            observer.next({
+              status: PreApprovalStatus.SIGN,
+            });
+
+            const signature = await signerContext(deviceId, signer =>
+              signer.signTransaction(derivationPath, hash),
+            );
+
+            observer.next({
+              status: PreApprovalStatus.SUBMIT,
+            });
+
+            await submitTapRequest({
               partyId,
+              serialized,
+              signature,
             });
 
-            if (serialized && hash) {
-              observer.next({
-                status: PreApprovalStatus.SIGN,
-              });
-
-              const signature = await signerContext(deviceId, signer =>
-                signer.signTransaction(derivationPath, hash),
-              );
-
-              observer.next({
-                status: PreApprovalStatus.SUBMIT,
-              });
-
-              await submitTapRequest(currency, {
-                partyId,
-                serialized,
-                signature,
-              });
-
-              observer.next({
-                status: PreApprovalStatus.SUCCESS,
-              });
-            }
+            observer.next({
+              status: PreApprovalStatus.SUCCESS,
+            });
           } catch (err) {
             // Tap request failure should not break the pre-approval flow
           }
@@ -255,58 +214,7 @@ export const buildAuthorizePreapproval =
       );
     });
 
-const createAccount = async ({
-  address,
-  partyId,
-  derivationPath,
-  currency,
-  derivationMode,
-  index = 0,
-}: {
-  address: string;
-  derivationPath: string;
-  partyId: string;
-  currency: CryptoCurrency;
-  derivationMode: DerivationMode;
-  index?: number;
-}): Promise<Partial<Account>> => {
-  const accountShape = await getAccountShape(
-    {
-      address,
-      currency,
-      derivationMode,
-      derivationPath,
-      index,
-      rest: {
-        cantonResources: {
-          partyId,
-        },
-      },
-    },
-    { paginationConfig: {} },
-  );
-
-  const account: Partial<CantonAccount> = {
-    ...accountShape,
-    type: "Account",
-    xpub: partyId.replace(/:/g, "_"),
-    index,
-    // operations: [],
-    currency,
-    derivationMode,
-    lastSyncDate: new Date(),
-    pendingOperations: [],
-    seedIdentifier: address,
-    balanceHistoryCache: emptyHistoryCache,
-    cantonResources: {
-      partyId,
-    },
-  };
-
-  return account;
-};
-
-const log = (message: string, ...rest: unknown[]) => {
+const log = (message: string, ...rest: any[]) => {
   // eslint-disable-next-line no-console
   console.log(message, ...rest);
 };

package/src/bridge/prepareTransaction.ts

@@ -1,16 +1,25 @@
 import { AccountBridge } from "@ledgerhq/types-live";
 import { Transaction } from "../types";
-import { estimateFees } from "../common-logic";
+import { craftTransaction, estimateFees } from "../common-logic";
+import { getNextSequence } from "../network/node";
 import BigNumber from "bignumber.js";
-import { updateTransaction } from "./updateTransaction";
 
 export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
   account,
   transaction,
 ) => {
-  let fee = transaction.fee;
-  if (!fee || fee.eq(0)) {
-    fee = BigNumber((await estimateFees(account.currency)).toString());
+  const seq = await getNextSequence(account.freshAddress);
+
+  const craftedTransaction = await craftTransaction(
+    { address: account.freshAddress, nextSequenceNumber: seq },
+    { amount: transaction.amount, recipient: transaction.recipient },
+  );
+
+  const fee = await estimateFees(craftedTransaction.serializedTransaction);
+
+  if (transaction.fee !== new BigNumber(fee.toString())) {
+    return { ...transaction, fee: new BigNumber(fee.toString()) };
   }
-  return updateTransaction(transaction, { fee });
+
+  return transaction;
 };