pepay-streams-sdk 0.1.0

package/src/client.ts

@@ -0,0 +1,518 @@
+/**
+ * Main Pepay Streams SDK Client
+ *
+ * Unified interface for all Pepay Streams operations:
+ * - Campaign creation and management
+ * - Token claiming
+ * - Staking pools
+ * - P2P marketplace
+ * - Automation
+ * - API queries
+ */
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  custom,
+  type PublicClient,
+  type WalletClient,
+  type Address,
+  type Chain,
+  erc20Abi,
+} from 'viem';
+
+// Browser wallet types
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  interface Window {
+    ethereum?: {
+      request: (args: { method: string }) => Promise<Address[]>;
+    };
+  }
+}
+import { DIAMOND_ABI } from '@pepay-streams/abi/diamond';
+import type { PepayStreamsConfig, TransactionResult } from './types';
+import { CampaignsModule } from './campaigns';
+import { ClaimsModule } from './claims';
+import { StakingModule } from './staking';
+import { MarketplaceModule } from './marketplace';
+import { AutomationModule } from './automation';
+import { ApiClient } from './api';
+
+// Chain configurations
+const CHAINS: Record<number, Chain> = {
+  1: {
+    id: 1,
+    name: 'Ethereum',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: { default: { http: ['https://eth.llamarpc.com'] } },
+  } as Chain,
+  56: {
+    id: 56,
+    name: 'BNB Smart Chain',
+    nativeCurrency: { name: 'BNB', symbol: 'BNB', decimals: 18 },
+    rpcUrls: { default: { http: ['https://bsc-dataseed.binance.org'] } },
+  } as Chain,
+  31337: {
+    id: 31337,
+    name: 'Anvil Local',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: { default: { http: ['http://127.0.0.1:8545'] } },
+  } as Chain,
+};
+
+// Canonical addresses
+const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3' as const;
+const WETH_ADDRESSES: Record<number, Address> = {
+  1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  56: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', // WBNB
+  31337: '0x2bdCC0de6bE1f7D2ee689a0342D76F52E8EFABa3', // Local WETH
+};
+
+/**
+ * Pepay Streams SDK Client
+ *
+ * The main entry point for interacting with Pepay Streams protocol.
+ *
+ * @example
+ * ```typescript
+ * import { PepayStreamsClient } from '@pepay-streams/sdk';
+ *
+ * // Read-only client
+ * const client = new PepayStreamsClient({
+ *   rpcUrl: 'https://eth.llamarpc.com',
+ *   diamondAddress: '0x...',
+ *   chainId: 1,
+ * });
+ *
+ * // Client with signer (for transactions)
+ * const clientWithSigner = new PepayStreamsClient({
+ *   rpcUrl: 'https://eth.llamarpc.com',
+ *   diamondAddress: '0x...',
+ *   chainId: 1,
+ * }).withSigner(walletClient);
+ *
+ * // Or use browser wallet
+ * const browserClient = PepayStreamsClient.fromBrowserWallet({
+ *   diamondAddress: '0x...',
+ *   chainId: 1,
+ * });
+ * ```
+ */
+export class PepayStreamsClient {
+  readonly publicClient: PublicClient;
+  readonly walletClient: WalletClient | undefined;
+  readonly diamondAddress: Address;
+  readonly chainId: number;
+  readonly wethAddress: Address;
+  readonly permit2Address: Address;
+
+  // Modules
+  readonly campaigns: CampaignsModule;
+  readonly claims: ClaimsModule;
+  readonly staking: StakingModule;
+  readonly marketplace: MarketplaceModule;
+  readonly automation: AutomationModule;
+  readonly api: ApiClient | undefined;
+
+  constructor(config: PepayStreamsConfig) {
+    this.diamondAddress = config.diamondAddress;
+    this.chainId = config.chainId;
+    this.wethAddress = config.wethAddress ?? WETH_ADDRESSES[config.chainId] ?? '0x0000000000000000000000000000000000000000';
+    this.permit2Address = config.permit2Address ?? PERMIT2_ADDRESS;
+
+    // Create public client
+    const chain = CHAINS[config.chainId];
+    this.publicClient = createPublicClient({
+      chain,
+      transport: http(config.rpcUrl),
+    });
+
+    // Initialize modules
+    this.campaigns = new CampaignsModule(
+      this.publicClient,
+      undefined,
+      this.diamondAddress
+    );
+    this.claims = new ClaimsModule(
+      this.publicClient,
+      undefined,
+      this.diamondAddress,
+      this.chainId
+    );
+    this.staking = new StakingModule(
+      this.publicClient,
+      undefined,
+      this.diamondAddress
+    );
+    this.marketplace = new MarketplaceModule(
+      this.publicClient,
+      undefined,
+      this.diamondAddress
+    );
+    this.automation = new AutomationModule(
+      this.publicClient,
+      undefined,
+      this.diamondAddress
+    );
+
+    // Initialize API client if URL provided
+    if (config.apiBaseUrl) {
+      this.api = new ApiClient(config.apiBaseUrl, config.chainId);
+    }
+  }
+
+  /**
+   * Create a client with a wallet for signing transactions
+   */
+  withSigner(walletClient: WalletClient): PepayStreamsClientWithSigner {
+    return new PepayStreamsClientWithSigner(
+      this.publicClient,
+      walletClient,
+      this.diamondAddress,
+      this.chainId,
+      this.wethAddress,
+      this.permit2Address,
+      this.api
+    );
+  }
+
+  /**
+   * Create a client from browser wallet (window.ethereum)
+   */
+  static async fromBrowserWallet(config: {
+    diamondAddress: Address;
+    chainId: number;
+    apiBaseUrl?: string;
+  }): Promise<PepayStreamsClientWithSigner> {
+    if (typeof window === 'undefined' || !window.ethereum) {
+      throw new Error('Browser wallet not available');
+    }
+
+    const ethereum = window.ethereum;
+
+    // Request account access
+    const accounts = await ethereum.request({
+      method: 'eth_requestAccounts',
+    });
+
+    if (!accounts[0]) {
+      throw new Error('No account available');
+    }
+
+    const chain = CHAINS[config.chainId];
+    if (!chain) {
+      throw new Error(`Chain ${config.chainId} not supported`);
+    }
+
+    const publicClient = createPublicClient({
+      chain,
+      transport: custom(ethereum),
+    });
+
+    const walletClient = createWalletClient({
+      chain,
+      transport: custom(ethereum),
+      account: accounts[0],
+    });
+
+    return new PepayStreamsClientWithSigner(
+      publicClient,
+      walletClient,
+      config.diamondAddress,
+      config.chainId,
+      WETH_ADDRESSES[config.chainId] ?? '0x0000000000000000000000000000000000000000',
+      PERMIT2_ADDRESS,
+      config.apiBaseUrl ? new ApiClient(config.apiBaseUrl, config.chainId) : undefined
+    );
+  }
+
+  /**
+   * Create a client with private key (for Node.js/scripts)
+   */
+  static fromPrivateKey(config: PepayStreamsConfig & { privateKey: `0x${string}` }): PepayStreamsClientWithSigner {
+    const chain = CHAINS[config.chainId];
+    if (!chain) {
+      throw new Error(`Chain ${config.chainId} not supported`);
+    }
+
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(config.rpcUrl),
+    });
+
+    // Import account from private key
+    const { privateKeyToAccount } = require('viem/accounts');
+    const account = privateKeyToAccount(config.privateKey);
+
+    const walletClient = createWalletClient({
+      chain,
+      transport: http(config.rpcUrl),
+      account,
+    });
+
+    return new PepayStreamsClientWithSigner(
+      publicClient,
+      walletClient,
+      config.diamondAddress,
+      config.chainId,
+      config.wethAddress ?? WETH_ADDRESSES[config.chainId] ?? '0x0000000000000000000000000000000000000000',
+      config.permit2Address ?? PERMIT2_ADDRESS,
+      config.apiBaseUrl ? new ApiClient(config.apiBaseUrl, config.chainId) : undefined
+    );
+  }
+
+  // ============================================================================
+  // Read-only utilities
+  // ============================================================================
+
+  /**
+   * Get token balance
+   */
+  async getTokenBalance(token: Address, account: Address): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: 'balanceOf',
+      args: [account],
+    });
+  }
+
+  /**
+   * Get token allowance for Diamond contract
+   */
+  async getTokenAllowance(token: Address, owner: Address): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: 'allowance',
+      args: [owner, this.diamondAddress],
+    });
+  }
+
+  /**
+   * Get token info (symbol, decimals, name)
+   */
+  async getTokenInfo(token: Address): Promise<{
+    symbol: string;
+    decimals: number;
+    name: string;
+  }> {
+    const [symbol, decimals, name] = await Promise.all([
+      this.publicClient.readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: 'symbol',
+      }) as Promise<string>,
+      this.publicClient.readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: 'decimals',
+      }) as Promise<number>,
+      this.publicClient.readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: 'name',
+      }) as Promise<string>,
+    ]);
+
+    return { symbol, decimals, name };
+  }
+
+  /**
+   * Get version of a specific facet
+   *
+   * @param facetAddress - The address of the facet to query
+   */
+  async getFacetVersion(facetAddress: Address): Promise<string> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'getVersion',
+      args: [facetAddress],
+    });
+    return result as string;
+  }
+
+  /**
+   * Get all facet versions
+   */
+  async getAllVersions(): Promise<{ facets: Address[]; versions: string[] }> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'getAllVersions',
+    });
+    const [facets, versions] = result as [Address[], string[]];
+    return { facets, versions };
+  }
+
+  /**
+   * Check if Diamond contract is in emergency pause
+   */
+  async isEmergencyPaused(): Promise<boolean> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'isEmergencyPaused',
+    });
+    return result as boolean;
+  }
+}
+
+/**
+ * Client with signer for write operations
+ */
+export class PepayStreamsClientWithSigner extends PepayStreamsClient {
+  override readonly walletClient: WalletClient;
+  override readonly campaigns: CampaignsModule;
+  override readonly claims: ClaimsModule;
+  override readonly staking: StakingModule;
+  override readonly marketplace: MarketplaceModule;
+  override readonly automation: AutomationModule;
+
+  constructor(
+    publicClient: PublicClient,
+    walletClient: WalletClient,
+    diamondAddress: Address,
+    chainId: number,
+    wethAddress: Address,
+    permit2Address: Address,
+    apiClient?: ApiClient
+  ) {
+    // Create base config
+    const config: PepayStreamsConfig = {
+      rpcUrl: '', // Not used, we pass clients directly
+      diamondAddress,
+      chainId,
+      wethAddress,
+      permit2Address,
+    };
+
+    // Call parent with minimal config
+    super(config);
+
+    // Override with provided clients
+    (this as { publicClient: PublicClient }).publicClient = publicClient;
+    this.walletClient = walletClient;
+    if (apiClient) {
+      (this as { api: ApiClient }).api = apiClient;
+    }
+
+    // Reinitialize modules with wallet client
+    this.campaigns = new CampaignsModule(
+      publicClient,
+      walletClient,
+      diamondAddress
+    );
+    this.claims = new ClaimsModule(
+      publicClient,
+      walletClient,
+      diamondAddress,
+      chainId
+    );
+    this.staking = new StakingModule(
+      publicClient,
+      walletClient,
+      diamondAddress
+    );
+    this.marketplace = new MarketplaceModule(
+      publicClient,
+      walletClient,
+      diamondAddress
+    );
+    this.automation = new AutomationModule(
+      publicClient,
+      walletClient,
+      diamondAddress
+    );
+  }
+
+  /**
+   * Get the connected wallet address
+   */
+  get address(): Address {
+    if (!this.walletClient.account) {
+      throw new Error('No account connected');
+    }
+    return this.walletClient.account.address;
+  }
+
+  // ============================================================================
+  // Token Operations
+  // ============================================================================
+
+  /**
+   * Approve tokens for the Diamond contract
+   *
+   * @example
+   * ```typescript
+   * await client.approve(tokenAddress, parseEther('1000'));
+   * ```
+   */
+  async approve(
+    token: Address,
+    amount: bigint
+  ): Promise<TransactionResult> {
+    const hash = await this.walletClient.writeContract({
+      chain: this.walletClient.chain,
+      account: this.walletClient.account!,
+      address: token,
+      abi: erc20Abi,
+      functionName: 'approve',
+      args: [this.diamondAddress, amount],
+    });
+
+    return {
+      hash,
+      wait: async () => {
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+          hash,
+        });
+        return {
+          blockNumber: receipt.blockNumber,
+          transactionHash: receipt.transactionHash,
+          gasUsed: receipt.gasUsed,
+          status: receipt.status,
+          logs: receipt.logs,
+        };
+      },
+    };
+  }
+
+  /**
+   * Approve max tokens (type(uint256).max)
+   */
+  async approveMax(token: Address): Promise<TransactionResult> {
+    const MAX_UINT256 = 2n ** 256n - 1n;
+    return this.approve(token, MAX_UINT256);
+  }
+
+  /**
+   * Check and approve if needed
+   */
+  async ensureAllowance(
+    token: Address,
+    requiredAmount: bigint
+  ): Promise<TransactionResult | null> {
+    const currentAllowance = await this.getTokenAllowance(
+      token,
+      this.address
+    );
+
+    if (currentAllowance >= requiredAmount) {
+      return null; // Already approved
+    }
+
+    return this.approve(token, requiredAmount);
+  }
+
+  /**
+   * Get native balance (ETH/BNB)
+   */
+  async getNativeBalance(): Promise<bigint> {
+    return this.publicClient.getBalance({ address: this.address });
+  }
+}
+
+export default PepayStreamsClient;

package/src/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Pepay Streams SDK
+ *
+ * TypeScript SDK for interacting with Pepay Streams protocol:
+ * - Token distribution campaigns (airdrops, vesting, locks)
+ * - Staking pools
+ * - P2P marketplace
+ * - Automation
+ *
+ * @packageDocumentation
+ */
+
+// Main client
+export { PepayStreamsClient, PepayStreamsClientWithSigner } from './client';
+
+// Modules
+export { CampaignsModule } from './campaigns';
+export { ClaimsModule } from './claims';
+export { StakingModule } from './staking';
+export { MarketplaceModule } from './marketplace';
+export { AutomationModule } from './automation';
+export { ApiClient, ApiError } from './api';
+
+// Types - Core
+export type {
+  PepayStreamsConfig,
+  TransactionResult,
+  TransactionReceipt,
+} from './types';
+
+// Types - Recipients
+export type {
+  Recipient,
+  RecipientWithCliff,
+  RecipientStatus,
+} from './types';
+
+// Types - Campaigns
+export type {
+  BaseCampaignParams,
+  InstantAirdropParams,
+  VestedAirdropParams,
+  LockParams,
+  VestingParams,
+  CampaignInfo,
+} from './types';
+
+// Types - Staking
+export type {
+  CreatePoolParams,
+  PoolInfo,
+  UserStake,
+} from './types';
+
+// Types - Marketplace
+export type {
+  OrderType,
+  CreateInstantOrderParams,
+  CreateVestedOrderParams,
+  CreateTradableOrderParams,
+  OrderInfo,
+  OrderQuote,
+} from './types';
+
+// Types - Automation
+export type {
+  EnableAutoWithdrawParams,
+  EnableAutoReleaseParams,
+  AutomationStatus,
+} from './types';
+
+// Types - Claims
+export type {
+  ClaimParams,
+  BatchClaimParams,
+  MetaClaimParams,
+  MerkleClaimParams,
+  ClaimResult,
+} from './types';
+
+// Types - API
+export type {
+  PaginatedResponse,
+  ApiCampaign,
+  ApiOrder,
+  ApiStakingPool,
+} from './types';
+
+// Enums from shared
+export {
+  CampaignKind,
+  DeliveryKind,
+  OrderStatus,
+  ChangePolicy,
+  StartMode,
+  Visibility,
+  StatusBits,
+} from './types';
+
+// Re-export viem Address type for convenience
+export type { Address, Hash, Hex } from 'viem';