Exchanges Travel Rule Overview

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

import { Fireblocks } from '@fireblocks/ts-sdk';

const fireblocksSDK = new Fireblocks({ apiKey, privateKey, basePath: baseUrl });

async function getExchangePublicKey() {
  try {
    const credentialsResponse = await fireblocksSDK.exchangeAccounts
.getExchangeAccountsCredentialsPublicKey();
    return credentialsResponse.publicKey;
  } catch (error) {
    console.error('Failed to get workspace exchange public key:', error);
    throw error;
  }
}

/**
 * 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);
}

async function createExchangeTransaction(fireblocksSDK: Fireblocks, piiData: any) {
  // 2. Get workspace exchange public key from Fireblocks
  const publicKey = await getExchangePublicKey();

  // 3. RSA-only encrypt each PII field individually
  const encryptedPiiData = await encryptPiiFieldsIndividually(piiData, publicKey);

  // 4. Build the Fireblocks transaction payload
  const transactionRequest = {
    operation: "TRANSFER",
    source: { type: "VAULT_ACCOUNT", id: "1" },
    destination: { type: "EXCHANGE_ACCOUNT", id: "exchange_account_id" },
    amount: "100",
    assetId: "BTC",
    extraParameters: {
      piiData: encryptedPiiData
    }
  };

  // 5. Send the transaction
  const result = await fireblocksSDK.transactions.createTransaction({           
    transactionRequest: transactionRequest 
  });
  console.log('Exchange transaction created:', result.id);
  return result;
}

createExchangeTransaction(fireblocksSDK, <PII DATA OBJECT>)
  .then(() => console.log("PII transaction sent successfully to exchange."))
  .catch(console.error);