// generateHeaders.js

const crypto = require("crypto");
const apiKey = "123456...";
const secret = "ABCDEF...";

module.exports = async (subAccountUid = {}) => {
  const timeStamp = new Date().getTime();
  const queryString = `${timeStamp}${apikey}`;
  const signature = crypto
    .createHmac("sha256", secret)
    .update(queryString)
    .digest("hex");

  return {
    "Content-Type": "application/json;charset=utf-8",
    "X-Auth-Apikey": apikey,
    "X-Auth-Nonce": timeStamp,
    "X-Auth-Signature": signature,
    "X-Auth-Signature": signature,
    // Only for sub-account / customer requests:
    "X-Auth-Subaccount-UID": subAccountUid,
  };
};

// generateHeaders.js

const crypto = require("crypto");
const apiKey = "123456...";
const secret = "ABCDEF...";

module.exports = async () => {
  const timeStamp = new Date().getTime();
  const queryString = `${timeStamp}${apikey}`;
  const signature = crypto
    .createHmac("sha256", secret)
    .update(queryString)
    .digest("hex");

  return {
    "Content-Type": "application/json;charset=utf-8",
    "X-Auth-Apikey": apikey,
    "X-Auth-Nonce": timeStamp,
    "X-Auth-Signature": signature,
  };
};

// createOrder.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

createOrder = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "POST";
  const path = `/api/v2/atlas/market/orders`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const orderData = {
    market: "btczar",
    side: "sell",
    volume: "0.00001",
    ord_type: "limit",
    price: "800000",
    post_only: true,
    custom_order_id: "302b0494-1a06-4089-846c-0c6b13f1b661",
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: orderData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

{
  "id": 173757,
  "uuid": "7e86a4fa-fcae-4953-b9bc-d6f328beea48",
  "side": "sell",
  "ord_type": "limit",
  "price": "800000.0",
  "avg_price": "0.0",
  "state": "pending",
  "market": "btczar",
  "created_at": "2023-12-08T08:46:59+01:00",
  "updated_at": "2023-12-08T08:46:59+01:00",
  "origin_volume": "0.00001",
  "remaining_volume": "0.00001",
  "executed_volume": "0.0",
  "trades_count": 0,
  "custom_order_id": "302b0494-1a06-4089-846c-0c6b13f1b661"
}

// generateHeadersWithSubAccount.js

const crypto = require("crypto");
const apiKey = "123456...";
const secret = "ABCDEF...";
const subAccountUid = "CCT1234567"; // Sub-account or customer UID

module.exports = async () => {
  const timeStamp = new Date().getTime();
  const queryString = `${timeStamp}${apiKey}`;
  const signature = crypto
    .createHmac("sha256", secret)
    .update(queryString)
    .digest("hex");

  return {
    "Content-Type": "application/json;charset=utf-8",
    "X-Auth-Apikey": apiKey,
    "X-Auth-Nonce": timeStamp,
    "X-Auth-Signature": signature,
    "X-Auth-Subaccount-Uid": subAccountUid, // Act on behalf of sub-account/customer
  };
};

// createOrderAsSubAccount.js
const axios = require("axios");
const generateHeaders = require("./generateHeadersWithSubAccount");

createOrder = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "POST";
  const path = `/api/v2/atlas/market/orders`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const orderData = {
    market: "btczar",
    side: "buy",
    volume: "0.00001",
    ord_type: "limit",
    price: "750000",
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: orderData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

const axios = require("axios");

getMarkets = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const path = `/api/v2/atlas/public/markets`;
  const url = `${baseUrl}${path}`;

  const axiosConfig = {
    method: method,
    url: url,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

getMarkets();

[
  {
    "id": "btczar",
    "name": "BTC/ZAR",
    "base_unit": "btc",
    "quote_unit": "zar",
    "min_price": "200000.0",
    "max_price": "1200000.0",
    "min_amount": "0.00001",
    "amount_precision": 8,
    "price_precision": 2,
    "state": "enabled"
  },
  {
    "id": "ethzar",
    "name": "ETH/ZAR",
    "base_unit": "eth",
    "quote_unit": "zar",
    "min_price": "10000.0",
    "max_price": "100000.0",
    "min_amount": "0.0001",
    "amount_precision": 8,
    "price_precision": 2,
    "state": "enabled"
  },
  {
    "id": "xrpzar",
    "name": "XRP/ZAR",
    "base_unit": "xrp",
    "quote_unit": "zar",
    "min_price": "1.0",
    "max_price": "100.0",
    "min_amount": "1.0",
    "amount_precision": 6,
    "price_precision": 2,
    "state": "enabled"
  },
  {
    "id": "usdczar",
    "name": "USDC/ZAR",
    "base_unit": "usdc",
    "quote_unit": "zar",
    "min_price": "14.0",
    "max_price": "29.0",
    "min_amount": "0.5",
    "amount_precision": 2,
    "price_precision": 2,
    "state": "enabled"
  }
]

const axios = require("axios");
const generateHeaders = require("./generateHeaders");

getTransactions = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const path = `/api/v2/account/transactions?currency=btc&type=deposit&limit=25&page=1`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

getTransactions();

{
  "currency": "btc",
  "name": "My Bitcoin Wallet",
  "description": "Personal cold storage wallet",
  "data": {
    "address": "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq"
  }
}

{
  "currency": "xrp",
  "name": "Exchange XRP Account",
  "description": "My Binance XRP deposit",
  "data": {
    "address": "rN7n7otQDd6FczFgLdlqtyMVrn3qHwuSaDcqC",
    "tag": "123456789"
  }
}

{
  "currency": "eth",
  "name": "Friend's Wallet",
  "description": "John's Ethereum wallet",
  "data": {
    "address": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    "is_own": false,
    "is_unhosted": true,
    "recipient_data": {
      "first_name": "John",
      "last_name": "Doe",
      "country": "US"
    }
  }
}

{
  "currency": "zar",
  "name": "South African Bank Account",
  "description": "Personal savings account",
  "data": {
    "full_name": "Thabo Mbeki",
    "account_number": "1234567890",
    "bank_name": "Standard Bank",
    "bank_swift_code": "SBZAZAJJ",
    "bank_address": "30 Baker Street",
    "bank_city": "Johannesburg",
    "account_type": "savings"
  }
}

{
  "currency": "gbp",
  "name": "UK Business Account",
  "description": "Company bank account",
  "data": {
    "full_name": "John Smith",
    "account_number": "12345678",
    "bank_name": "Barclays Bank",
    "bank_swift_code": "BARCGB22",
    "bank_address": "1 Churchill Place",
    "bank_city": "London",
    "account_type": "checking"
  }
}

{
  "currency": "eur",
  "name": "EU Partner Account",
  "description": "European supplier payment",
  "data": {
    "full_name": "Jean Dupont",
    "iban": "FR1420041010050500013M02606",
    "bank_name": "BNP Paribas",
    "bank_swift_code": "BNPAFRPP",
    "bank_city": "Paris"
  }
}

{
  "currency": "usd",
  "name": "International Vendor",
  "description": "Asian supplier USD payment",
  "data": {
    "full_name": "ABC Trading Company Ltd",
    "account_number": "9876543210",
    "bank_name": "Asia Commercial Bank",
    "bank_swift_code": "ACBVSGSG",
    "intermediary_bank_swift": "CHASUS33",
    "bank_address": "123 Business Street",
    "bank_city": "Singapore"
  }
}

{
  "is_own": false,
  "is_unhosted": true,
  "vasp_id": 123,
  "address": "lnbc...", // Lightning address or BOLT11
  "recipient_data": {
    "first_name": "John",
    "last_name": "Doe",
    "company_name": "Acme Corp",
    "address": "123 Main St",
    "country": "US",
    "identity_type": "Passport"
  }
}

// createSubAccount.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

createSubAccount = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "POST";
  const path = `/api/v2/persona/resource/sub_accounts`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const subAccountData = {
    account_name: "Trading Account 1",
    deposit_action: "transfer_to_parent",
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: subAccountData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

createSubAccount();

{
  "action": "none|aggregate|convert_and_withdraw|aggregate_convert_and_withdraw",
  "target_currency": "currency_code", // Required for convert actions (e.g., "zar", "usd")
  "beneficiary_id": 123, // Required for withdraw actions
  "lightning_invoice": "lnbc...", // Alternative to beneficiary_id for Lightning withdrawals
  "max_slippage": 2.0 // Optional: Max slippage percentage (0.1-10, default: 2.0)
}

{
  "account_name": "Trading Account 1",
  "deposit_action": {
    "action": "aggregate"
  }
}

{
  "account_name": "USD Conversion Account",
  "deposit_action": {
    "action": "convert_and_withdraw",
    "target_currency": "usd",
    "beneficiary_id": 789,
    "max_slippage": 1.5
  }
}

// listSubAccounts.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

listSubAccounts = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const path = `/api/v2/persona/resource/sub_accounts?page=1&limit=100`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

listSubAccounts();

// getSubAccount.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

getSubAccount = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const subAccountUid = "CCT1234567";
  const path = `/api/v2/persona/resource/sub_accounts/${subAccountUid}`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

getSubAccount();

// updateSubAccount.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

updateSubAccount = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "PUT";
  const subAccountUid = "CCT1234567";
  const path = `/api/v2/persona/resource/sub_accounts/${subAccountUid}`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const updateData = {
    deposit_action: "none",
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: updateData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

updateSubAccount();

// deleteSubAccount.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

deleteSubAccount = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "DELETE";
  const subAccountUid = "CCT1234567";
  const path = `/api/v2/persona/resource/sub_accounts/${subAccountUid}`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log("Sub-account deleted successfully");
  } catch (err) {
    console.log(err);
  }
};

deleteSubAccount();

// createIndividualCustomer.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

createIndividualCustomer = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "POST";
  const path = `/api/v2/persona/resource/customers`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const customerData = {
    entity_type: "individual",
    email: "[email protected]",
    phone_number: "+27821234567",
    account_name: "John Doe Account",

    // Personal Information
    first_name: "John",
    last_name: "Doe",
    dob: "1990-01-15",

    // Location Information
    address: "123 Main Street, Apt 4B",
    postcode: "7700",
    city: "Cape Town",
    country: "ZA",
    nationality: "ZA",
    country_of_residence: "ZA",
    sa_id_number: "9001155800087",

    // Professional Information (See not above for approved list)
    occupation: "Software Engineer",
    source_of_funds: "Salary or Wages",

    // Document Information
    doc_number: "M12345678",
    doc_type: "Passport",
    doc_expire: "2028-12-31",
    doc_country: "ZA",

    // PEP Declaration
    is_pep_occupation: false,
    is_pep_related: false,
    is_pip: false,
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: customerData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

createIndividualCustomer();

{
  "action": "none|aggregate|convert_and_withdraw|aggregate_convert_and_withdraw",
  "target_currency": "currency_code", // Required for convert actions (e.g., "zar", "usd")
  "beneficiary_id": 123, // Required for withdraw actions
  "lightning_invoice": "lnbc...", // Alternative to beneficiary_id for Lightning withdrawals
  "max_slippage": 2.0 // Optional: Max slippage percentage (0.1-10, default: 2.0)
}

{
  "entity_type": "individual",
  "email": "[email protected]",
  "first_name": "John",
  "last_name": "Doe",
  // ... other required fields ...
  "deposit_action": {
    "action": "convert_and_withdraw",
    "target_currency": "zar",
    "beneficiary_id": 456,
    "max_slippage": 2.5
  }
}

// createBusinessCustomer.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

createBusinessCustomer = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "POST";
  const path = `/api/v2/persona/resource/customers`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const customerData = {
    entity_type: "business",
    email: "[email protected]",
    phone_number: "+27821234567",
    account_name: "ACME Corporation",

    business_profile: {
      // Core Business Information
      company_name: "ACME Corp (Pty) Ltd",
      registration_number: "2020/123456/07",
      registration_country: "ZA",
      industry: "Financial Services",
      purpose_of_account: "Cryptocurrency trading and payment processing",
      expected_monthly_volume_usd: 500000,

      // Additional Business Information
      jurisdictions_of_operation: ["ZA", "US", "GB"],
      website: "https://www.acmecorp.com",
      employee_count: 25,

      // Business Address
      address: "123 Business Street, Suite 100",
      city: "Cape Town",
      postcode: "8001",
      country: "ZA",

      // License Information
      license_status: "Licensed",
      license_number: "FSP12345",
      license_jurisdictions: ["ZA"],
    },

    // Ultimate Beneficial Owners (at least 1 required)
    ubos: [
      {
        // Personal Information
        email: "[email protected]",
        first_name: "Jane",
        last_name: "Smith",
        phone_number: "+27821111111",
        dob: "1985-05-15",

        // Residence Information
        address: "456 Residential Ave",
        postcode: "7700",
        city: "Cape Town",
        country: "ZA",
        nationality: "ZA",
        id_number: "8505155800088",

        // Professional Information
        occupation: "Chief Executive Officer",
        source_of_funds: "Business Income",

        // Ownership & Roles
        ownership_percentage: 60,
        is_director: true,
        is_authorized_signatory: true,

        // PEP Declaration
        is_pep_occupation: false,
        is_pep_related: false,
        is_pip: false,
      },
      {
        // Second UBO example
        email: "[email protected]",
        first_name: "John",
        last_name: "Doe",
        dob: "1980-03-20",

        address: "789 Co-founder Street",
        postcode: "7800",
        city: "Cape Town",
        country: "ZA",
        nationality: "ZA",
        id_number: "8003205800089",

        occupation: "Chief Technology Officer",
        source_of_funds: "Business Income",

        ownership_percentage: 40,
        is_director: true,
        is_authorized_signatory: false,

        is_pep_occupation: false,
        is_pep_related: false,
        is_pip: false,
      },
    ],
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: customerData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

createBusinessCustomer();

// listCustomers.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

listCustomers = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const path = `/api/v2/persona/resource/customers?page=1&limit=100`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

listCustomers();

Page: 1
Per-Page: 100
Total: 150

[
  {
    "uid": "CCT1234567",
    "account_name": "CUST-001",
    "state": "active",
    "custom_id": "CUST-001",
    "kyc_status": "verified",
    "created_at": "2024-01-01T00:00:00.000Z"
  },
  {
    "uid": "CCT1234567",
    "account_name": "CUST-002",
    "state": "active",
    "custom_id": "CUST-002",
    "kyc_status": "verified",
    "created_at": "2024-01-02T00:00:00.000Z"
  }
]

// getCustomer.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

getCustomer = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "GET";
  const customerUid = "CCT1234567";
  const path = `/api/v2/persona/resource/customers/${customerUid}`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

getCustomer();

// updateCustomer.js
const axios = require("axios");
const generateHeaders = require("./generateHeaders");

updateCustomer = async () => {
  const baseUrl = "https://trade.capecrypto.com";
  const method = "PUT";
  const customerUid = "CCT1234567";
  const path = `/api/v2/persona/resource/customers/${customerUid}`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const updateData = {
    custom_id: "CUST-001-UPDATED",
    external_verification_url: "https://example.com/verify/updated",
  };

  const axiosConfig = {
    method: method,
    url: url,
    headers: headers,
    data: updateData,
  };

  try {
    const results = await axios(axiosConfig);
    console.log(JSON.stringify(results.data, undefined, 2));
  } catch (err) {
    console.log(err);
  }
};

updateCustomer();

// uploadIndividualDocuments.js
const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");
const generateHeaders = require("./generateHeaders");

uploadDocuments = async (customerUid) => {
  const baseUrl = "https://trade.capecrypto.com";
  const path = `/api/v2/verification/customers/documents`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  // Document 1: ID Front
  const formData1 = new FormData();
  formData1.append("upload", fs.createReadStream("./id_front.jpg"));
  formData1.append("doc_type", "Passport");
  formData1.append("customer_uid", customerUid);
  formData1.append("doc_number", "M12345678");
  formData1.append("doc_expire", "2028-12-31");

  try {
    await axios.post(url, formData1, {
      headers: { ...headers, ...formData1.getHeaders() },
    });
    console.log("ID front uploaded successfully");
  } catch (err) {
    console.log("Error uploading ID front:", err);
  }

  // Document 2: ID Back
  const formData2 = new FormData();
  formData2.append("upload", fs.createReadStream("./id_back.jpg"));
  formData2.append("doc_type", "Drivers license back");
  formData2.append("customer_uid", customerUid);
  formData2.append("doc_number", "DL987654");
  formData2.append("doc_expire", "2028-12-31");

  try {
    await axios.post(url, formData2, {
      headers: { ...headers, ...formData2.getHeaders() },
    });
    console.log("ID back uploaded successfully");
  } catch (err) {
    console.log("Error uploading ID back:", err);
  }

  // Document 3: Selfie
  const formData3 = new FormData();
  formData3.append("upload", fs.createReadStream("./selfie.jpg"));
  formData3.append("doc_type", "Selfie");
  formData3.append("customer_uid", customerUid);

  try {
    await axios.post(url, formData3, {
      headers: { ...headers, ...formData3.getHeaders() },
    });
    console.log("Selfie uploaded successfully");
  } catch (err) {
    console.log("Error uploading selfie:", err);
  }

  // Document 4: Proof of Address
  const formData4 = new FormData();
  formData4.append("upload", fs.createReadStream("./proof_of_address.pdf"));
  formData4.append("doc_type", "Proof of Address");
  formData4.append("customer_uid", customerUid);

  try {
    await axios.post(url, formData4, {
      headers: { ...headers, ...formData4.getHeaders() },
    });
    console.log("Proof of Address uploaded successfully");
  } catch (err) {
    console.log("Error uploading proof of address:", err);
  }
};

// Upload documents after customer creation
uploadDocuments("CCT1234567");

// uploadBusinessDocuments.js
const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");
const generateHeaders = require("./generateHeaders");

uploadBusinessDocument = async (customerUid, documentType, filePath) => {
  const baseUrl = "https://trade.capecrypto.com";
  const path = `/api/v2/verification/customers/documents`;
  const url = `${baseUrl}${path}`;
  const headers = await generateHeaders();

  const formData = new FormData();
  formData.append("upload", fs.createReadStream(filePath));
  formData.append("doc_type", documentType);
  formData.append("customer_uid", customerUid);
  formData.append("doc_number", "N/A");
  formData.append("doc_expire", "N/A");

  try {
    const result = await axios.post(url, formData, {
      headers: { ...headers, ...formData.getHeaders() },
    });
    console.log(`${documentType} uploaded successfully`);
    return result.data;
  } catch (err) {
    console.log(`Error uploading ${documentType}:`, err);
    throw err;
  }
};

// Upload all required business documents
const uploadAllBusinessDocuments = async (customerUid) => {
  const documents = [
    { type: "Board Resolution", file: "./board_resolution.pdf" },
    { type: "Company Registration", file: "./company_registration.pdf" },
    { type: "AML Policy", file: "./aml_policy.pdf" },
    { type: "Business License", file: "./business_license.pdf" },
    { type: "Business Proof of Address", file: "./proof_of_address.pdf" },
    { type: "Shareholder Certificate", file: "./shareholder_certificate.pdf" },
    { type: "Incorporation Certificate", file: "./incorporation_cert.pdf" },
    { type: "Bank Statement", file: "./bank_statement.pdf" },
    { type: "Tax Statement", file: "./tax_statement.pdf" },
  ];

  for (const doc of documents) {
    await uploadBusinessDocument(customerUid, doc.type, doc.file);
  }

  console.log("All business documents uploaded successfully");
};

// Upload documents after business customer creation
uploadAllBusinessDocuments("CCT1234567");