@bvdaniel/confidential-pay-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A0x
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+export declare const USDC_ADDRESS: Record<string, `0x${string}`>;
+export declare const CHAIN: Record<string, any>;
+export interface ConfidentialPayOptions {
+    apiKeyId?: string;
+    apiKeySecret?: string;
+    walletSecret?: string;
+    network?: string;
+}
+export declare class ConfidentialPay {
+    private client;
+    private network;
+    private publicClient;
+    constructor(options?: ConfidentialPayOptions);
+    get networkName(): string;
+    /**
+     * Creates a new server-controlled EOA on Base.
+     */
+    createWallet(name?: string): Promise<{
+        address: `0x${string}`;
+    }>;
+    /**
+     * Get or create a named wallet. Idempotent.
+     */
+    getOrCreateWallet(name: string): Promise<{
+        address: `0x${string}`;
+    }>;
+    /**
+     * Requests testnet ETH from the CDP faucet (only works on testnets).
+     */
+    faucetEth(address: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Requests testnet USDC from the CDP faucet (only works on testnets).
+     */
+    faucetUsdc(address: `0x${string}`): Promise<`0x${string}`>;
+    /**
+     * Waits for a transaction to reach finality on the configured network.
+     */
+    waitForReceipt(txHash: `0x${string}`): Promise<any>;
+    /**
+     * Gets the USDC balance for a wallet address.
+     */
+    getUsdcBalance(address: `0x${string}`): Promise<string>;
+    /**
+     * Gets the native ETH balance for a wallet address (for gas).
+     */
+    getNativeBalance(address: `0x${string}`): Promise<string>;
+    /**
+     * Sends a USDC payment from a wallet address to a recipient.
+     * Returns the transaction hash.
+     */
+    sendUsdcPayment(params: {
+        from: `0x${string}`;
+        to: `0x${string}`;
+        amount: string;
+    }): Promise<{
+        transactionHash: `0x${string}`;
+        network: string;
+    }>;
+    /**
+     * Funds a wallet for the first time on testnets: USDC if below 1, ETH gas if below 0.001.
+     * Skips both if already funded. Fails silently on faucet rate-limits.
+     * @returns true if the wallet holds >= 1 USDC after this call.
+     */
+    fundOnFirstSend(address: `0x${string}`): Promise<boolean>;
+}

package/dist/index.js

@@ -0,0 +1,194 @@
+import { CdpClient } from "@coinbase/cdp-sdk";
+import { createPublicClient, http, encodeFunctionData, parseUnits, formatUnits } from "viem";
+import { base, baseSepolia } from "viem/chains";
+export const USDC_ADDRESS = {
+    "base-mainnet": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+};
+export const CHAIN = {
+    "base-mainnet": base,
+    "base-sepolia": baseSepolia,
+};
+const ERC20_TRANSFER_ABI = [
+    {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "to", type: "address" },
+            { name: "value", type: "uint256" },
+        ],
+        outputs: [{ name: "", type: "bool" }],
+    },
+];
+const ERC20_BALANCE_ABI = [
+    {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+];
+function applyTimeout(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class ConfidentialPay {
+    client;
+    network;
+    publicClient;
+    constructor(options = {}) {
+        this.client = new CdpClient({
+            apiKeyId: options.apiKeyId || process.env.CDP_API_KEY_ID,
+            apiKeySecret: options.apiKeySecret || process.env.CDP_API_KEY_SECRET,
+            walletSecret: options.walletSecret || process.env.CDP_WALLET_SECRET,
+        });
+        this.network = options.network || process.env.CDP_NETWORK || "base-sepolia";
+        const chain = CHAIN[this.network];
+        if (!chain)
+            throw new Error(`Unsupported network: ${this.network}`);
+        this.publicClient = createPublicClient({
+            chain,
+            transport: http(),
+        });
+    }
+    get networkName() {
+        return this.network;
+    }
+    /**
+     * Creates a new server-controlled EOA on Base.
+     */
+    async createWallet(name) {
+        const account = await this.client.evm.createAccount({ name });
+        return { address: account.address };
+    }
+    /**
+     * Get or create a named wallet. Idempotent.
+     */
+    async getOrCreateWallet(name) {
+        const account = await this.client.evm.getOrCreateAccount({ name });
+        return { address: account.address };
+    }
+    /**
+     * Requests testnet ETH from the CDP faucet (only works on testnets).
+     */
+    async faucetEth(address) {
+        if (this.network === "base-mainnet") {
+            throw new Error("Faucet is only available on testnets.");
+        }
+        const res = await this.client.evm.requestFaucet({
+            address,
+            network: "base-sepolia",
+            token: "eth",
+        });
+        return res.transactionHash;
+    }
+    /**
+     * Requests testnet USDC from the CDP faucet (only works on testnets).
+     */
+    async faucetUsdc(address) {
+        if (this.network === "base-mainnet") {
+            throw new Error("Faucet is only available on testnets.");
+        }
+        const res = await this.client.evm.requestFaucet({
+            address,
+            network: "base-sepolia",
+            token: "usdc",
+        });
+        return res.transactionHash;
+    }
+    /**
+     * Waits for a transaction to reach finality on the configured network.
+     */
+    async waitForReceipt(txHash) {
+        return this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    }
+    /**
+     * Gets the USDC balance for a wallet address.
+     */
+    async getUsdcBalance(address) {
+        const usdc = USDC_ADDRESS[this.network];
+        if (!usdc)
+            throw new Error(`USDC not configured for network ${this.network}`);
+        const balance = await this.publicClient.readContract({
+            address: usdc,
+            abi: ERC20_BALANCE_ABI,
+            functionName: "balanceOf",
+            args: [address],
+        });
+        return formatUnits(balance, 6);
+    }
+    /**
+     * Gets the native ETH balance for a wallet address (for gas).
+     */
+    async getNativeBalance(address) {
+        const balance = await this.publicClient.getBalance({ address });
+        return formatUnits(balance, 18);
+    }
+    /**
+     * Sends a USDC payment from a wallet address to a recipient.
+     * Returns the transaction hash.
+     */
+    async sendUsdcPayment(params) {
+        const usdc = USDC_ADDRESS[this.network];
+        if (!usdc)
+            throw new Error(`USDC not configured for network ${this.network}`);
+        const amount = parseUnits(params.amount, 6);
+        const data = encodeFunctionData({
+            abi: ERC20_TRANSFER_ABI,
+            functionName: "transfer",
+            args: [params.to, amount],
+        });
+        const res = await this.client.evm.sendTransaction({
+            address: params.from,
+            transaction: {
+                to: usdc,
+                data,
+                value: BigInt(0),
+            },
+            network: this.network,
+        });
+        return {
+            transactionHash: res.transactionHash,
+            network: this.network,
+        };
+    }
+    /**
+     * Funds a wallet for the first time on testnets: USDC if below 1, ETH gas if below 0.001.
+     * Skips both if already funded. Fails silently on faucet rate-limits.
+     * @returns true if the wallet holds >= 1 USDC after this call.
+     */
+    async fundOnFirstSend(address) {
+        if (this.network === "base-mainnet")
+            return true;
+        try {
+            const usdc = Number(await this.getUsdcBalance(address));
+            if (usdc < 1) {
+                const hash = await this.faucetUsdc(address);
+                await this.waitForReceipt(hash);
+            }
+            // Poll until USDC is visible on-chain (faucet credit and CDP's view lag on new wallets).
+            await applyTimeout(15000);
+            for (let i = 0; i < 12; i++) {
+                if (Number(await this.getUsdcBalance(address)) >= 1)
+                    break;
+                await applyTimeout(5000);
+            }
+        }
+        catch {
+            // faucet rate-limited — fall through, caller retries
+        }
+        try {
+            const eth = Number(await this.getNativeBalance(address));
+            if (eth < 0.001) {
+                const hash = await this.faucetEth(address);
+                await this.waitForReceipt(hash);
+                await applyTimeout(5000);
+            }
+        }
+        catch {
+            // ETH faucet rate-limited — fall through
+        }
+        return Number(await this.getUsdcBalance(address)) >= 1;
+    }
+}

package/dist/smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/smoke.js

@@ -0,0 +1,25 @@
+import { ConfidentialPay } from "./index.js";
+import dotenv from "dotenv";
+dotenv.config();
+async function main() {
+    const pay = new ConfidentialPay();
+    console.log(`[smoke] network: ${pay.networkName}`);
+    console.log("[smoke] creating wallet...");
+    const wallet = await pay.getOrCreateWallet("confidential-pay-smoke");
+    console.log(`[smoke] wallet: ${wallet.address}`);
+    if (pay.networkName !== "base-mainnet") {
+        console.log("[smoke] fauceting ETH...");
+        const hash = await pay.faucetEth(wallet.address);
+        console.log(`[smoke] faucet tx: ${hash}`);
+        console.log("[smoke] waiting for faucet receipt...");
+        const receipt = await pay.waitForReceipt(hash);
+        console.log(`[smoke] faucet status: ${receipt.status}`);
+        const usdcBalance = await pay.getUsdcBalance(wallet.address);
+        console.log(`[smoke] usdc balance: ${usdcBalance}`);
+    }
+    console.log("[smoke] DONE — credentials valid, wallet created.");
+}
+main().catch((err) => {
+    console.error("[smoke] FAILED:", err.message ?? err);
+    process.exit(1);
+});

package/dist/transfer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transfer-test.js

@@ -0,0 +1,65 @@
+import { ConfidentialPay } from "./index.js";
+import dotenv from "dotenv";
+dotenv.config();
+async function main() {
+    const pay = new ConfidentialPay();
+    console.log(`[transfer] network: ${pay.networkName}`);
+    const sender = await pay.getOrCreateWallet("sender");
+    const receiver = await pay.getOrCreateWallet("receiver");
+    console.log(`[transfer] sender:   ${sender.address}`);
+    console.log(`[transfer] receiver: ${receiver.address}`);
+    console.log("[transfer] fauceting ETH + USDC...");
+    try {
+        const ethHash = await pay.faucetEth(sender.address);
+        console.log(`[transfer] ETH faucet tx: ${ethHash}`);
+        await pay.waitForReceipt(ethHash);
+    }
+    catch (e) {
+        console.log(`[transfer] ETH faucet skipped: ${e.message ?? e}`);
+    }
+    const senderBal = await pay.getUsdcBalance(sender.address);
+    console.log(`[transfer] sender USDC before: ${senderBal}`);
+    if (Number(senderBal) < 1) {
+        try {
+            const hash = await pay.faucetUsdc(sender.address);
+            console.log(`[transfer] faucet tx: ${hash}`);
+            await pay.waitForReceipt(hash);
+        }
+        catch (e) {
+            console.log(`[transfer] faucet skipped: ${e.message ?? e}`);
+            return;
+        }
+    }
+    // Faucet balance can lag the receipt — poll up to 30s.
+    let received = "0";
+    for (let i = 0; i < 6; i++) {
+        received = await pay.getUsdcBalance(sender.address);
+        if (Number(received) > 0)
+            break;
+        await new Promise((s) => setTimeout(s, 5000));
+    }
+    console.log(`[transfer] sender USDC after faucet: ${received}`);
+    console.log("[transfer] sending 0.5 USDC...");
+    const tx = await pay.sendUsdcPayment({
+        from: sender.address,
+        to: receiver.address,
+        amount: "0.5",
+    });
+    console.log(`[transfer] tx: ${tx.transactionHash}`);
+    const receipt = await pay.waitForReceipt(tx.transactionHash);
+    console.log(`[transfer] status: ${receipt.status}`);
+    const senderAfter = await pay.getUsdcBalance(sender.address);
+    const receiverAfter = await pay.getUsdcBalance(receiver.address);
+    console.log(`[transfer] sender USDC after:   ${senderAfter}`);
+    console.log(`[transfer] receiver USDC after: ${receiverAfter}`);
+    if (Number(receiverAfter) > 0) {
+        console.log("[transfer] SUCCESS — USDC transfer confirmed on Base Sepolia");
+    }
+    else {
+        console.log("[transfer] receiver balance unchanged — investigate");
+    }
+}
+main().catch((err) => {
+    console.error("[transfer] FAILED:", err.message ?? err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@bvdaniel/confidential-pay-core",
+  "version": "0.1.0",
+  "description": "Core wrapper around CDP Non-custodial Wallets for confidential USDC payments on Base.",
+  "keywords": [
+    "confidential",
+    "payments",
+    "usdc",
+    "base",
+    "cdp",
+    "wallets",
+    "crypto"
+  ],
+  "license": "MIT",
+  "author": "a0x-co <hi@a0x.co>",
+  "homepage": "https://a0x-confidential-pay-demo-2w42vltmu-bvdaniels-projects.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a0x-co/a0x-confidential-pay.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/a0x-co/a0x-confidential-pay/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@coinbase/cdp-sdk": "^0.9.0"
+  },
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "viem": "^2.56.1"
+  },
+  "devDependencies": {
+    "@coinbase/cdp-sdk": "^1.55.0",
+    "@types/node": "^22",
+    "typescript": "^5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "smoke": "node --env-file=.env dist/smoke.js",
+    "test:transfer": "node --env-file=.env dist/transfer-test.js",
+    "test": "node --test dist/test/*.test.js"
+  }
+}