Currency Exchange

destination_minor = floor(source_minor × 915000 ÷ 1000000)

npm install --global @parix/cli@latest
parix --version

parix auth login
parix auth status
parix database list --json

export PARIX_DATABASE_ID="db_replace_with_uuid"

[
  { "id": "870000000000000001", "ledger": 840, "code": 100, "flags": 8 },
  { "id": "870000000000000002", "ledger": 840, "code": 110, "flags": 10 },
  { "id": "870000000000000003", "ledger": 840, "code": 200, "flags": 10 },
  { "id": "870000000000000004", "ledger": 840, "code": 210, "flags": 8 },
  { "id": "870000000000000005", "ledger": 978, "code": 100, "flags": 8 },
  { "id": "870000000000000006", "ledger": 978, "code": 200, "flags": 10 },
  { "id": "870000000000000007", "ledger": 978, "code": 110, "flags": 10 }
]

parix tb create-accounts "$PARIX_DATABASE_ID" --file ./fx-accounts.json --json

parix tb create-transfers "$PARIX_DATABASE_ID" \
  --id 880000000000000001 \
  --from 870000000000000001 \
  --to 870000000000000002 \
  --amount 100050 \
  --ledger 840 \
  --code 10 \
  --json

parix tb create-transfers "$PARIX_DATABASE_ID" \
  --id 880000000000000002 \
  --from 870000000000000005 \
  --to 870000000000000006 \
  --amount 500000 \
  --ledger 978 \
  --code 10 \
  --json

[
  {
    "id": "880000000000000003",
    "debit_account_id": "870000000000000002",
    "credit_account_id": "870000000000000003",
    "amount": "10000",
    "user_data_128": "890000000000000001",
    "user_data_64": "915000",
    "user_data_32": 1,
    "ledger": 840,
    "code": 300,
    "flags": 1
  },
  {
    "id": "880000000000000004",
    "debit_account_id": "870000000000000002",
    "credit_account_id": "870000000000000004",
    "amount": "50",
    "user_data_128": "890000000000000001",
    "user_data_64": "915000",
    "user_data_32": 1,
    "ledger": 840,
    "code": 301,
    "flags": 1
  },
  {
    "id": "880000000000000005",
    "debit_account_id": "870000000000000006",
    "credit_account_id": "870000000000000007",
    "amount": "9150",
    "user_data_128": "890000000000000001",
    "user_data_64": "915000",
    "user_data_32": 1,
    "ledger": 978,
    "code": 302,
    "flags": 0
  }
]

parix tb create-transfers "$PARIX_DATABASE_ID" --file ./accepted-fx-quote.json --json
parix tb lookup-transfers "$PARIX_DATABASE_ID" --ids 880000000000000003,880000000000000004,880000000000000005 --json
parix tb query-accounts "$PARIX_DATABASE_ID" --ledger 840 --limit 20 --json
parix tb query-accounts "$PARIX_DATABASE_ID" --ledger 978 --limit 20 --json

import type {
  Account,
  CreateAccountResult,
  CreateTransferResult,
  Transfer,
} from '@parix/tigerbeetle-node';
import { AccountFlags, CreateTransferError, TransferFlags, createClient } from '@parix/tigerbeetle-node';

const client = createClient({
  baseUrl: process.env.PARIX_BASE_URL ?? 'https://parix.io',
  apiKey: mustGetEnv('PARIX_API_KEY'),
  databaseId: mustGetEnv('PARIX_DATABASE_ID'),
});

const ledger = { usd: 840, eur: 978 } as const;
const accountId = {
  usdTreasury: 870000000000000001n,
  customerUsd: 870000000000000002n,
  usdPool: 870000000000000003n,
  usdFeeRevenue: 870000000000000004n,
  eurTreasury: 870000000000000005n,
  eurPool: 870000000000000006n,
  customerEur: 870000000000000007n,
} as const;

const acceptedQuote = {
  id: 890000000000000001n,
  revision: 1,
  rateScaled: 915000n,
  sourceMinor: 10000n,
  feeMinor: 50n,
  destinationMinor: 9150n,
  transferId: {
    source: 880000000000000003n,
    fee: 880000000000000004n,
    destination: 880000000000000005n,
  },
} as const;

function account(id: bigint, ledgerId: number, code: number, flags: number): Account {
  return {
    id,
    debits_pending: 0n,
    debits_posted: 0n,
    credits_pending: 0n,
    credits_posted: 0n,
    user_data_128: 0n,
    user_data_64: 0n,
    user_data_32: 0,
    reserved: 0,
    ledger: ledgerId,
    code,
    flags,
    timestamp: 0n,
  };
}

function transfer(input: {
  id: bigint;
  debitAccountId: bigint;
  creditAccountId: bigint;
  amount: bigint;
  ledger: number;
  code: number;
  flags?: number;
  quoteId?: bigint;
  rateScaled?: bigint;
  quoteRevision?: number;
}): Transfer {
  return {
    id: input.id,
    debit_account_id: input.debitAccountId,
    credit_account_id: input.creditAccountId,
    amount: input.amount,
    pending_id: 0n,
    user_data_128: input.quoteId ?? 0n,
    user_data_64: input.rateScaled ?? 0n,
    user_data_32: input.quoteRevision ?? 0,
    timeout: 0,
    ledger: input.ledger,
    code: input.code,
    flags: input.flags ?? TransferFlags.none,
    timestamp: 0n,
  };
}

function getHttpStatus(cause: unknown): number | undefined {
  if (!cause || typeof cause !== 'object' || !('status' in cause)) return undefined;
  const status = (cause as { status?: unknown }).status;
  return typeof status === 'number' ? status : undefined;
}

function wasDefinitelyRejected(cause: unknown): boolean {
  const status = getHttpStatus(cause);
  return status !== undefined && [400, 401, 402, 403, 404, 409, 429].includes(status);
}

function sameAccount(actual: Account, intended: Account): boolean {
  return (
    actual.id === intended.id &&
    actual.user_data_128 === intended.user_data_128 &&
    actual.user_data_64 === intended.user_data_64 &&
    actual.user_data_32 === intended.user_data_32 &&
    actual.reserved === intended.reserved &&
    actual.ledger === intended.ledger &&
    actual.code === intended.code &&
    actual.flags === intended.flags
  );
}

function sameTransfer(actual: Transfer, intended: Transfer): boolean {
  return (
    actual.id === intended.id &&
    actual.debit_account_id === intended.debit_account_id &&
    actual.credit_account_id === intended.credit_account_id &&
    actual.amount === intended.amount &&
    actual.pending_id === intended.pending_id &&
    actual.user_data_128 === intended.user_data_128 &&
    actual.user_data_64 === intended.user_data_64 &&
    actual.user_data_32 === intended.user_data_32 &&
    actual.timeout === intended.timeout &&
    actual.ledger === intended.ledger &&
    actual.code === intended.code &&
    actual.flags === intended.flags
  );
}

async function accountsExistExactly(batch: Account[]): Promise<boolean> {
  const found = await client.lookupAccounts(batch.map(({ id }) => id));
  if (found.length === 0) return false;

  const intendedById = new Map(batch.map((item) => [item.id, item]));
  if (
    found.length !== batch.length ||
    !found.every((item) => {
      const intended = intendedById.get(item.id);
      return intended !== undefined && sameAccount(item, intended);
    })
  ) {
    throw new Error('FX account IDs are partially present or have different immutable fields');
  }
  return true;
}

async function transfersExistExactly(label: string, batch: Transfer[]): Promise<boolean> {
  const found = await client.lookupTransfers(batch.map(({ id }) => id));
  if (found.length === 0) return false;

  const intendedById = new Map(batch.map((item) => [item.id, item]));
  if (
    found.length !== batch.length ||
    !found.every((item) => {
      const intended = intendedById.get(item.id);
      return intended !== undefined && sameTransfer(item, intended);
    })
  ) {
    throw new Error(`${label} IDs are partially present or have different immutable fields`);
  }
  return true;
}

async function createAccountsOrReconcile(batch: Account[]): Promise<void> {
  if (await accountsExistExactly(batch)) return;

  let results: CreateAccountResult[] | CreateTransferResult[];
  try {
    results = await client.createAccounts(batch);
  } catch (cause) {
    if (wasDefinitelyRejected(cause)) throw cause;
    if (await accountsExistExactly(batch)) return;
    throw new Error('Account outcome is ambiguous; retry only with the same IDs and fields', { cause });
  }

  if (await accountsExistExactly(batch)) return;
  if (results.length === 0) {
    throw new Error('Account write was not confirmed by lookup; do not advance or change the payload');
  }
  throw new Error(
      `createAccounts rejected and lookup found no exact batch: ${JSON.stringify(results)}`,
    );
}

async function createTransfersOrReconcile(label: string, batch: Transfer[]): Promise<void> {
  if (await transfersExistExactly(label, batch)) return;

  let results: CreateAccountResult[] | CreateTransferResult[];
  try {
    results = await client.createTransfers(batch);
  } catch (cause) {
    if (wasDefinitelyRejected(cause)) throw cause;
    if (await transfersExistExactly(label, batch)) return;
    throw new Error(`${label} outcome is ambiguous; retry only with the same IDs and fields`, { cause });
  }

  if (await transfersExistExactly(label, batch)) return;
  if (results.length === 0) {
    throw new Error(`${label} was not confirmed by lookup; do not advance or change the payload`);
  }
  throw new Error(
      `${label} rejected${results.some((item) => item.result === CreateTransferError.exceeds_credits) ? ' (capacity)' : ''}` +
        ` and lookup found no exact batch: ${JSON.stringify(results)}`,
    );
}

async function settleAcceptedQuote(): Promise<void> {
  await createTransfersOrReconcile('accepted FX quote', [
    transfer({
      id: acceptedQuote.transferId.source,
      debitAccountId: accountId.customerUsd,
      creditAccountId: accountId.usdPool,
      amount: acceptedQuote.sourceMinor,
      ledger: ledger.usd,
      code: 300,
      flags: TransferFlags.linked,
      quoteId: acceptedQuote.id,
      rateScaled: acceptedQuote.rateScaled,
      quoteRevision: acceptedQuote.revision,
    }),
    transfer({
      id: acceptedQuote.transferId.fee,
      debitAccountId: accountId.customerUsd,
      creditAccountId: accountId.usdFeeRevenue,
      amount: acceptedQuote.feeMinor,
      ledger: ledger.usd,
      code: 301,
      flags: TransferFlags.linked,
      quoteId: acceptedQuote.id,
      rateScaled: acceptedQuote.rateScaled,
      quoteRevision: acceptedQuote.revision,
    }),
    transfer({
      id: acceptedQuote.transferId.destination,
      debitAccountId: accountId.eurPool,
      creditAccountId: accountId.customerEur,
      amount: acceptedQuote.destinationMinor,
      ledger: ledger.eur,
      code: 302,
      flags: TransferFlags.none,
      quoteId: acceptedQuote.id,
      rateScaled: acceptedQuote.rateScaled,
      quoteRevision: acceptedQuote.revision,
    }),
  ]);
}

async function main(): Promise<void> {
  const constrainedHistory = AccountFlags.history | AccountFlags.debits_must_not_exceed_credits;
  await createAccountsOrReconcile([
    account(accountId.usdTreasury, ledger.usd, 100, AccountFlags.history),
    account(accountId.customerUsd, ledger.usd, 110, constrainedHistory),
    account(accountId.usdPool, ledger.usd, 200, constrainedHistory),
    account(accountId.usdFeeRevenue, ledger.usd, 210, AccountFlags.history),
    account(accountId.eurTreasury, ledger.eur, 100, AccountFlags.history),
    account(accountId.eurPool, ledger.eur, 200, constrainedHistory),
    account(accountId.customerEur, ledger.eur, 110, constrainedHistory),
  ]);

  await createTransfersOrReconcile('test USD funding', [
    transfer({
      id: 880000000000000001n,
      debitAccountId: accountId.usdTreasury,
      creditAccountId: accountId.customerUsd,
      amount: 100050n,
      ledger: ledger.usd,
      code: 10,
    }),
  ]);
  await createTransfersOrReconcile('test EUR liquidity', [
    transfer({
      id: 880000000000000002n,
      debitAccountId: accountId.eurTreasury,
      creditAccountId: accountId.eurPool,
      amount: 500000n,
      ledger: ledger.eur,
      code: 10,
    }),
  ]);

  await settleAcceptedQuote();
}

function mustGetEnv(name: string): string {
  const value = process.env[name];
  if (!value) throw new Error(`Missing ${name}`);
  return value;
}

try {
  await main();
} finally {
  client.destroy();
}