​
Overview

This tutorial will guide you through implementing multicurrency transactions with the Blnk Ledger.

For this tutorial, we’ll use the Blnk TypeScript SDK for the implementation. If you prefer, you can also refer to the API reference for details on the available endpoints.

​
Designing your map

Before writing code, it’s crucial to design a money movement map that outlines how money moves in your system. This serves as the blueprint for your implementation.

​
Set up your implementation

A simple multicurrency transaction flow (e.g. USD to GBP) needs:

  1. Two balances in different currencies. We’ll use USD and GBP for this guide.
  2. Two transactions: one to debit the source (send USD), and the other the credit the destination balance (receive GBP).
  3. Use a linked id to connect both transactions together.

​
Sending USD

Record a transaction for the USD being sent, and deposit it into a liquidity balance (in USD) managed by your organization.

TypeScript
async function sendUSD(usdSourceBalance, linkedTransactionId, usdAmount, currentFxRate, uniqueReference, description) {
  const blnk = await getBlnkInstance();
  const { Transactions } = blnk;
  
  const send = await Transactions.create({
    amount: usdAmount,
    precision: 100,
    reference: uniqueReference,
    description: description || "Transfer for GBP",
    currency: "USD",
    source: usdSourceBalance,
    destination: "@USDLiquidity",
    meta_data: {
      fx_transaction_id: linkedTransactionId,
      fx_rate: currentFxRate
    }
  });
  
  console.log("Transaction created:", send.data.transaction_id);
  return send.data.transaction_id;
}

​
Sending GBP

Next, record a transaction for the GBP received in the destination balance, transferred from a liquidity balance (in GBP) that your organization also manages.

TypeScript
async function sendUSD(usdDestinationBalance, linkedTransactionId, gbpAmount, currentFxRate, uniqueReference, description) {
  const blnk = await getBlnkInstance();
  const { Transactions } = blnk;
  
  const receive = await Transactions.create({
    amount: gbpAmount,
    precision: 100,
    reference: uniqueReference,
    description: description || "Transfer for GBP",
    currency: "GBP",
    source: "@GBPLiquidity",
    destination: usdDestinationBalance,
    meta_data: {
      fx_transaction_id: linkedTransactionId,
      fx_rate: currentFxRate
    }
  });
  
  console.log("Transaction created:", receive.data.transaction_id);
  return receive.data.transaction_id;
}

​
Handling FX rates

Develop a function to compute the amount the recipient will receive in GBP, using real-time FX rates:

TypeScript
function calculateGBP(usdAmount, usdToGbpRate) {
  const gbpAmount = usdAmount * usdToGbpRate;

  return Number(gbpAmount.toFixed(2));
}

​
Conclusion

This tutorial provides a clear and detailed understanding of money movement between different currencies, ensuring no risk of missing cents.

Other things you can do is:

  1. Atomically process both transactions as a bulk transaction ensuring that they either both succeed or both fail.

  2. Use multiple destinations to record and charge spread fees and charges typically associated with FX conversions.

​
Can’t find your use case?

If you’re searching for a specific tutorial that isn’t included here, you’re welcome to contribute to our documentation by sharing your expertise or requesting a new tutorial in our Discord community.

We’re always thrilled to expand our resources with the help of our developer community!