🔵 Base Integration Guide

// Node.js - Register Base Mainnet
const registerBaseChain = async (token) => {
  const response = await fetch("https://api.quub.exchange/v2/chains", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
      "Idempotency-Key": `base-mainnet-${Date.now()}`,
    },
    body: JSON.stringify({
      chainId: 8453,
      name: "Base",
      shortName: "BASE",
      networkType: "MAINNET",
      layer: "L2",
      parentChainId: 1, // Ethereum mainnet
      nativeCurrency: "ETH",
      decimals: 18,
      blockTime: 2,
      confirmations: 1, // Faster on L2
      explorerUrl: "https://basescan.org",
      docsUrl: "https://docs.base.org/",
      genesisHash:
        "0x0000000000000000000000000000000000000000000000000000000000000000",
      chainNamespace: "EVM",
      status: "ACTIVE",
      metadata: {
        rollupType: "OPTIMISTIC",
        l1SettlementChain: "ETHEREUM",
        sequencerUrl: "https://mainnet-sequencer.base.org",
        challengePeriod: 604800, // 7 days in seconds
      },
    }),
  });

  return response.json();
};

// Node.js - Setup Base RPC with Coinbase and other providers
const setupBaseRPCAdapters = async (token, apiKeys = {}) => {
  const adapters = [
    {
      name: "Base Public Primary",
      rpcEndpoint: "https://mainnet.base.org",
      signerPolicy: "MPC_CLUSTER",
      priority: 0,
    },
    {
      name: "Alchemy Base",
      rpcEndpoint: `https://base-mainnet.g.alchemy.com/v2/${
        apiKeys.alchemy || "YOUR_ALCHEMY_KEY"
      }`,
      wsEndpoint: `wss://base-mainnet.g.alchemy.com/v2/${
        apiKeys.alchemy || "YOUR_ALCHEMY_KEY"
      }`,
      signerPolicy: "MPC_CLUSTER",
      priority: 1,
    },
    {
      name: "Infura Base",
      rpcEndpoint: `https://base-mainnet.infura.io/v3/${
        apiKeys.infura || "YOUR_INFURA_KEY"
      }`,
      wsEndpoint: `wss://base-mainnet.infura.io/ws/v3/${
        apiKeys.infura || "YOUR_INFURA_KEY"
      }`,
      signerPolicy: "MPC_CLUSTER",
      priority: 2,
    },
    {
      name: "QuickNode Base",
      rpcEndpoint:
        apiKeys.quicknode ||
        "https://your-quicknode-endpoint.base.quiknode.pro/",
      signerPolicy: "MPC_CLUSTER",
      priority: 3,
    },
  ];

  const results = [];
  for (const adapter of adapters) {
    const response = await fetch(
      "https://api.quub.exchange/v2/chain/adapters",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
          "Idempotency-Key": `base-${adapter.name
            .toLowerCase()
            .replace(/\s+/g, "-")}`,
        },
        body: JSON.stringify({
          chainId: 8453,
          ...adapter,
        }),
      }
    );
    results.push(await response.json());
  }

  return results;
};

// Node.js - Track ETH deposits from Ethereum L1 to Base L2
class BaseBridgeMonitor {
  constructor(orgId, token) {
    this.orgId = orgId;
    this.token = token;
    this.baseUrl = "https://api.quub.exchange/v2";
    this.l1ChainId = 1; // Ethereum
    this.l2ChainId = 8453; // Base
    this.bridgeContractL1 = "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"; // Base Portal
  }

  async recordL1Deposit(txData) {
    // Record the L1 deposit transaction
    const l1Response = await fetch(
      `${this.baseUrl}/orgs/${this.orgId}/onchain/txs`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${this.token}`,
          "Content-Type": "application/json",
          "X-Org-Id": this.orgId,
          "Idempotency-Key": `base-l1-deposit-${txData.hash}`,
        },
        body: JSON.stringify({
          chainId: this.l1ChainId,
          hash: txData.hash,
          fromAddress: txData.from,
          toAddress: this.bridgeContractL1,
          value: txData.value,
          direction: "OUTBOUND",
          status: "CONFIRMED",
          blockNumber: txData.blockNumber,
          gasPrice: txData.gasPrice,
          nonce: txData.nonce,
          txFeeAmount: txData.txFeeAmount,
          refType: "BRIDGE_DEPOSIT_L1",
          source: "NODE",
        }),
      }
    );

    return l1Response.json();
  }

  async recordL2Mint(l1TxHash, l2TxHash, value, l2BlockNumber) {
    // Record the corresponding L2 mint/credit
    const l2Response = await fetch(
      `${this.baseUrl}/orgs/${this.orgId}/onchain/txs`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${this.token}`,
          "Content-Type": "application/json",
          "X-Org-Id": this.orgId,
          "Idempotency-Key": `base-l2-mint-${l2TxHash}`,
        },
        body: JSON.stringify({
          chainId: this.l2ChainId,
          hash: l2TxHash,
          fromAddress: "0x0000000000000000000000000000000000000000", // Mint
          toAddress: "0x...", // User's Base address
          value: value,
          direction: "INBOUND",
          status: "CONFIRMED",
          blockNumber: l2BlockNumber,
          gasPrice: "0", // No gas cost for bridged mint
          refType: "BRIDGE_DEPOSIT_L2",
          refId: l1TxHash, // Link to L1 deposit
          source: "BRIDGE_MONITOR",
        }),
      }
    );

    return l2Response.json();
  }

  async trackBridgeDeposit(l1TxHash) {
    // Monitor L1 transaction until confirmed
    const l1Tx = await this.waitForL1Confirmation(l1TxHash);
    await this.recordL1Deposit(l1Tx);

    // Wait for L2 processing (typically 1-2 minutes on Base)
    const l2Tx = await this.waitForL2Mint(l1TxHash);
    await this.recordL2Mint(l1TxHash, l2Tx.hash, l1Tx.value, l2Tx.blockNumber);

    return {
      l1Transaction: l1TxHash,
      l2Transaction: l2Tx.hash,
      status: "COMPLETED",
    };
  }

  async waitForL1Confirmation(txHash) {
    // Implementation would check L1 transaction status
    return {
      hash: txHash,
      from: "0x...",
      value: "1.5",
      blockNumber: 18500000,
      gasPrice: "30000000000",
      nonce: 42,
      txFeeAmount: "0.00063",
    };
  }

  async waitForL2Mint(l1TxHash) {
    // Implementation would monitor Base bridge events
    return {
      hash: "0x...",
      blockNumber: 8500000,
    };
  }
}

// Usage
const bridgeMonitor = new BaseBridgeMonitor("org-uuid", token);
const result = await bridgeMonitor.trackBridgeDeposit("0xabc123...");
console.log("Bridge deposit completed:", result);

// Node.js - Handle Base's extremely low gas costs
class BaseGasTracker {
  constructor() {
    this.typicalGasPrice = 100_000; // 0.0001 Gwei typical on Base
    this.maxGasPrice = 1_000_000; // 0.001 Gwei max
  }

  async getCurrentGasPrice() {
    // Base gas prices are extremely low
    // web3.eth.getGasPrice() on Base
    return 100_000; // 0.0001 Gwei
  }

  estimateBaseCost(gasLimit, gasPriceWei = this.typicalGasPrice) {
    const costWei = gasLimit * gasPriceWei;
    const costETH = costWei / 1e18;

    // Example: ETH at $3000
    const ethPrice = 3000;
    const costUSD = costETH * ethPrice;

    return {
      gasLimit,
      gasPriceGwei: gasPriceWei / 1e9,
      gasPriceWei: gasPriceWei,
      totalCostWei: costWei,
      totalCostETH: costETH,
      totalCostUSD: costUSD,
    };
  }

  compareToL1(gasLimit) {
    // Compare Base L2 cost to Ethereum L1
    const baseCost = this.estimateBaseCost(gasLimit);

    const l1GasPrice = 30_000_000_000; // 30 Gwei typical on L1
    const l1CostWei = gasLimit * l1GasPrice;
    const l1CostETH = l1CostWei / 1e18;
    const l1CostUSD = l1CostETH * 3000;

    const savings = l1CostUSD - baseCost.totalCostUSD;
    const savingsPercent = (savings / l1CostUSD) * 100;

    return {
      base: baseCost,
      l1: {
        totalCostETH: l1CostETH,
        totalCostUSD: l1CostUSD,
      },
      savings: {
        usd: savings,
        percent: savingsPercent,
      },
    };
  }

  async recordTransactionWithL2Cost(orgId, token, txData) {
    const gasEstimate = this.estimateBaseCost(
      txData.gasLimit || 21000,
      parseInt(txData.gasPrice || this.typicalGasPrice)
    );

    const response = await fetch(
      `https://api.quub.exchange/v2/orgs/${orgId}/onchain/txs`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
          "X-Org-Id": orgId,
          "Idempotency-Key": `base-tx-${txData.hash}`,
        },
        body: JSON.stringify({
          chainId: 8453,
          hash: txData.hash,
          fromAddress: txData.from,
          toAddress: txData.to,
          value: txData.value,
          direction: txData.direction || "OUTBOUND",
          status: "PENDING",
          gasPrice: String(gasEstimate.gasPriceWei),
          txFeeAmount: String(gasEstimate.totalCostETH),
          txFeeUsd: String(gasEstimate.totalCostUSD),
          source: "NODE",
        }),
      }
    );

    return response.json();
  }
}

// Usage
const gasTracker = new BaseGasTracker();

// Simple transfer cost on Base
const transferCost = gasTracker.estimateBaseCost(21000);
console.log(
  `Base transfer cost: ${transferCost.totalCostETH.toFixed(
    8
  )} ETH ($${transferCost.totalCostUSD.toFixed(4)})`
);

// Compare to L1
const comparison = gasTracker.compareToL1(21000);
console.log(
  `Savings vs L1: $${comparison.savings.usd.toFixed(
    2
  )} (${comparison.savings.percent.toFixed(2)}% cheaper)`
);

// Node.js - Leverage Coinbase ecosystem integration
class BaseCoinbaseIntegration {
  constructor(orgId, token) {
    this.orgId = orgId;
    this.token = token;
    this.baseUrl = "https://api.quub.exchange/v2";
  }

  async createCoinbaseOptimizedWallet() {
    // Create wallet optimized for Coinbase <-> Base flow
    const response = await fetch(`${this.baseUrl}/orgs/${this.orgId}/wallets`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${this.token}`,
        "Content-Type": "application/json",
        "X-Org-Id": this.orgId,
        "Idempotency-Key": `base-coinbase-wallet-${Date.now()}`,
      },
      body: JSON.stringify({
        chainId: 8453,
        walletType: "HOT",
        label: "Base Coinbase Flow",
        signerPolicy: "MPC_CLUSTER",
        metadata: {
          purpose: "coinbase-base-bridge",
          optimizedFor: "fast-deposits",
        },
      }),
    });

    return response.json();
  }

  async recordCoinbaseDeposit(depositData) {
    // User deposits from Coinbase to Base (near-instant)
    const response = await fetch(
      `${this.baseUrl}/orgs/${this.orgId}/onchain/txs`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${this.token}`,
          "Content-Type": "application/json",
          "X-Org-Id": this.orgId,
          "Idempotency-Key": `coinbase-deposit-${depositData.hash}`,
        },
        body: JSON.stringify({
          chainId: 8453,
          hash: depositData.hash,
          fromAddress: depositData.from,
          toAddress: depositData.to,
          value: depositData.value,
          direction: "INBOUND",
          status: "CONFIRMED",
          blockNumber: depositData.blockNumber,
          gasPrice: "0", // Coinbase subsidizes
          txFeeAmount: "0",
          refType: "COINBASE_DEPOSIT",
          source: "COINBASE_BRIDGE",
        }),
      }
    );

    return response.json();
  }
}

// Usage
const coinbaseIntegration = new BaseCoinbaseIntegration("org-uuid", token);
const wallet = await coinbaseIntegration.createCoinbaseOptimizedWallet();
console.log("Created Coinbase-optimized wallet:", wallet.data.address);