@flatcash/bearerswap 1.0.0

package/README.md

@@ -0,0 +1,142 @@
+# @flatcash/bearerswap
+
+**Private token transfers on Ethereum.** Send any ERC-20 token without revealing sender-recipient links on-chain.
+
+BearerSwap uses a commit-reveal pattern with a privacy relayer that adds timing randomization, breaking the correlation between deposit and withdrawal.
+
+## Install
+
+```bash
+npm install @flatcash/bearerswap ethers
+```
+
+## Quick Start
+
+```typescript
+import { BearerSwap } from '@flatcash/bearerswap';
+
+// Initialize with your private key (sender)
+const bs = new BearerSwap({
+  privateKey: process.env.PRIVATE_KEY,
+  rpcUrl: 'https://eth.drpc.org',
+});
+
+// 1. Commit tokens (locks them in the contract)
+const { secret, nonce, txHash } = await bs.commit(
+  '0x853d955aCEf822Db058eb8505911ED77F175b99e', // FLAT token
+  '100.0',                                        // amount
+  '0xRecipientAddress...'                         // recipient
+);
+
+console.log(`Committed! TX: ${txHash}`);
+console.log(`Share these with recipient: secret=${secret}, nonce=${nonce}`);
+
+// 2. Deliver (recipient or anyone calls this)
+const delivery = await bs.deliver(secret, recipientAddress, nonce);
+console.log(`Delivery queued! ETA: ${delivery.estimatedDeliveryMinutes} min`);
+```
+
+## How It Works
+
+```
+Sender                    Contract                  Relayer                  Recipient
+  |                          |                        |                        |
+  |-- commit(hash, token) -->|                        |                        |
+  |   (locks tokens + ETH)   |                        |                        |
+  |                          |                        |                        |
+  |--- share secret+nonce ---|------------------------|------> (off-chain) --->|
+  |                          |                        |                        |
+  |                          |                        |<-- deliver(s,r,n) -----|
+  |                          |                        |                        |
+  |                          |   (random 2-45 min)    |                        |
+  |                          |                        |                        |
+  |                          |<--- reveal(s,r,n) -----|                        |
+  |                          |--- tokens + ETH -------|----------------------->|
+```
+
+**Privacy guarantees:**
+- On-chain, the commit contains only a hash — no recipient info
+- The relayer adds a random delay (2–45 min, exponential distribution)
+- The recipient receives tokens + a small ETH stipend for gas
+- No link between sender and recipient is visible on-chain
+
+## API Reference
+
+### `new BearerSwap(config)`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `relayerUrl` | string | `https://flat.cash` | Relayer API URL |
+| `rpcUrl` | string | `https://eth.drpc.org` | Ethereum RPC endpoint |
+| `privateKey` | string | — | Sender's private key |
+| `provider` | ethers.Provider | — | Custom provider |
+| `signer` | ethers.Signer | — | Custom signer |
+
+### `bs.commit(token, amount, recipient, decimals?)`
+
+Locks tokens in the BearerSwap contract. Returns `{ secret, nonce, commitHash, txHash }`.
+
+### `bs.deliver(secret, recipient, nonce)`
+
+Queues the reveal via the relayer. Returns `{ success, estimatedDeliveryMinutes, flatAmount }`.
+
+### `bs.status()`
+
+Returns relayer health: balance, queue size, availability.
+
+### `bs.resolve(identifier)`
+
+Resolves a FlatID username or ENS name to an Ethereum address.
+
+### `BearerSwap.computeHash(secret, recipient, nonce)`
+
+Static helper to compute the commit hash for verification.
+
+## Use Cases
+
+### AI Agent Payments
+```typescript
+// Your autonomous agent pays for services privately
+const bs = new BearerSwap({ privateKey: AGENT_WALLET_KEY });
+const { secret, nonce } = await bs.commit(FLAT_TOKEN, '10.0', serviceProvider);
+// Agent shares secret with service provider via API
+await fetch(serviceProviderUrl, { body: JSON.stringify({ secret, nonce }) });
+```
+
+### Private Payroll
+```typescript
+// Pay employees without revealing individual salaries on-chain
+for (const employee of employees) {
+  const { secret, nonce } = await bs.commit(FLAT_TOKEN, employee.salary, employee.address);
+  await sendEncryptedMessage(employee.email, { secret, nonce });
+}
+```
+
+### Tipping / Donations
+```typescript
+// Anonymous tips to content creators
+const { secret, nonce } = await bs.commit(FLAT_TOKEN, '5.0', creatorAddress);
+// Share via any private channel
+```
+
+## Supported Tokens
+
+Any ERC-20 token on Ethereum mainnet. Primary tokens:
+- **FLAT** (`0x853d955aCEf822Db058eb8505911ED77F175b99e`) — CPI-pegged stablecoin
+- **SAVE** — Locked FLAT with yield
+
+## Contract
+
+- **BearerSwap V3:** `0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566`
+- **Network:** Ethereum Mainnet
+- **Verified on Etherscan:** [View Contract](https://etherscan.io/address/0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566)
+
+## Fees
+
+- **Protocol fee:** 0 (no fees extracted)
+- **Gas:** Sender pays commit gas + ETH stipend (~0.0004 ETH)
+- **Relayer:** Free — operated by the FLAT Protocol
+
+## License
+
+MIT — Flat Protocol team

package/dist/index.d.mts

@@ -0,0 +1,147 @@
+import { ethers } from 'ethers';
+
+/**
+ * @flatcash/bearerswap — Private token transfers on Ethereum
+ *
+ * BearerSwap lets you send ERC-20 tokens privately using a commit-reveal
+ * pattern with a relayer that adds timing randomization for privacy.
+ *
+ * Usage:
+ *   import { BearerSwap } from '@flatcash/bearerswap';
+ *   const bs = new BearerSwap({ relayerUrl: 'https://flat.cash' });
+ *   const { secret, nonce, txHash } = await bs.commit(token, amount, recipient);
+ *   // Share secret + nonce + recipient with the receiver (off-chain)
+ *   const delivery = await bs.deliver(secret, recipient, nonce);
+ */
+
+interface BearerSwapConfig {
+    /** Relayer API base URL (default: https://flat.cash) */
+    relayerUrl?: string;
+    /** Ethereum RPC URL for on-chain operations */
+    rpcUrl?: string;
+    /** Private key for signing commit transactions (sender) */
+    privateKey?: string;
+    /** Ethers provider (alternative to rpcUrl) */
+    provider?: ethers.Provider;
+    /** Ethers signer (alternative to privateKey + provider) */
+    signer?: ethers.Signer;
+}
+interface CommitResult {
+    /** The secret (bytes32) — share with recipient off-chain */
+    secret: string;
+    /** The nonce (bytes32) — share with recipient off-chain */
+    nonce: string;
+    /** The commit hash stored on-chain */
+    commitHash: string;
+    /** Transaction hash of the commit */
+    txHash: string;
+    /** Amount committed (human-readable) */
+    amount: string;
+    /** Token address */
+    token: string;
+    /** Recipient address */
+    recipient: string;
+}
+interface DeliverResult {
+    /** Whether the delivery was queued successfully */
+    success: boolean;
+    /** Current status */
+    status: "queued" | "already_settled";
+    /** Estimated delivery time in minutes (privacy delay) */
+    estimatedDeliveryMinutes: number;
+    /** Amount being delivered (human-readable) */
+    flatAmount: string;
+    /** Recipient address */
+    recipient: string;
+    /** Commit hash */
+    hash: string;
+}
+interface RelayerStatus {
+    /** BearerSwap contract address */
+    contract: string;
+    /** Contract version */
+    version: string;
+    /** Number of reveals pending in queue */
+    pendingInQueue: number;
+    /** ETH stipend sent with each reveal */
+    recipientStipend: string;
+    /** Relayer wallet address */
+    relayerAddress?: string;
+    /** Relayer ETH balance */
+    relayerBalanceEth?: string;
+    /** Whether the contract is paused */
+    contractPaused?: boolean;
+    /** Whether the relayer is available */
+    available?: boolean;
+}
+interface ResolveResult {
+    /** Resolved Ethereum address */
+    address: string;
+    /** Type of identifier resolved */
+    type: "address" | "ens" | "flatid";
+    /** Display name (username or ENS) */
+    displayName: string | null;
+}
+declare const BEARERSWAP_V3_ADDRESS = "0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566";
+declare const BEARERSWAP_V3_ABI: string[];
+declare class BearerSwap {
+    private relayerUrl;
+    private provider;
+    private signer;
+    constructor(config?: BearerSwapConfig);
+    /** Contract address */
+    get contractAddress(): string;
+    /**
+     * Commit tokens on-chain for private transfer.
+     *
+     * This locks tokens in the BearerSwap contract. The returned secret and
+     * nonce must be shared with the recipient off-chain (e.g., via encrypted
+     * message, QR code, or any private channel).
+     *
+     * @param token - ERC-20 token address
+     * @param amount - Amount to send (human-readable, e.g., "100.0")
+     * @param recipient - Recipient Ethereum address
+     * @param decimals - Token decimals (default: 18)
+     */
+    commit(token: string, amount: string, recipient: string, decimals?: number): Promise<CommitResult>;
+    /**
+     * Deliver a committed transfer to the recipient via the relayer.
+     *
+     * The relayer adds a random privacy delay (2–45 min) before executing
+     * the on-chain reveal, breaking timing correlation between commit and reveal.
+     *
+     * @param secret - The secret from the commit step
+     * @param recipient - The recipient address
+     * @param nonce - The nonce from the commit step
+     */
+    deliver(secret: string, recipient: string, nonce: string): Promise<DeliverResult>;
+    /**
+     * Check relayer status (balance, queue size, availability).
+     */
+    status(): Promise<RelayerStatus>;
+    /**
+     * Resolve a FlatID username or ENS name to an Ethereum address.
+     *
+     * @param identifier - FlatID username, ENS name, or Ethereum address
+     */
+    resolve(identifier: string): Promise<ResolveResult>;
+    /**
+     * Check the status of a specific commitment on-chain.
+     *
+     * @param commitHash - The commit hash (bytes32)
+     */
+    getCommitment(commitHash: string): Promise<{
+        sender: string;
+        token: string;
+        amount: bigint;
+        timestamp: bigint;
+        settled: boolean;
+    }>;
+    /**
+     * Compute the commit hash from secret, recipient, and nonce.
+     * Useful for verifying parameters before delivery.
+     */
+    static computeHash(secret: string, recipient: string, nonce: string): string;
+}
+
+export { BEARERSWAP_V3_ABI, BEARERSWAP_V3_ADDRESS, BearerSwap, type BearerSwapConfig, type CommitResult, type DeliverResult, type RelayerStatus, type ResolveResult, BearerSwap as default };

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { ethers } from 'ethers';
+
+/**
+ * @flatcash/bearerswap — Private token transfers on Ethereum
+ *
+ * BearerSwap lets you send ERC-20 tokens privately using a commit-reveal
+ * pattern with a relayer that adds timing randomization for privacy.
+ *
+ * Usage:
+ *   import { BearerSwap } from '@flatcash/bearerswap';
+ *   const bs = new BearerSwap({ relayerUrl: 'https://flat.cash' });
+ *   const { secret, nonce, txHash } = await bs.commit(token, amount, recipient);
+ *   // Share secret + nonce + recipient with the receiver (off-chain)
+ *   const delivery = await bs.deliver(secret, recipient, nonce);
+ */
+
+interface BearerSwapConfig {
+    /** Relayer API base URL (default: https://flat.cash) */
+    relayerUrl?: string;
+    /** Ethereum RPC URL for on-chain operations */
+    rpcUrl?: string;
+    /** Private key for signing commit transactions (sender) */
+    privateKey?: string;
+    /** Ethers provider (alternative to rpcUrl) */
+    provider?: ethers.Provider;
+    /** Ethers signer (alternative to privateKey + provider) */
+    signer?: ethers.Signer;
+}
+interface CommitResult {
+    /** The secret (bytes32) — share with recipient off-chain */
+    secret: string;
+    /** The nonce (bytes32) — share with recipient off-chain */
+    nonce: string;
+    /** The commit hash stored on-chain */
+    commitHash: string;
+    /** Transaction hash of the commit */
+    txHash: string;
+    /** Amount committed (human-readable) */
+    amount: string;
+    /** Token address */
+    token: string;
+    /** Recipient address */
+    recipient: string;
+}
+interface DeliverResult {
+    /** Whether the delivery was queued successfully */
+    success: boolean;
+    /** Current status */
+    status: "queued" | "already_settled";
+    /** Estimated delivery time in minutes (privacy delay) */
+    estimatedDeliveryMinutes: number;
+    /** Amount being delivered (human-readable) */
+    flatAmount: string;
+    /** Recipient address */
+    recipient: string;
+    /** Commit hash */
+    hash: string;
+}
+interface RelayerStatus {
+    /** BearerSwap contract address */
+    contract: string;
+    /** Contract version */
+    version: string;
+    /** Number of reveals pending in queue */
+    pendingInQueue: number;
+    /** ETH stipend sent with each reveal */
+    recipientStipend: string;
+    /** Relayer wallet address */
+    relayerAddress?: string;
+    /** Relayer ETH balance */
+    relayerBalanceEth?: string;
+    /** Whether the contract is paused */
+    contractPaused?: boolean;
+    /** Whether the relayer is available */
+    available?: boolean;
+}
+interface ResolveResult {
+    /** Resolved Ethereum address */
+    address: string;
+    /** Type of identifier resolved */
+    type: "address" | "ens" | "flatid";
+    /** Display name (username or ENS) */
+    displayName: string | null;
+}
+declare const BEARERSWAP_V3_ADDRESS = "0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566";
+declare const BEARERSWAP_V3_ABI: string[];
+declare class BearerSwap {
+    private relayerUrl;
+    private provider;
+    private signer;
+    constructor(config?: BearerSwapConfig);
+    /** Contract address */
+    get contractAddress(): string;
+    /**
+     * Commit tokens on-chain for private transfer.
+     *
+     * This locks tokens in the BearerSwap contract. The returned secret and
+     * nonce must be shared with the recipient off-chain (e.g., via encrypted
+     * message, QR code, or any private channel).
+     *
+     * @param token - ERC-20 token address
+     * @param amount - Amount to send (human-readable, e.g., "100.0")
+     * @param recipient - Recipient Ethereum address
+     * @param decimals - Token decimals (default: 18)
+     */
+    commit(token: string, amount: string, recipient: string, decimals?: number): Promise<CommitResult>;
+    /**
+     * Deliver a committed transfer to the recipient via the relayer.
+     *
+     * The relayer adds a random privacy delay (2–45 min) before executing
+     * the on-chain reveal, breaking timing correlation between commit and reveal.
+     *
+     * @param secret - The secret from the commit step
+     * @param recipient - The recipient address
+     * @param nonce - The nonce from the commit step
+     */
+    deliver(secret: string, recipient: string, nonce: string): Promise<DeliverResult>;
+    /**
+     * Check relayer status (balance, queue size, availability).
+     */
+    status(): Promise<RelayerStatus>;
+    /**
+     * Resolve a FlatID username or ENS name to an Ethereum address.
+     *
+     * @param identifier - FlatID username, ENS name, or Ethereum address
+     */
+    resolve(identifier: string): Promise<ResolveResult>;
+    /**
+     * Check the status of a specific commitment on-chain.
+     *
+     * @param commitHash - The commit hash (bytes32)
+     */
+    getCommitment(commitHash: string): Promise<{
+        sender: string;
+        token: string;
+        amount: bigint;
+        timestamp: bigint;
+        settled: boolean;
+    }>;
+    /**
+     * Compute the commit hash from secret, recipient, and nonce.
+     * Useful for verifying parameters before delivery.
+     */
+    static computeHash(secret: string, recipient: string, nonce: string): string;
+}
+
+export { BEARERSWAP_V3_ABI, BEARERSWAP_V3_ADDRESS, BearerSwap, type BearerSwapConfig, type CommitResult, type DeliverResult, type RelayerStatus, type ResolveResult, BearerSwap as default };

package/dist/index.js

@@ -0,0 +1,218 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BEARERSWAP_V3_ABI: () => BEARERSWAP_V3_ABI,
+  BEARERSWAP_V3_ADDRESS: () => BEARERSWAP_V3_ADDRESS,
+  BearerSwap: () => BearerSwap,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_ethers = require("ethers");
+var BEARERSWAP_V3_ADDRESS = "0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566";
+var BEARERSWAP_V3_ABI = [
+  "function commit(bytes32 hash, address token, uint256 amount) external payable",
+  "function reveal(bytes32 secret, address recipient, bytes32 nonce) external",
+  "function commitments(bytes32 hash) view returns (address sender, address token, uint256 amount, uint256 timestamp, bool settled)",
+  "function paused() view returns (bool)",
+  "function pendingCount() view returns (uint256)",
+  "function getRecommendedETH() view returns (uint256)",
+  "function getMinETH() pure returns (uint256)",
+  "function verifyPreimage(bytes32 secret, address recipient, bytes32 nonce) view returns (bytes32)"
+];
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+];
+var BearerSwap = class {
+  constructor(config = {}) {
+    this.provider = null;
+    this.signer = null;
+    this.relayerUrl = (config.relayerUrl || "https://flat.cash").replace(
+      /\/$/,
+      ""
+    );
+    if (config.signer) {
+      this.signer = config.signer;
+      this.provider = config.signer.provider || null;
+    } else if (config.privateKey) {
+      const provider = config.provider || new import_ethers.ethers.JsonRpcProvider(config.rpcUrl || "https://eth.drpc.org");
+      this.provider = provider;
+      this.signer = new import_ethers.ethers.Wallet(config.privateKey, provider);
+    } else if (config.provider) {
+      this.provider = config.provider;
+    }
+  }
+  /** Contract address */
+  get contractAddress() {
+    return BEARERSWAP_V3_ADDRESS;
+  }
+  /**
+   * Commit tokens on-chain for private transfer.
+   *
+   * This locks tokens in the BearerSwap contract. The returned secret and
+   * nonce must be shared with the recipient off-chain (e.g., via encrypted
+   * message, QR code, or any private channel).
+   *
+   * @param token - ERC-20 token address
+   * @param amount - Amount to send (human-readable, e.g., "100.0")
+   * @param recipient - Recipient Ethereum address
+   * @param decimals - Token decimals (default: 18)
+   */
+  async commit(token, amount, recipient, decimals = 18) {
+    if (!this.signer) {
+      throw new Error(
+        "Signer required for commit. Provide privateKey or signer in config."
+      );
+    }
+    const secret = import_ethers.ethers.hexlify(import_ethers.ethers.randomBytes(32));
+    const nonce = import_ethers.ethers.hexlify(import_ethers.ethers.randomBytes(32));
+    const commitHash = import_ethers.ethers.solidityPackedKeccak256(
+      ["bytes32", "address", "bytes32"],
+      [secret, recipient, nonce]
+    );
+    const amountWei = import_ethers.ethers.parseUnits(amount, decimals);
+    const tokenContract = new import_ethers.ethers.Contract(token, ERC20_ABI, this.signer);
+    const signerAddress = await this.signer.getAddress();
+    const currentAllowance = await tokenContract.allowance(
+      signerAddress,
+      BEARERSWAP_V3_ADDRESS
+    );
+    if (currentAllowance < amountWei) {
+      const approveTx = await tokenContract.approve(
+        BEARERSWAP_V3_ADDRESS,
+        amountWei
+      );
+      await approveTx.wait();
+    }
+    const contract = new import_ethers.ethers.Contract(
+      BEARERSWAP_V3_ADDRESS,
+      BEARERSWAP_V3_ABI,
+      this.signer
+    );
+    const recommendedETH = await contract.getRecommendedETH();
+    const tx = await contract.commit(commitHash, token, amountWei, {
+      value: recommendedETH,
+      gasLimit: 15e4
+    });
+    const receipt = await tx.wait();
+    return {
+      secret,
+      nonce,
+      commitHash,
+      txHash: receipt.hash,
+      amount,
+      token,
+      recipient
+    };
+  }
+  /**
+   * Deliver a committed transfer to the recipient via the relayer.
+   *
+   * The relayer adds a random privacy delay (2–45 min) before executing
+   * the on-chain reveal, breaking timing correlation between commit and reveal.
+   *
+   * @param secret - The secret from the commit step
+   * @param recipient - The recipient address
+   * @param nonce - The nonce from the commit step
+   */
+  async deliver(secret, recipient, nonce) {
+    const response = await fetch(`${this.relayerUrl}/api/bearer/deliver`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ secret, recipient, nonce })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(
+        `Delivery failed (${response.status}): ${error.error || error.details || "Unknown error"}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Check relayer status (balance, queue size, availability).
+   */
+  async status() {
+    const response = await fetch(`${this.relayerUrl}/api/bearer/status`);
+    if (!response.ok) {
+      throw new Error(`Status check failed (${response.status})`);
+    }
+    return response.json();
+  }
+  /**
+   * Resolve a FlatID username or ENS name to an Ethereum address.
+   *
+   * @param identifier - FlatID username, ENS name, or Ethereum address
+   */
+  async resolve(identifier) {
+    const response = await fetch(
+      `${this.relayerUrl}/api/bearer/resolve/${encodeURIComponent(identifier)}`
+    );
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Not found" }));
+      throw new Error(
+        `Resolve failed (${response.status}): ${error.error || "Not found"}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Check the status of a specific commitment on-chain.
+   *
+   * @param commitHash - The commit hash (bytes32)
+   */
+  async getCommitment(commitHash) {
+    const provider = this.provider || new import_ethers.ethers.JsonRpcProvider("https://eth.drpc.org");
+    const contract = new import_ethers.ethers.Contract(
+      BEARERSWAP_V3_ADDRESS,
+      BEARERSWAP_V3_ABI,
+      provider
+    );
+    const result = await contract.commitments(commitHash);
+    return {
+      sender: result.sender,
+      token: result.token,
+      amount: result.amount,
+      timestamp: result.timestamp,
+      settled: result.settled
+    };
+  }
+  /**
+   * Compute the commit hash from secret, recipient, and nonce.
+   * Useful for verifying parameters before delivery.
+   */
+  static computeHash(secret, recipient, nonce) {
+    return import_ethers.ethers.solidityPackedKeccak256(
+      ["bytes32", "address", "bytes32"],
+      [secret, recipient, nonce]
+    );
+  }
+};
+var index_default = BearerSwap;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BEARERSWAP_V3_ABI,
+  BEARERSWAP_V3_ADDRESS,
+  BearerSwap
+});

package/dist/index.mjs

@@ -0,0 +1,191 @@
+// src/index.ts
+import { ethers } from "ethers";
+var BEARERSWAP_V3_ADDRESS = "0x5de315Dab49012c5bbeC41d7a3B25c6829a3e566";
+var BEARERSWAP_V3_ABI = [
+  "function commit(bytes32 hash, address token, uint256 amount) external payable",
+  "function reveal(bytes32 secret, address recipient, bytes32 nonce) external",
+  "function commitments(bytes32 hash) view returns (address sender, address token, uint256 amount, uint256 timestamp, bool settled)",
+  "function paused() view returns (bool)",
+  "function pendingCount() view returns (uint256)",
+  "function getRecommendedETH() view returns (uint256)",
+  "function getMinETH() pure returns (uint256)",
+  "function verifyPreimage(bytes32 secret, address recipient, bytes32 nonce) view returns (bytes32)"
+];
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+];
+var BearerSwap = class {
+  constructor(config = {}) {
+    this.provider = null;
+    this.signer = null;
+    this.relayerUrl = (config.relayerUrl || "https://flat.cash").replace(
+      /\/$/,
+      ""
+    );
+    if (config.signer) {
+      this.signer = config.signer;
+      this.provider = config.signer.provider || null;
+    } else if (config.privateKey) {
+      const provider = config.provider || new ethers.JsonRpcProvider(config.rpcUrl || "https://eth.drpc.org");
+      this.provider = provider;
+      this.signer = new ethers.Wallet(config.privateKey, provider);
+    } else if (config.provider) {
+      this.provider = config.provider;
+    }
+  }
+  /** Contract address */
+  get contractAddress() {
+    return BEARERSWAP_V3_ADDRESS;
+  }
+  /**
+   * Commit tokens on-chain for private transfer.
+   *
+   * This locks tokens in the BearerSwap contract. The returned secret and
+   * nonce must be shared with the recipient off-chain (e.g., via encrypted
+   * message, QR code, or any private channel).
+   *
+   * @param token - ERC-20 token address
+   * @param amount - Amount to send (human-readable, e.g., "100.0")
+   * @param recipient - Recipient Ethereum address
+   * @param decimals - Token decimals (default: 18)
+   */
+  async commit(token, amount, recipient, decimals = 18) {
+    if (!this.signer) {
+      throw new Error(
+        "Signer required for commit. Provide privateKey or signer in config."
+      );
+    }
+    const secret = ethers.hexlify(ethers.randomBytes(32));
+    const nonce = ethers.hexlify(ethers.randomBytes(32));
+    const commitHash = ethers.solidityPackedKeccak256(
+      ["bytes32", "address", "bytes32"],
+      [secret, recipient, nonce]
+    );
+    const amountWei = ethers.parseUnits(amount, decimals);
+    const tokenContract = new ethers.Contract(token, ERC20_ABI, this.signer);
+    const signerAddress = await this.signer.getAddress();
+    const currentAllowance = await tokenContract.allowance(
+      signerAddress,
+      BEARERSWAP_V3_ADDRESS
+    );
+    if (currentAllowance < amountWei) {
+      const approveTx = await tokenContract.approve(
+        BEARERSWAP_V3_ADDRESS,
+        amountWei
+      );
+      await approveTx.wait();
+    }
+    const contract = new ethers.Contract(
+      BEARERSWAP_V3_ADDRESS,
+      BEARERSWAP_V3_ABI,
+      this.signer
+    );
+    const recommendedETH = await contract.getRecommendedETH();
+    const tx = await contract.commit(commitHash, token, amountWei, {
+      value: recommendedETH,
+      gasLimit: 15e4
+    });
+    const receipt = await tx.wait();
+    return {
+      secret,
+      nonce,
+      commitHash,
+      txHash: receipt.hash,
+      amount,
+      token,
+      recipient
+    };
+  }
+  /**
+   * Deliver a committed transfer to the recipient via the relayer.
+   *
+   * The relayer adds a random privacy delay (2–45 min) before executing
+   * the on-chain reveal, breaking timing correlation between commit and reveal.
+   *
+   * @param secret - The secret from the commit step
+   * @param recipient - The recipient address
+   * @param nonce - The nonce from the commit step
+   */
+  async deliver(secret, recipient, nonce) {
+    const response = await fetch(`${this.relayerUrl}/api/bearer/deliver`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ secret, recipient, nonce })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(
+        `Delivery failed (${response.status}): ${error.error || error.details || "Unknown error"}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Check relayer status (balance, queue size, availability).
+   */
+  async status() {
+    const response = await fetch(`${this.relayerUrl}/api/bearer/status`);
+    if (!response.ok) {
+      throw new Error(`Status check failed (${response.status})`);
+    }
+    return response.json();
+  }
+  /**
+   * Resolve a FlatID username or ENS name to an Ethereum address.
+   *
+   * @param identifier - FlatID username, ENS name, or Ethereum address
+   */
+  async resolve(identifier) {
+    const response = await fetch(
+      `${this.relayerUrl}/api/bearer/resolve/${encodeURIComponent(identifier)}`
+    );
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Not found" }));
+      throw new Error(
+        `Resolve failed (${response.status}): ${error.error || "Not found"}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Check the status of a specific commitment on-chain.
+   *
+   * @param commitHash - The commit hash (bytes32)
+   */
+  async getCommitment(commitHash) {
+    const provider = this.provider || new ethers.JsonRpcProvider("https://eth.drpc.org");
+    const contract = new ethers.Contract(
+      BEARERSWAP_V3_ADDRESS,
+      BEARERSWAP_V3_ABI,
+      provider
+    );
+    const result = await contract.commitments(commitHash);
+    return {
+      sender: result.sender,
+      token: result.token,
+      amount: result.amount,
+      timestamp: result.timestamp,
+      settled: result.settled
+    };
+  }
+  /**
+   * Compute the commit hash from secret, recipient, and nonce.
+   * Useful for verifying parameters before delivery.
+   */
+  static computeHash(secret, recipient, nonce) {
+    return ethers.solidityPackedKeccak256(
+      ["bytes32", "address", "bytes32"],
+      [secret, recipient, nonce]
+    );
+  }
+};
+var index_default = BearerSwap;
+export {
+  BEARERSWAP_V3_ABI,
+  BEARERSWAP_V3_ADDRESS,
+  BearerSwap,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@flatcash/bearerswap",
+  "version": "1.0.0",
+  "description": "BearerSwap SDK — Private token transfers on Ethereum. Send any ERC-20 token privately with zero-knowledge commit-reveal.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "keywords": ["ethereum", "privacy", "erc20", "token-transfer", "bearerswap", "flat", "save", "commit-reveal", "private-transfer"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AuditTester1/bearerswap-sdk"
+  },
+  "homepage": "https://flat.cash/developers",
+  "peerDependencies": {
+    "ethers": "^6.0.0"
+  },
+  "devDependencies": {
+    "ethers": "^6.13.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  }
+}