@ledgerhq/coin-canton 0.5.0 → 0.5.1-nightly.0

package/src/bridge/sync.ts

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

package/src/bridge/updateTransaction.ts

@@ -8,10 +8,5 @@ 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,23 +1,28 @@
 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 = () => coinConfig.getCoinConfig().useGateway === true;
-const getNativeId = () => coinConfig.getCoinConfig().nativeInstrumentId;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
+const getNativeId = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).nativeInstrumentId;
 
-function adaptInstrument(instrument: InstrumentBalance): Balance {
+function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): Balance {
   return {
     value: BigInt(instrument.amount),
     locked: instrument.locked === true ? BigInt(instrument.amount) : BigInt(0),
     asset:
-      getNativeId() === instrument.instrument_id
+      getNativeId(currency) === instrument.instrument_id
         ? { type: "native" }
         : { type: "token", assetReference: instrument.instrument_id },
   };
 }
 
-export async function getBalance(partyId: string): Promise<Balance[]> {
-  if (useGateway())
-    return (await gatewayGetBalance(partyId)).map(instrument => adaptInstrument(instrument));
+export async function getBalance(currency: CryptoCurrency, partyId: string): Promise<Balance[]> {
+  if (useGateway(currency))
+    return (await gatewayGetBalance(currency, partyId)).map(instrument =>
+      adaptInstrument(currency, instrument),
+    );
   else throw new Error("Not implemented");
 }

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

@@ -2,6 +2,11 @@ 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(),
@@ -35,9 +40,9 @@ describe("getBalance", () => {
 
     (getBalanceFromNetwork as jest.Mock).mockResolvedValue(mockInstruments);
 
-    const result = await getBalance("party-id");
+    const result = await getBalance(mockCurrency, "party-id");
 
-    expect(getBalanceFromNetwork).toHaveBeenCalledWith("party-id");
+    expect(getBalanceFromNetwork).toHaveBeenCalledWith(mockCurrency, "party-id");
     expect(result).toEqual<Balance[]>([
       {
         value: BigInt(1000),
@@ -57,7 +62,7 @@ describe("getBalance", () => {
       useGateway: false,
     } as any);
 
-    await expect(getBalance("party-id")).rejects.toThrow("Not implemented");
+    await expect(getBalance(mockCurrency, "party-id")).rejects.toThrow("Not implemented");
     expect(getBalanceFromNetwork).not.toHaveBeenCalled();
   });
 });

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

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

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

@@ -2,11 +2,13 @@ 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 = () => coinConfig.getCoinConfig().useGateway === true;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
 
-export async function lastBlock(): Promise<BlockInfo> {
+export async function lastBlock(currency: CryptoCurrency): Promise<BlockInfo> {
   return {
-    height: useGateway() ? await getLedgerEnd() : await nodeGetLedgerEnd(),
+    height: useGateway(currency) ? await getLedgerEnd(currency) : 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 coinConfig from "../../config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 /**
  * Returns list of operations associated to an account.
@@ -10,10 +10,11 @@ import coinConfig from "../../config";
  * 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(partyId, {
+  const { operations, next } = await getOperations(currency, partyId, {
     cursor: page.pagingToken !== undefined ? parseInt(page.pagingToken) : undefined,
     minOffset: page.minHeight,
     limit: page.limit,

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,9 @@
-// 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
+import coinConfig from "../../config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+const feeValue = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).fee ?? 2n * 10n ** 38n;
+
+export async function estimateFees(currency: CryptoCurrency): Promise<bigint> {
+  return Promise.resolve(BigInt(feeValue(currency)));
 }

package/src/config.ts

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

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

@@ -13,6 +13,11 @@ import {
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
 } from "./gateway";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
 
 describe("gateway (devnet)", () => {
   let onboardedAccount: {
@@ -50,7 +55,7 @@ describe("gateway (devnet)", () => {
       };
 
       // WHEN
-      const response = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex, "ed25519");
 
       // THEN
       expect(response).toHaveProperty("party_id");
@@ -58,7 +63,8 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("public_key_fingerprint");
       expect(response).toHaveProperty("transactions");
       expect(response.transactions).toHaveProperty("combined_hash");
-      expect(response.party_name).toBe(keyPair.publicKeyHex);
+      expect(response.party_name).toBeDefined();
+      expect(typeof response.party_name).toBe("string");
 
       expect(response.public_key_fingerprint).toBe(keyPair.fingerprint);
     }, 30000);
@@ -69,11 +75,20 @@ describe("gateway (devnet)", () => {
       // GIVEN
       const { keyPair } = getOnboardedAccount();
       const prepareRequest = { public_key: keyPair.publicKeyHex, public_key_type: "ed25519" };
-      const prepareResponse = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+      const prepareResponse = await prepareOnboarding(
+        mockCurrency,
+        keyPair.publicKeyHex,
+        "ed25519",
+      );
       const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
 
       // WHEN
-      const response = await submitOnboarding(prepareRequest, prepareResponse, signature);
+      const response = await submitOnboarding(
+        mockCurrency,
+        prepareRequest,
+        prepareResponse,
+        signature,
+      );
 
       // Save onboarded account for all tests that need a valid party ID
       onboardedAccount = {
@@ -91,7 +106,7 @@ describe("gateway (devnet)", () => {
 
   describe("getLedgerEnd", () => {
     it("should return ledger end", async () => {
-      const end = await getLedgerEnd();
+      const end = await getLedgerEnd(mockCurrency);
       expect(end).toBeGreaterThanOrEqual(0);
     });
   });
@@ -99,7 +114,7 @@ describe("gateway (devnet)", () => {
   describe("getBalance", () => {
     it("should return user balance", async () => {
       const { partyId } = getOnboardedAccount();
-      const balance = await getBalance(partyId);
+      const balance = await getBalance(mockCurrency, partyId);
       expect(balance.length).toBeGreaterThanOrEqual(0);
       if (balance.length > 0) {
         expect(balance[0].amount).toBeGreaterThanOrEqual(0);
@@ -110,7 +125,7 @@ describe("gateway (devnet)", () => {
 
   describe("getPartyById", () => {
     it.skip("should return party info", async () => {
-      const party = await getPartyById("4f2e1485107adf5f");
+      const party = await getPartyById(mockCurrency, "4f2e1485107adf5f");
       expect(party).toBeDefined();
     });
   });
@@ -118,6 +133,7 @@ describe("gateway (devnet)", () => {
   describe("getPartyByPubKey", () => {
     it.skip("should return party info", async () => {
       const party = await getPartyByPubKey(
+        mockCurrency,
         "122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
       );
       expect(party).toBeDefined();
@@ -127,7 +143,9 @@ describe("gateway (devnet)", () => {
   describe("getOperations", () => {
     it("should return user transactions", async () => {
       const { operations } = await getOperations(
+        mockCurrency,
         "party-5f29bb32e9939939::12202becd8062a1d170209956cfd977fca76fcb4d2a892d08c77a7483f35a11d6440",
+        {},
       );
       expect(operations.length).toBeGreaterThanOrEqual(0);
     });
@@ -140,7 +158,7 @@ describe("gateway (devnet)", () => {
       const amount = 1000;
 
       // WHEN
-      const response = await prepareTapRequest({ partyId, amount });
+      const response = await prepareTapRequest(mockCurrency, { partyId, amount });
 
       // THEN
       expect(response).toHaveProperty("serialized");
@@ -154,14 +172,14 @@ describe("gateway (devnet)", () => {
     it("should submit tap request with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
-      const tapPrepareResponse = await prepareTapRequest({
+      const tapPrepareResponse = await prepareTapRequest(mockCurrency, {
         partyId,
         amount: 1000,
       });
       const tapSignature = keyPair.sign(tapPrepareResponse.hash);
 
       // WHEN
-      const response = await submitTapRequest({
+      const response = await submitTapRequest(mockCurrency, {
         partyId,
         serialized: tapPrepareResponse.serialized,
         signature: tapSignature,
@@ -181,7 +199,7 @@ describe("gateway (devnet)", () => {
       const { partyId } = getOnboardedAccount();
 
       // WHEN
-      const response = await preparePreApprovalTransaction(partyId);
+      const response = await preparePreApprovalTransaction(mockCurrency, partyId);
 
       // THEN
       expect(response).toHaveProperty("serialized");
@@ -195,11 +213,12 @@ describe("gateway (devnet)", () => {
     it("should submit pre-approval transaction with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
-      const preparedTransaction = await preparePreApprovalTransaction(partyId);
+      const preparedTransaction = await preparePreApprovalTransaction(mockCurrency, partyId);
       const preApprovalSignature = keyPair.sign(preparedTransaction.hash);
 
       // WHEN
       const response = await submitPreApprovalTransaction(
+        mockCurrency,
         partyId,
         preparedTransaction,
         preApprovalSignature,