Exchanges Travel Rule Overview

{
  "type": "exchange-service-travel-rule",
  "typeVersion": "1.0.0",
  "data": {
    "beneficiary": {},
    "originator": {},
    "beneficiaryVASP": {},
    "originatingVASP": {},
    "transactionData": {}
  }
}

const { data } = await fireblocks.exchangeAccounts.getExchangeAccountsCredentialsPublicKey();
const publicKey = data.publicKey;

/**
 * Cleans PEM headers, footers, and whitespace, then converts it to an ArrayBuffer.
 */
function pemToArrayBuffer(pem: string): ArrayBuffer {
  const cleanBase64 = pem
    .replace(/-----BEGIN PUBLIC KEY-----/g, '')
    .replace(/-----END PUBLIC KEY-----/g, '')
    .replace(/\s+/g, '');

  const binaryString = atob(cleanBase64);
  return Uint8Array.from(binaryString, (char) => char.charCodeAt(0)).buffer;
}

/**
 * Imports an RSA public key from PEM format for the Web Crypto API.
 */
export async function importRsaPublicKey(pemContents: string): Promise<CryptoKey> {
  const binaryDer = pemToArrayBuffer(pemContents);

  return crypto.subtle.importKey(
    'spki',
    binaryDer,
    { name: 'RSA-OAEP', hash: 'SHA-256' },
    true,
    ['encrypt']
  );
}

/**
 * Encrypts a primitive value using an imported CryptoKey (RSA-OAEP with SHA-256)
 * and returns a Base64 string.
 */
async function encryptPrimitiveData(data: string | number | boolean, cryptoKey: CryptoKey): Promise<string> {
  const encodedData = new TextEncoder().encode(String(data));

  const encryptedBuffer = await crypto.subtle.encrypt(
    { name: 'RSA-OAEP' },
    cryptoKey,
    encodedData
  );

  return Buffer.from(encryptedBuffer).toString('base64');
}

/**
 * Encrypts each PII field individually using RSA-OAEP encryption.
 * Preserves the original object/array structure.
 *
 * @param piiData - PII data object to encrypt field by field
 * @param publicKey - RSA public key in PEM format or JSON string containing credPublicKey
 * @returns Promise<any> - Object with each primitive field encrypted individually in Base64
 */
export async function encryptPiiFieldsIndividually(piiData: any, publicKey: string): Promise<any> {
  // 1. Extract PEM content if JSON string was provided, then import key once
  const pemContents = publicKey.trim().startsWith('{')
    ? JSON.parse(publicKey).credPublicKey
    : publicKey;

  const cryptoKey = await importRsaPublicKey(pemContents);

  // 2. Recursive traversal helper
  async function encryptPrimitives(obj: any): Promise<any> {
    if (obj === null || obj === undefined) {
      return obj;
    }

    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
      return await encryptPrimitiveData(obj, cryptoKey);
    }

    if (Array.isArray(obj)) {
      return Promise.all(obj.map((item) => encryptPrimitives(item)));
    }

    if (typeof obj === 'object') {
      const result: any = {};
      for (const [key, value] of Object.entries(obj)) {
        result[key] = await encryptPrimitives(value);
      }
      return result;
    }

    return obj;
  }

  // 3. Execute recursive encryption
  return encryptPrimitives(piiData);
}

const encryptedPiiData = await encryptPiiFieldsIndividually(piiData, publicKey);

const { data: tx } = await fireblocks.transactions.createTransaction({
  transactionRequest: {
    operation: "TRANSFER",
    assetId: "BTC",
    amount: "100",
    source: { type: "VAULT_ACCOUNT", id: "1" },
    destination: { type: "EXCHANGE_ACCOUNT", id: "exchange_account_id" },
    extraParameters: { piiData: encryptedPiiData },
  },
});
console.log("Exchange transaction created:", tx.id);