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

package/src/bridge/signOperation.ts

@@ -1,11 +1,10 @@
 import { Observable } from "rxjs";
-import BigNumber from "bignumber.js";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import { AccountBridge, Operation } from "@ledgerhq/types-live";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { combine, craftTransaction } from "../common-logic";
-import { Transaction, CantonSigner } from "../types";
+import { combine, craftTransaction, getNextValidSequence } from "../common-logic";
+import { Transaction, CantonSigner, BoilerplateNativeTransaction } from "../types";
 
 export const buildSignOperation =
   (signerContext: SignerContext<CantonSigner>): AccountBridge<Transaction>["signOperation"] =>
@@ -21,36 +20,30 @@ export const buildSignOperation =
             type: "device-signature-requested",
           });
 
+          const nextSequenceNumber = await getNextValidSequence(account.freshAddress);
+
           const signature = await signerContext(deviceId, async signer => {
             const { freshAddressPath: derivationPath } = account;
-            const partyId = (account as unknown as { cantonResources: { partyId: string } })
-              .cantonResources.partyId;
-            const params: {
-              recipient?: string;
-              amount: BigNumber;
-              tokenId: string;
-              expireInSeconds: number;
-              memo?: string;
-            } = {
-              recipient: transaction.recipient,
-              amount: transaction.amount,
-              expireInSeconds: 60 * 60,
-              tokenId: "Amulet",
-            };
-            if (transaction.memo) {
-              params.memo = transaction.memo;
-            }
+            const { publicKey } = await signer.getAddress(derivationPath);
 
-            const { hash, serializedTransaction } = await craftTransaction(
-              account.currency,
+            const { nativeTransaction, serializedTransaction } = await craftTransaction(
+              {
+                address: account.freshAddress,
+                publicKey,
+              },
               {
-                address: partyId,
+                recipient: transaction.recipient,
+                amount: transaction.amount,
+                fee: fee,
               },
-              params,
             );
-            const transactionSignature = await signer.signTransaction(derivationPath, hash);
 
-            return combine(serializedTransaction, `${transactionSignature}__PARTY__${partyId}`);
+            const transactionSignature = await signer.signTransaction(
+              derivationPath,
+              serializedTransaction,
+            );
+
+            return combine(serializedTransaction, transactionSignature);
           });
 
           o.next({
@@ -71,6 +64,7 @@ export const buildSignOperation =
             senders: [account.freshAddress],
             recipients: [transaction.recipient],
             date: new Date(),
+            transactionSequenceNumber: nextSequenceNumber,
             extra: {},
           };
 

package/src/bridge/sync.ts

@@ -1,14 +1,14 @@
 import BigNumber from "bignumber.js";
-import { Operation, OperationType } from "@ledgerhq/types-live";
-import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { Operation } from "@ledgerhq/types-live";
+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 { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
-import { CantonAccount } from "../types";
+
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import coinConfig from "../config";
 
 const txInfoToOperationAdapter =
-  (accountId: string, partyId: string) =>
+  (accountId: string, address: string) =>
   (txInfo: OperationInfo): Operation => {
     const {
       transaction_hash,
@@ -18,17 +18,12 @@ const txInfoToOperationAdapter =
       recipients,
       transaction_timestamp,
       fee: { value: fee },
-      transfers: [{ value: transferValue, details }],
+      transfers: [{ value: transferValue }],
     } = txInfo;
-    let type: OperationType = "UNKNOWN";
-    if (txInfo.type === "Send") {
-      type = senders.includes(partyId) ? "OUT" : "IN";
-    } else if (txInfo.type === "Receive") {
-      type = "IN";
-    }
+
+    const type = senders.includes(address) ? "OUT" : "IN";
     const value = new BigNumber(transferValue);
     const feeValue = new BigNumber(fee);
-    const memo = details.metadata.reason;
 
     const op: Operation = {
       id: encodeOperationId(accountId, transaction_hash, type),
@@ -45,7 +40,6 @@ const txInfoToOperationAdapter =
       transactionSequenceNumber: height,
       extra: {
         uid,
-        memo,
       },
     };
 
@@ -55,60 +49,45 @@ const txInfoToOperationAdapter =
 const filterOperations = (
   transactions: OperationInfo[],
   accountId: string,
-  partyId: string,
+  address: string,
 ): Operation[] => {
-  return transactions.map(txInfoToOperationAdapter(accountId, partyId));
+  return transactions
+    .filter(tx => tx.type === "Receive" || tx.type === "Send")
+    .map(txInfoToOperationAdapter(accountId, address));
 };
 
-export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
-  const { address, initialAccount, currency, derivationMode, derivationPath, rest } = info;
-
-  const xpubOrAddress = (
-    (initialAccount && initialAccount.id && decodeAccountId(initialAccount.id).xpubOrAddress) ||
-    ""
-  ).replace(/:/g, "_");
-  const partyId =
-    rest?.cantonResources?.partyId ||
-    initialAccount?.cantonResources?.partyId ||
-    xpubOrAddress.replace(/_/g, ":");
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  // TODO: we need better solution ?
+  const xpubOrAddress = address?.replace(/:/g, "_") || "";
 
   const accountId = encodeAccountId({
     type: "js",
     version: "2",
     currencyId: currency.id,
     xpubOrAddress,
-    derivationMode,
+    derivationMode: "",
   });
 
+  // blockheight retrieval
+  const blockHeight = await getLedgerEnd();
+
   // 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 === "Amulet") || {
-    instrument_id: "Amulet",
-    amount: 0,
-    locked: false,
-  };
-
-  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)),
-  );
+  const balanceData = await getBalance(address);
+  const balance = new BigNumber(balanceData[0]?.amount || "0");
+  const reserveMin = coinConfig.getCoinConfig().minReserve || 0;
+  const spendableBalance = balance.minus(BigNumber(reserveMin));
 
   // Tx history fetching
   const oldOperations = initialAccount?.operations || [];
   const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-  const transactionData = await getOperations(currency, partyId, {
-    cursor: startAt,
+  const transactionData = await getOperations(address, {
+    cursor: 0,
     limit: 100,
   });
-  // blockheight retrieval
-  const blockHeight = await getLedgerEnd(currency);
 
-  const newOperations = filterOperations(transactionData.operations, accountId, partyId);
+  const newOperations = filterOperations(transactionData.operations, accountId, address);
   const operations = mergeOps(oldOperations, newOperations);
 
   // We return the new account shape
@@ -120,11 +99,6 @@ export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
     spendableBalance,
     operations,
     operationsCount: operations.length,
-    freshAddress: address,
-    freshAddressPath: derivationPath,
-    cantonResources: {
-      partyId,
-    },
   };
 
   return shape;

package/src/bridge/updateTransaction.ts

@@ -8,5 +8,10 @@ import type { Transaction } from "../types";
 // NOTE: here is an example transaction updater function
 // in this case, it resets fee to null depending on the patch content
 export const updateTransaction: AccountBridge<Transaction>["updateTransaction"] = (tx, patch) => {
+  // eslint-disable-next-line no-constant-condition
+  if (patch.recipient === "boilerplate1" || true) {
+    patch = { ...patch, fee: null };
+  }
+
   return defaultUpdateTransaction(tx, patch);
 };

package/src/common-logic/account/getBalance.ts

@@ -1,28 +1,23 @@
 import { Balance } from "@ledgerhq/coin-framework/api/types";
 import { getBalance as gatewayGetBalance, type InstrumentBalance } from "../../network/gateway";
 import coinConfig from "../../config";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = (currency: CryptoCurrency) =>
-  coinConfig.getCoinConfig(currency).useGateway === true;
-const getNativeId = (currency: CryptoCurrency) =>
-  coinConfig.getCoinConfig(currency).nativeInstrumentId;
+const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
+const getNativeId = () => coinConfig.getCoinConfig().nativeInstrumentId;
 
-function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): Balance {
+function adaptInstrument(instrument: InstrumentBalance): Balance {
   return {
     value: BigInt(instrument.amount),
     locked: instrument.locked === true ? BigInt(instrument.amount) : BigInt(0),
     asset:
-      getNativeId(currency) === instrument.instrument_id
+      getNativeId() === instrument.instrument_id
         ? { type: "native" }
         : { type: "token", assetReference: instrument.instrument_id },
   };
 }
 
-export async function getBalance(currency: CryptoCurrency, partyId: string): Promise<Balance[]> {
-  if (useGateway(currency))
-    return (await gatewayGetBalance(currency, partyId)).map(instrument =>
-      adaptInstrument(currency, instrument),
-    );
+export async function getBalance(partyId: string): Promise<Balance[]> {
+  if (useGateway())
+    return (await gatewayGetBalance(partyId)).map(instrument => adaptInstrument(instrument));
   else throw new Error("Not implemented");
 }

package/src/common-logic/account/getBalance.unit.test.ts

@@ -2,11 +2,6 @@ import { getBalance as getBalanceFromNetwork } from "../../network/gateway";
 import * as coinConfigModule from "../../config";
 import { getBalance } from "./getBalance";
 import { Balance } from "@ledgerhq/coin-framework/api/types";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-const mockCurrency = {
-  id: "canton_network",
-} as unknown as CryptoCurrency;
 
 jest.mock("../../network/gateway", () => ({
   getBalance: jest.fn(),
@@ -40,9 +35,9 @@ describe("getBalance", () => {
 
     (getBalanceFromNetwork as jest.Mock).mockResolvedValue(mockInstruments);
 
-    const result = await getBalance(mockCurrency, "party-id");
+    const result = await getBalance("party-id");
 
-    expect(getBalanceFromNetwork).toHaveBeenCalledWith(mockCurrency, "party-id");
+    expect(getBalanceFromNetwork).toHaveBeenCalledWith("party-id");
     expect(result).toEqual<Balance[]>([
       {
         value: BigInt(1000),
@@ -62,7 +57,7 @@ describe("getBalance", () => {
       useGateway: false,
     } as any);
 
-    await expect(getBalance(mockCurrency, "party-id")).rejects.toThrow("Not implemented");
+    await expect(getBalance("party-id")).rejects.toThrow("Not implemented");
     expect(getBalanceFromNetwork).not.toHaveBeenCalled();
   });
 });

package/src/common-logic/history/lastBlock.test.ts

@@ -1,7 +1,6 @@
 import { lastBlock } from "./lastBlock";
 import { getLedgerEnd as gatewayGetLedgerEnd } from "../../network/gateway";
 import { getLedgerEnd as nodeGetLedgerEnd } from "../../network/node";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../../network/gateway", () => ({
   getLedgerEnd: jest.fn(),
@@ -19,10 +18,6 @@ jest.mock("../../config", () => ({
 
 import coinConfig from "../../config";
 
-const mockCurrency = {
-  id: "canton_network",
-} as unknown as CryptoCurrency;
-
 describe("lastBlock", () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -32,7 +27,7 @@ describe("lastBlock", () => {
     (coinConfig.getCoinConfig as jest.Mock).mockReturnValue({ useGateway: true });
     (gatewayGetLedgerEnd as jest.Mock).mockResolvedValue(100);
 
-    const result = await lastBlock(mockCurrency);
+    const result = await lastBlock();
 
     expect(result).toEqual({ height: 100 });
     expect(gatewayGetLedgerEnd).toHaveBeenCalledTimes(1);
@@ -43,7 +38,7 @@ describe("lastBlock", () => {
     (coinConfig.getCoinConfig as jest.Mock).mockReturnValue({ useGateway: false });
     (nodeGetLedgerEnd as jest.Mock).mockResolvedValue(200);
 
-    const result = await lastBlock(mockCurrency);
+    const result = await lastBlock();
 
     expect(result).toEqual({ height: 200 });
     expect(nodeGetLedgerEnd).toHaveBeenCalledTimes(1);

package/src/common-logic/history/lastBlock.ts

@@ -2,13 +2,11 @@ import type { BlockInfo } from "@ledgerhq/coin-framework/api/index";
 import { getLedgerEnd as nodeGetLedgerEnd } from "../../network/node";
 import { getLedgerEnd } from "../../network/gateway";
 import coinConfig from "../../config";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = (currency: CryptoCurrency) =>
-  coinConfig.getCoinConfig(currency).useGateway === true;
+const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
 
-export async function lastBlock(currency: CryptoCurrency): Promise<BlockInfo> {
+export async function lastBlock(): Promise<BlockInfo> {
   return {
-    height: useGateway(currency) ? await getLedgerEnd(currency) : await nodeGetLedgerEnd(),
+    height: useGateway() ? await getLedgerEnd() : await nodeGetLedgerEnd(),
   };
 }

package/src/common-logic/history/listOperations.ts

@@ -1,6 +1,6 @@
 import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
 import { getOperations } from "../../network/gateway";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import coinConfig from "../../config";
 
 /**
  * Returns list of operations associated to an account.
@@ -10,11 +10,10 @@ import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
  * Impl to finalize when backend is ready
  */
 export async function listOperations(
-  currency: CryptoCurrency,
   partyId: string,
   page: Pagination,
 ): Promise<[Operation[], string]> {
-  const { operations, next } = await getOperations(currency, partyId, {
+  const { operations, next } = await getOperations(partyId, {
     cursor: page.pagingToken !== undefined ? parseInt(page.pagingToken) : undefined,
     minOffset: page.minHeight,
     limit: page.limit,

package/src/common-logic/transaction/broadcast.test.ts

@@ -1,7 +1,6 @@
 import { submit } from "../../network/gateway";
 import * as coinConfigModule from "../../config";
 import { broadcast } from "./broadcast";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../../network/gateway", () => ({
   submit: jest.fn(),
@@ -9,13 +8,9 @@ jest.mock("../../network/gateway", () => ({
 
 const mockSerialized = JSON.stringify({
   serialized: "serialized-tx",
-  signature: "signature__PARTY__alice:123",
+  signature: "signature",
 });
 
-const mockCurrency = {
-  id: "canton_network",
-} as unknown as CryptoCurrency;
-
 describe("broadcast", () => {
   const mockGetCoinConfig = jest.spyOn(coinConfigModule.default, "getCoinConfig");
 
@@ -28,11 +23,11 @@ describe("broadcast", () => {
       useGateway: true,
     } as any);
 
-    (submit as jest.Mock).mockResolvedValue({ update_id: "my-update-id" });
+    (submit as jest.Mock).mockResolvedValue({ updateId: "my-update-id" });
 
-    const result = await broadcast(mockCurrency, mockSerialized);
+    const result = await broadcast(mockSerialized);
 
-    expect(submit).toHaveBeenCalledWith(mockCurrency, "alice:123", "serialized-tx", "signature");
+    expect(submit).toHaveBeenCalledWith("serialized-tx", "signature");
     expect(result).toEqual("my-update-id");
   });
 
@@ -41,7 +36,7 @@ describe("broadcast", () => {
       useGateway: false,
     } as any);
 
-    await expect(broadcast(mockCurrency, mockSerialized)).rejects.toThrow("Not implemented");
+    await expect(broadcast(mockSerialized)).rejects.toThrow("Not implemented");
     expect(submit).not.toHaveBeenCalled();
   });
 });

package/src/common-logic/transaction/broadcast.ts

@@ -1,14 +1,10 @@
 import coinConfig from "../../config";
 import { submit } from "../../network/gateway";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = (currency: CryptoCurrency) =>
-  coinConfig.getCoinConfig(currency).useGateway === true;
+const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
 
-export async function broadcast(currency: CryptoCurrency, signedTx: string): Promise<string> {
+export async function broadcast(signedTx: string): Promise<string> {
   const parsed: { serialized: string; signature: string } = JSON.parse(signedTx);
-  const [sig, party] = parsed.signature.split("__PARTY__");
-  if (useGateway(currency))
-    return (await submit(currency, party, parsed.serialized, sig)).update_id;
+  if (useGateway()) return (await submit(parsed.serialized, parsed.signature)).updateId;
   else throw new Error("Not implemented");
 }

package/src/common-logic/transaction/combine.test.ts

@@ -3,15 +3,25 @@ import { combine } from "./combine";
 describe("combine", () => {
   it("responds with a Stringify version of the payload to broadcast", () => {
     // GIVEN
-    const transaction = "0x000000001";
+    const transaction = {
+      transaction: {
+        serialized: "SERIALIZED",
+        json: "JSON",
+        hash: "HASH",
+      },
+    };
     const signature = "SIGNATURE";
 
     // WHEN
-    const result = combine(transaction, signature);
+    const result = combine(JSON.stringify(transaction), signature);
 
     // THEN
     expect(JSON.parse(result)).toEqual({
-      serialized: "0x000000001",
+      transaction: {
+        serialized: "SERIALIZED",
+        json: "JSON",
+        hash: "HASH",
+      },
       signature: "SIGNATURE",
     });
   });

package/src/common-logic/transaction/combine.ts

@@ -1,7 +1,9 @@
 // Combines signature with raw transaction
-export function combine(serialized: string, signature: string): string {
+export function combine(transaction: string, signature: string): string {
+  const tx = JSON.parse(transaction);
+
   return JSON.stringify({
-    serialized,
+    ...tx,
     signature,
   });
 }

package/src/common-logic/transaction/craftTransaction.ts

@@ -1,13 +1,9 @@
 import BigNumber from "bignumber.js";
-import {
-  PrepareTransferRequest,
-  prepareTransferRequest,
-  PrepareTransferResponse,
-} from "../../network/gateway";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { BoilerplateNativeTransaction } from "../../types";
+
+const encodeNativeTx = (nativeTx: BoilerplateNativeTransaction) => JSON.stringify(nativeTx);
 
 export async function craftTransaction(
-  currency: CryptoCurrency,
   account: {
     address: string;
     nextSequenceNumber?: number;
@@ -16,36 +12,25 @@ export async function craftTransaction(
   transaction: {
     recipient?: string;
     amount: BigNumber;
-    tokenId: string;
-    expireInSeconds: number;
-    memo?: string;
+    fee?: BigNumber;
   },
 ): Promise<{
-  nativeTransaction: PrepareTransferResponse;
+  nativeTransaction: BoilerplateNativeTransaction;
   serializedTransaction: string;
-  hash: string;
 }> {
-  const params: PrepareTransferRequest = {
-    recipient: transaction.recipient || "",
-    amount: transaction.amount.toString(),
-    type: "token-transfer-request" as const,
-    execute_before_secs: transaction.expireInSeconds,
-    instrument_id: transaction.tokenId,
+  const nativeTransaction: BoilerplateNativeTransaction = {
+    TransactionType: "Payment",
+    Account: account.address,
+    Amount: transaction.amount.toString(),
+    Destination: transaction.recipient || "",
+    Fee: transaction.fee?.toString() || "0",
+    Sequence: account.nextSequenceNumber || 0,
   };
 
-  if (transaction.memo) {
-    params.reason = transaction.memo;
-  }
-
-  const { serialized, json, hash } = await prepareTransferRequest(
-    currency,
-    account.address,
-    params,
-  );
+  const serializedTransaction = encodeNativeTx(nativeTransaction);
 
   return {
-    nativeTransaction: json,
-    serializedTransaction: serialized,
-    hash,
+    nativeTransaction,
+    serializedTransaction,
   };
 }

package/src/common-logic/transaction/estimateFees.ts

@@ -1,8 +1,4 @@
-import coinConfig from "../../config";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-const feeValue = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).fee ?? 1;
-
-export async function estimateFees(currency: CryptoCurrency): Promise<bigint> {
-  return Promise.resolve(BigInt(feeValue(currency)));
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function estimateFees(serializedTransaction: string): Promise<bigint> {
+  return Promise.resolve(BigInt(10_000)); // TODO replace with real implementation
 }

package/src/config.ts

@@ -10,7 +10,6 @@ export type CantonConfig = {
   networkType: "mainnet" | "devnet" | "localnet";
   useGateway?: boolean;
   nativeInstrumentId?: string;
-  fee?: number;
 };
 
 export type CantonCoinConfig = CurrencyConfig & CantonConfig;