pepay-streams-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2926 @@
+'use strict';
+
+var viem = require('viem');
+var diamond = require('@pepay-streams/abi/diamond');
+var shared = require('@pepay-streams/shared');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var CampaignsModule = class {
+  constructor(publicClient, walletClient, diamondAddress) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.diamondAddress = diamondAddress;
+  }
+  // ============================================================================
+  // Campaign Creation
+  // ============================================================================
+  /**
+   * Create an Instant Airdrop campaign
+   *
+   * Tokens are immediately claimable by recipients after funding.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.createInstantAirdrop({
+   *   token: '0x...',
+   *   recipients: [
+   *     { address: '0x...', amount: parseEther('100') },
+   *     { address: '0x...', amount: parseEther('50') },
+   *   ],
+   * });
+   * console.log('Campaign created, tx:', result.hash);
+   * ```
+   */
+  async createInstantAirdrop(params) {
+    const wallet = this.requireWallet();
+    const recipients = params.recipients.map((r) => r.address);
+    const amounts = params.recipients.map((r) => r.amount);
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const args = {
+      kind: 0 /* INSTANT */,
+      token: params.token,
+      start: now,
+      end: now,
+      // Instant airdrop - same start/end
+      step: 0n,
+      cliffReleaseTime: 0n,
+      cliffBps: 0,
+      autoClaimIncentiveBps: params.autoClaimIncentiveBps ?? 0,
+      cancelable: params.cancelable ?? true,
+      claimOnce: params.claimOnce ?? true,
+      changePolicy: this.changePolicyToEnum(params.changePolicy),
+      claimGrace: BigInt(params.claimGrace ?? 0),
+      recipients,
+      amounts,
+      feeBuffer: params.feeBuffer ?? 0n,
+      attachDefaultRegistry: params.attachDefaultRegistry ?? false,
+      unwrapWETH: params.unwrapWETH ?? false,
+      weth: params.weth ?? viem.zeroAddress
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createCampaign",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a Vested Airdrop campaign
+   *
+   * Tokens vest linearly over time with optional cliff period.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.createVestedAirdrop({
+   *   token: '0x...',
+   *   recipients: [
+   *     { address: '0x...', amount: parseEther('1000') },
+   *   ],
+   *   startTime: Math.floor(Date.now() / 1000), // Start now
+   *   duration: 365 * 24 * 60 * 60, // 1 year
+   *   cliffDuration: 90 * 24 * 60 * 60, // 3 month cliff
+   *   steps: 12, // Monthly releases
+   * });
+   * ```
+   */
+  async createVestedAirdrop(params) {
+    const wallet = this.requireWallet();
+    const recipients = params.recipients.map((r) => r.address);
+    const amounts = params.recipients.map((r) => r.amount);
+    const startTime = BigInt(params.startTime);
+    const endTime = startTime + BigInt(params.duration);
+    const steps = params.steps ?? 1;
+    const step = steps > 1 ? BigInt(params.duration) / BigInt(steps) : 0n;
+    const cliffReleaseTime = params.cliffDuration ? startTime + BigInt(params.cliffDuration) : 0n;
+    const args = {
+      kind: 1 /* VESTED */,
+      token: params.token,
+      start: startTime,
+      end: endTime,
+      step,
+      cliffReleaseTime,
+      cliffBps: params.cliffBps ?? 0,
+      autoClaimIncentiveBps: params.autoClaimIncentiveBps ?? 0,
+      cancelable: params.cancelable ?? true,
+      claimOnce: false,
+      // Vested can claim multiple times
+      changePolicy: this.changePolicyToEnum(params.changePolicy),
+      claimGrace: BigInt(params.claimGrace ?? 0),
+      recipients,
+      amounts,
+      feeBuffer: params.feeBuffer ?? 0n,
+      attachDefaultRegistry: params.attachDefaultRegistry ?? false,
+      unwrapWETH: params.unwrapWETH ?? false,
+      weth: params.weth ?? viem.zeroAddress
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createCampaign",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a Token Lock
+   *
+   * Tokens are locked until a specific unlock time, then fully releasable.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.createLock({
+   *   token: '0x...',
+   *   recipient: '0x...',
+   *   amount: parseEther('1000000'),
+   *   unlockTime: Math.floor(Date.now() / 1000) + 180 * 24 * 60 * 60, // 6 months
+   * });
+   * ```
+   */
+  async createLock(params) {
+    const wallet = this.requireWallet();
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const unlockTime = BigInt(params.unlockTime);
+    const args = {
+      kind: 2 /* LOCK */,
+      token: params.token,
+      start: now,
+      end: unlockTime,
+      step: 0n,
+      cliffReleaseTime: unlockTime,
+      // Lock releases at this time
+      cliffBps: 1e4,
+      // 100% released at cliff
+      autoClaimIncentiveBps: 0,
+      cancelable: params.cancelable ?? false,
+      claimOnce: true,
+      changePolicy: this.changePolicyToEnum(params.changePolicy),
+      claimGrace: 0n,
+      recipients: [params.recipient],
+      amounts: [params.amount],
+      feeBuffer: params.feeBuffer ?? 0n,
+      attachDefaultRegistry: false,
+      unwrapWETH: params.unwrapWETH ?? false,
+      weth: params.weth ?? viem.zeroAddress
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createCampaign",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a Vesting Stream (Payment)
+   *
+   * Single-recipient vesting with optional automation.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.createVesting({
+   *   token: '0x...',
+   *   recipient: '0x...',
+   *   amount: parseEther('120000'), // 120k tokens
+   *   startTime: Math.floor(Date.now() / 1000),
+   *   duration: 365 * 24 * 60 * 60, // 1 year
+   *   cliffDuration: 0, // No cliff
+   *   steps: 12, // Monthly
+   * });
+   * ```
+   */
+  async createVesting(params) {
+    const wallet = this.requireWallet();
+    const startTime = BigInt(params.startTime);
+    const endTime = startTime + BigInt(params.duration);
+    const steps = params.steps ?? 1;
+    const step = steps > 1 ? BigInt(params.duration) / BigInt(steps) : 0n;
+    const cliffReleaseTime = params.cliffDuration ? startTime + BigInt(params.cliffDuration) : 0n;
+    const args = {
+      kind: 3 /* VESTING */,
+      token: params.token,
+      start: startTime,
+      end: endTime,
+      step,
+      cliffReleaseTime,
+      cliffBps: params.cliffBps ?? 0,
+      autoClaimIncentiveBps: params.autoClaimIncentiveBps ?? 0,
+      cancelable: params.cancelable ?? true,
+      claimOnce: false,
+      changePolicy: this.changePolicyToEnum(params.changePolicy),
+      claimGrace: BigInt(params.claimGrace ?? 0),
+      recipients: [params.recipient],
+      amounts: [params.amount],
+      feeBuffer: params.feeBuffer ?? 0n,
+      attachDefaultRegistry: false,
+      unwrapWETH: params.unwrapWETH ?? false,
+      weth: params.weth ?? viem.zeroAddress
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createCampaign",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a campaign with raw CreateArgs
+   *
+   * Low-level function for full control over campaign parameters.
+   */
+  async createCampaign(args) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createCampaign",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Campaign Funding
+  // ============================================================================
+  /**
+   * Fund a campaign using EIP-2612 Permit (gasless approval)
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.fundWithPermit({
+   *   campaignId,
+   *   amount: parseEther('1000'),
+   *   deadline: Math.floor(Date.now() / 1000) + 3600,
+   *   v: 28,
+   *   r: '0x...',
+   *   s: '0x...',
+   * });
+   * ```
+   */
+  async fundWithPermit(params) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "fundWithPermit",
+      args: [
+        params.campaignId,
+        params.amount,
+        params.deadline,
+        params.v,
+        params.r,
+        params.s
+      ]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Fund a campaign using Permit2 (gasless approval)
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.fundWithPermit2({
+   *   campaignId,
+   *   from: userAddress,
+   *   amount: parseEther('1000'),
+   *   permit2Data: encodedPermit2Data,
+   * });
+   * ```
+   */
+  async fundWithPermit2(params) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "fundWithPermit2",
+      args: [
+        params.campaignId,
+        params.from,
+        params.amount,
+        params.permit2Data
+      ]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Return leftover tokens to creator
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.campaigns.returnLeftover(campaignId, parseEther('100'));
+   * ```
+   */
+  async returnLeftover(campaignId, amountToReturn) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "returnLeftover",
+      args: [campaignId, amountToReturn]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Add native tips to a campaign for automation
+   */
+  async addNativeTips(campaignId, tipAmount) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "addNativeTips",
+      args: [campaignId, tipAmount],
+      value: tipAmount
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Campaign Queries
+  // ============================================================================
+  /**
+   * Get campaign summary by ID
+   *
+   * Returns full campaign configuration and state.
+   *
+   * @example
+   * ```typescript
+   * const campaign = await sdk.campaigns.getCampaign(1n);
+   * console.log('Campaign token:', campaign.token);
+   * console.log('Total claimed:', campaign.totalClaimed);
+   * ```
+   */
+  async getCampaign(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "campaignSummary",
+      args: [campaignId]
+    });
+    return this.parseCampaignSummary(campaignId, result);
+  }
+  /**
+   * Get campaign configuration only
+   */
+  async getCampaignConfig(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "campaignConfig",
+      args: [campaignId]
+    });
+    return {
+      kind: Number(result.kind),
+      cancelable: Boolean(result.cancelable),
+      claimOnce: Boolean(result.claimOnce),
+      canceled: Boolean(result.canceled),
+      changePolicy: Number(result.changePolicy),
+      token: result.token,
+      creator: result.creator,
+      cliffBps: Number(result.cliffBps),
+      autoClaimIncentiveBps: Number(result.autoClaimIncentiveBps),
+      start: Number(result.start),
+      end: Number(result.end),
+      step: Number(result.step),
+      canceledAt: Number(result.canceledAt),
+      cliffReleaseTime: Number(result.cliffReleaseTime),
+      claimGrace: Number(result.claimGrace),
+      unwrapWETH: Boolean(result.unwrapWETH),
+      weth: result.weth
+    };
+  }
+  /**
+   * Get campaign state (totals and accounting)
+   */
+  async getCampaignState(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "campaignState",
+      args: [campaignId]
+    });
+    return {
+      totalAllocated: result.totalAllocated,
+      totalClaimed: result.totalClaimed,
+      nativeTips: result.nativeTips,
+      returned: result.returned,
+      feeBuffer: result.feeBuffer,
+      feeLoss: result.feeLoss,
+      totalFunded: result.totalFunded,
+      statusBits: Number(result.statusBits),
+      uniqueRecipients: result.uniqueRecipients
+    };
+  }
+  /**
+   * Get campaign status bits
+   */
+  async getCampaignStatus(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "campaignStatus",
+      args: [campaignId]
+    });
+    return Number(result);
+  }
+  // ============================================================================
+  // Campaign Administration
+  // ============================================================================
+  /**
+   * Pause a campaign (creator or admin only)
+   *
+   * @param campaignId - Campaign ID
+   * @param reason - Pause reason as status bits (e.g., 1 for creator pause)
+   */
+  async pause(campaignId, reason = 1) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "pauseCampaign",
+      args: [campaignId, reason]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Resume a paused campaign
+   *
+   * @param campaignId - Campaign ID
+   * @param clearBits - Status bits to clear (e.g., 1 for creator pause)
+   */
+  async resume(campaignId, clearBits = 1) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "resumeCampaign",
+      args: [campaignId, clearBits]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Finalize a campaign (no more claims possible)
+   */
+  async finalize(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "finalizeCampaign",
+      args: [campaignId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Cancel a campaign and return funds to creator
+   */
+  async cancel(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "cancel",
+      args: [campaignId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Change a recipient address (for blocked recipients)
+   */
+  async changeRecipient(campaignId, fromAddress, toAddress) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "changeRecipient",
+      args: [campaignId, fromAddress, toAddress]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Add recipients to an existing campaign
+   */
+  async addRecipients(campaignId, recipients, amounts, additionalBuffer = 0n) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "addRecipients",
+      args: [campaignId, recipients, amounts, additionalBuffer]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error(
+        "Wallet client required for write operations. Initialize SDK with a signer."
+      );
+    }
+    return this.walletClient;
+  }
+  changePolicyToEnum(policy) {
+    switch (policy) {
+      case "only_recipient":
+        return 0 /* ONLY_RECIPIENT */;
+      case "only_creator":
+        return 1 /* ONLY_CREATOR */;
+      case "both":
+        return 2 /* BOTH */;
+      case "no_one":
+        return 3 /* NO_ONE */;
+      default:
+        return 0 /* ONLY_RECIPIENT */;
+    }
+  }
+  parseCampaignSummary(id, data) {
+    const cfg = data.cfg;
+    const state = data.state;
+    const kindMap = {
+      0: "instant_airdrop",
+      1: "vested_airdrop",
+      2: "lock",
+      3: "vesting"
+    };
+    const kind = Number(cfg.kind);
+    const result = {
+      id,
+      kind: kindMap[kind] ?? "instant_airdrop",
+      token: cfg.token,
+      creator: cfg.creator,
+      name: "",
+      // Not stored on-chain
+      totalAllocated: state.totalAllocated,
+      totalFunded: state.totalFunded,
+      totalClaimed: state.totalClaimed,
+      totalReturned: state.returned,
+      feeLoss: state.feeLoss,
+      feeBuffer: state.feeBuffer,
+      startTime: Number(cfg.start),
+      endTime: Number(cfg.end),
+      cliffTime: Number(cfg.cliffReleaseTime),
+      steps: Number(cfg.step) > 0 ? Math.ceil((Number(cfg.end) - Number(cfg.start)) / Number(cfg.step)) : 1,
+      recipientCount: Number(state.uniqueRecipients),
+      statusBits: Number(state.statusBits),
+      changePolicy: Number(cfg.changePolicy),
+      hasAutomation: (Number(state.statusBits) & 1 << 5) !== 0
+    };
+    if (data.hasRegistry) {
+      result.hasRegistry = true;
+    }
+    if (data.merkleRoot) {
+      result.merkleRoot = data.merkleRoot;
+    }
+    return result;
+  }
+  createTransactionResult(hash) {
+    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
+        };
+      }
+    };
+  }
+};
+var ClaimsModule = class {
+  constructor(publicClient, walletClient, diamondAddress, chainId) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.diamondAddress = diamondAddress;
+    this.chainId = chainId;
+  }
+  // ============================================================================
+  // Standard Claims
+  // ============================================================================
+  /**
+   * Claim vested tokens from a campaign
+   *
+   * For merkle-tree campaigns, requires allocation and proof.
+   * For direct campaigns, allocation should be 0 and proof empty.
+   *
+   * @example
+   * ```typescript
+   * // Direct campaign claim
+   * const result = await sdk.claims.claim({
+   *   campaignId: 1n,
+   *   allocation: 0n,
+   *   proof: [],
+   * });
+   *
+   * // Merkle campaign claim
+   * const result = await sdk.claims.claim({
+   *   campaignId: 1n,
+   *   allocation: parseEther('100'),
+   *   proof: ['0x...', '0x...'],
+   * });
+   * ```
+   */
+  async claim(params) {
+    const wallet = this.requireWallet();
+    let hash;
+    if (params.claimTo) {
+      hash = await wallet.writeContract({
+        chain: wallet.chain,
+        account: wallet.account,
+        address: this.diamondAddress,
+        abi: diamond.DIAMOND_ABI,
+        functionName: "claimTo",
+        args: [
+          params.campaignId,
+          params.claimTo,
+          params.allocation ?? 0n,
+          params.proof ?? []
+        ]
+      });
+    } else {
+      hash = await wallet.writeContract({
+        chain: wallet.chain,
+        account: wallet.account,
+        address: this.diamondAddress,
+        abi: diamond.DIAMOND_ABI,
+        functionName: "claim",
+        args: [
+          params.campaignId,
+          params.allocation ?? 0n,
+          params.proof ?? []
+        ]
+      });
+    }
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Claim from a campaign for multiple recipients in a single transaction
+   *
+   * More gas efficient than multiple individual claims.
+   * For direct allocation campaigns only.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.claims.claimBatch({
+   *   campaignId: 1n,
+   *   recipients: ['0x...', '0x...', '0x...'],
+   * });
+   * ```
+   */
+  async claimBatch(params) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "claimMany",
+      args: [params.campaignId, params.recipients]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Release locked tokens (for Lock campaigns)
+   *
+   * Can only be called after the unlock time has passed.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.claims.releaseLock(campaignId, [recipient1, recipient2]);
+   * ```
+   */
+  async releaseLock(campaignId, recipients) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "releaseLock",
+      args: [campaignId, recipients]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Meta-Transaction Claims (Gasless)
+  // ============================================================================
+  /**
+   * Claim via meta-transaction (gasless for recipient)
+   *
+   * A relayer submits the transaction on behalf of the recipient.
+   * The recipient signs an EIP-712 message off-chain.
+   *
+   * @example
+   * ```typescript
+   * // Recipient signs off-chain
+   * const signedAuth = await sdk.claims.signClaimMessage({
+   *   campaignId,
+   *   allocation: parseEther('100'),
+   *   proof: ['0x...'],
+   *   deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour
+   * });
+   *
+   * // Relayer submits
+   * const result = await sdk.claims.claimWithSig(signedAuth);
+   * ```
+   */
+  async claimWithSig(params) {
+    const wallet = this.requireWallet();
+    const auth = {
+      id: params.campaignId,
+      claimant: params.claimant,
+      payoutTo: params.payoutTo ?? params.claimant,
+      allocation: params.allocation,
+      proofHash: this.computeProofHash(params.proof),
+      deadline: BigInt(params.deadline),
+      nonce: params.nonce
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "claimWithSig",
+      args: [auth, params.proof, params.signature]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Generate the EIP-712 typed data for a claim signature
+   *
+   * The recipient signs this message off-chain.
+   */
+  getClaimTypedData(campaignId, claimant, payoutTo, allocation, proofHash, nonce, deadline) {
+    return {
+      domain: {
+        name: "PepayStreams",
+        version: "1",
+        chainId: this.chainId,
+        verifyingContract: this.diamondAddress
+      },
+      types: {
+        ClaimAuth: [
+          { name: "id", type: "uint256" },
+          { name: "claimant", type: "address" },
+          { name: "payoutTo", type: "address" },
+          { name: "allocation", type: "uint128" },
+          { name: "proofHash", type: "bytes32" },
+          { name: "deadline", type: "uint64" },
+          { name: "nonce", type: "uint256" }
+        ]
+      },
+      primaryType: "ClaimAuth",
+      message: {
+        id: campaignId,
+        claimant,
+        payoutTo,
+        allocation,
+        proofHash,
+        deadline: BigInt(deadline),
+        nonce
+      }
+    };
+  }
+  /**
+   * Sign a claim message for meta-transaction
+   *
+   * Returns the signature that can be submitted by a relayer.
+   */
+  async signClaimMessage(params) {
+    const wallet = this.requireWallet();
+    const claimant = wallet.account.address;
+    const payoutTo = params.payoutTo ?? claimant;
+    const nonce = await this.getClaimNonce(params.campaignId, claimant);
+    const proofHash = this.computeProofHash(params.proof);
+    const typedData = this.getClaimTypedData(
+      params.campaignId,
+      claimant,
+      payoutTo,
+      params.allocation,
+      proofHash,
+      nonce,
+      params.deadline
+    );
+    const signature = await wallet.signTypedData({
+      account: wallet.account,
+      domain: typedData.domain,
+      types: typedData.types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    });
+    return {
+      signature,
+      nonce,
+      deadline: params.deadline,
+      claimant,
+      payoutTo,
+      allocation: params.allocation,
+      proof: params.proof,
+      campaignId: params.campaignId
+    };
+  }
+  /**
+   * Get the current nonce for claim meta-transactions
+   */
+  async getClaimNonce(campaignId, address) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "noncesClaim",
+      args: [campaignId, address]
+    });
+    return result;
+  }
+  // ============================================================================
+  // Claim Status Queries
+  // ============================================================================
+  /**
+   * Get the amount currently claimable for a recipient
+   *
+   * @example
+   * ```typescript
+   * const claimable = await sdk.claims.getClaimable(campaignId, recipientAddress);
+   * console.log('Claimable:', formatEther(claimable));
+   * ```
+   */
+  async getClaimable(campaignId, recipient) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "claimableOf",
+      args: [campaignId, recipient]
+    });
+    return result;
+  }
+  /**
+   * Check if a recipient is blocked from claiming
+   */
+  async isBlocked(campaignId, recipient) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "isBlocked",
+      args: [campaignId, recipient]
+    });
+    return result;
+  }
+  /**
+   * Get vested amount for a recipient (how much has vested so far)
+   */
+  async getVestedAmount(campaignId, recipient, allocation) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "vestedAmount",
+      args: [campaignId, recipient, allocation]
+    });
+    return result;
+  }
+  /**
+   * Get merkle claimed shares for a recipient
+   */
+  async getMerkleClaimedShares(campaignId, recipient) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "merkleClaimedShares",
+      args: [campaignId, recipient]
+    });
+    return result;
+  }
+  /**
+   * Get detailed recipient status for a campaign
+   */
+  async getRecipientStatus(campaignId, recipient, allocation) {
+    const [claimable, blocked, vested, claimed] = await Promise.all([
+      this.getClaimable(campaignId, recipient),
+      this.isBlocked(campaignId, recipient),
+      this.getVestedAmount(campaignId, recipient, allocation),
+      this.getMerkleClaimedShares(campaignId, recipient)
+    ]);
+    return {
+      allocated: allocation,
+      claimed,
+      due: claimable,
+      blocked,
+      fullyVested: vested >= allocation
+    };
+  }
+  /**
+   * Check if a recipient can claim from a campaign
+   */
+  async canClaim(campaignId, recipient) {
+    try {
+      const [claimable, blocked] = await Promise.all([
+        this.getClaimable(campaignId, recipient),
+        this.isBlocked(campaignId, recipient)
+      ]);
+      return claimable > 0n && !blocked;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================================================
+  // Merkle Proof Helpers
+  // ============================================================================
+  /**
+   * Verify a Merkle proof locally
+   *
+   * Useful for validating proofs before submitting transactions.
+   */
+  verifyMerkleProof(root, leaf, proof) {
+    let computedHash = leaf;
+    for (const proofElement of proof) {
+      if (computedHash < proofElement) {
+        computedHash = viem.keccak256(
+          viem.encodePacked(["bytes32", "bytes32"], [computedHash, proofElement])
+        );
+      } else {
+        computedHash = viem.keccak256(
+          viem.encodePacked(["bytes32", "bytes32"], [proofElement, computedHash])
+        );
+      }
+    }
+    return computedHash === root;
+  }
+  /**
+   * Compute Merkle leaf for an allocation
+   */
+  computeMerkleLeaf(address, amount) {
+    return viem.keccak256(viem.encodePacked(["address", "uint256"], [address, amount]));
+  }
+  /**
+   * Compute proof hash for meta-transaction
+   */
+  computeProofHash(proof) {
+    if (proof.length === 0) {
+      return "0x0000000000000000000000000000000000000000000000000000000000000000";
+    }
+    return viem.keccak256(viem.encodePacked(["bytes32[]"], [proof]));
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error(
+        "Wallet client required for write operations. Initialize SDK with a signer."
+      );
+    }
+    return this.walletClient;
+  }
+  createTransactionResult(hash) {
+    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
+        };
+      }
+    };
+  }
+};
+var StakingModule = class {
+  constructor(publicClient, walletClient, diamondAddress) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.diamondAddress = diamondAddress;
+  }
+  // ============================================================================
+  // Staking Operations
+  // ============================================================================
+  /**
+   * Stake tokens in a pool
+   *
+   * Must approve the Diamond contract first.
+   *
+   * @example
+   * ```typescript
+   * await sdk.approve(stakeToken, amount);
+   * const result = await sdk.staking.stake(poolId, amount);
+   * ```
+   */
+  async stake(poolId, amount) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "stake",
+      args: [poolId, amount]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Increase stake in an existing deposit
+   */
+  async increaseStake(poolId, amount) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "increaseStake",
+      args: [poolId, amount]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Unstake all tokens from a pool
+   *
+   * Automatically claims pending rewards.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.staking.unstake(poolId);
+   * ```
+   */
+  async unstake(poolId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "unstake",
+      args: [poolId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Partial unstake - withdraw some tokens but keep position open
+   */
+  async partialUnstake(poolId, amount) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "partialUnstake",
+      args: [poolId, amount]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Emergency unstake - forfeit rewards but get principal back
+   *
+   * Use when pool has issues or you need immediate exit.
+   */
+  async emergencyUnstake(poolId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "emergencyUnstake",
+      args: [poolId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Pool Queries
+  // ============================================================================
+  /**
+   * Get pool information
+   *
+   * @example
+   * ```typescript
+   * const pool = await sdk.staking.getPool(1n);
+   * console.log('Total staked:', formatEther(pool.totalStaked));
+   * ```
+   */
+  async getPool(poolId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "pools",
+      args: [poolId]
+    });
+    return this.parsePoolInfo(poolId, result);
+  }
+  /**
+   * Get total number of staking pools
+   */
+  async getPoolCount() {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "poolCount",
+      args: []
+    });
+    return result;
+  }
+  /**
+   * Get pool stats (runtime state)
+   */
+  async getPoolStats(poolId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "poolStats",
+      args: [poolId]
+    });
+    return {
+      statusBits: result[0],
+      rewardRemaining: result[1],
+      totalStaked: result[2],
+      endAt: Number(result[4]),
+      finalized: result[6],
+      rewardRatePerSecond: result[9]
+    };
+  }
+  // ============================================================================
+  // User Stake Queries
+  // ============================================================================
+  /**
+   * Get user's deposit info for a pool
+   *
+   * @example
+   * ```typescript
+   * const stake = await sdk.staking.getUserDeposit(poolId, address);
+   * console.log('Staked:', formatEther(stake.amount));
+   * ```
+   */
+  async getUserDeposit(poolId, user) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "deposits",
+      args: [poolId, user]
+    });
+    return {
+      amount: result.amount,
+      startAt: Number(result.startAt),
+      rewardDebtRay: result.rewardDebtRay,
+      claimedReward: result.claimedReward,
+      claimedAt: Number(result.claimedAt),
+      active: result.active
+    };
+  }
+  /**
+   * Get comprehensive deposit status for a user
+   */
+  async getDepositStatus(poolId, user) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "depositStatus",
+      args: [poolId, user]
+    });
+    return {
+      active: result[0],
+      stakedAmount: result[1],
+      pendingRewards: result[2],
+      canUnstakeNow: result[3],
+      secondsUntilUnstake: Number(result[4]),
+      totalClaimed: result[5]
+    };
+  }
+  /**
+   * Get pending rewards for a user in a pool
+   */
+  async getPendingRewards(poolId, user) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "pendingReward",
+      args: [poolId, user]
+    });
+    return result;
+  }
+  /**
+   * Check if user can unstake from a pool
+   */
+  async canUnstake(poolId, user) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "canUnstake",
+      args: [poolId, user]
+    });
+    return result;
+  }
+  /**
+   * Get time until user can unstake
+   */
+  async secondsUntilUnstakeable(poolId, user) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "secondsUntilUnstakeable",
+      args: [poolId, user]
+    });
+    return result;
+  }
+  /**
+   * Get user's stake info for a pool (convenience wrapper)
+   *
+   * @example
+   * ```typescript
+   * const stake = await sdk.staking.getUserStake(poolId, address);
+   * console.log('Staked:', formatEther(stake.amount));
+   * console.log('Pending rewards:', formatEther(stake.pendingRewards));
+   * ```
+   */
+  async getUserStake(poolId, user) {
+    const [deposit, pendingRewards] = await Promise.all([
+      this.getUserDeposit(poolId, user),
+      this.getPendingRewards(poolId, user)
+    ]);
+    return {
+      amount: deposit.amount,
+      pendingRewards,
+      lastClaimTime: deposit.claimedAt,
+      stakeTime: deposit.startAt
+    };
+  }
+  // ============================================================================
+  // Utility Functions
+  // ============================================================================
+  /**
+   * Get APY preview for a pool
+   */
+  async getApyPreview(poolId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "apyPreview",
+      args: [poolId]
+    });
+    return {
+      ratePerSecond: result[0],
+      totalStaked: result[1]
+    };
+  }
+  /**
+   * Calculate APY for a pool
+   *
+   * @example
+   * ```typescript
+   * const pool = await sdk.staking.getPool(poolId);
+   * const apy = sdk.staking.calculateApy(pool);
+   * console.log('APY:', apy.toFixed(2), '%');
+   * ```
+   */
+  calculateApy(pool) {
+    if (pool.totalStaked === 0n) {
+      return 0;
+    }
+    const durationInYears = (pool.endTime - pool.startTime) / (365 * 24 * 60 * 60);
+    const rewardRate = Number(pool.rewardBudget) / Number(pool.totalStaked);
+    return rewardRate / durationInYears * 100;
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error(
+        "Wallet client required for write operations. Initialize SDK with a signer."
+      );
+    }
+    return this.walletClient;
+  }
+  parsePoolInfo(id, data) {
+    return {
+      id,
+      stakeToken: data.stake,
+      rewardToken: data.reward,
+      creator: data.creator,
+      totalStaked: data.totalStaked,
+      rewardBudget: data.rewardRemaining,
+      // Current remaining
+      rewardsDistributed: 0n,
+      // Not directly available
+      startTime: 0,
+      // Not in pool struct
+      endTime: Number(data.endAt),
+      minStake: 0n,
+      // Not in pool struct
+      maxStake: data.cap,
+      stakerCount: 0,
+      // Not in pool struct
+      isActive: !(data.statusBits > 0),
+      isFinalized: data.finalized
+    };
+  }
+  createTransactionResult(hash) {
+    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
+        };
+      }
+    };
+  }
+};
+var MarketplaceModule = class {
+  constructor(publicClient, walletClient, diamondAddress) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.diamondAddress = diamondAddress;
+  }
+  // ============================================================================
+  // Order Creation
+  // ============================================================================
+  /**
+   * Create an INSTANT order
+   *
+   * Seller deposits tokens upfront, buyer pays and receives immediately.
+   *
+   * @example
+   * ```typescript
+   * // Approve first
+   * await sdk.approve(sellToken, amount);
+   *
+   * const result = await sdk.marketplace.createInstantOrder({
+   *   sellToken: '0x...',
+   *   sellAmount: parseEther('1000'),
+   *   payToken: zeroAddress, // Native ETH
+   *   pricePerToken: parseEther('0.001'), // 0.001 ETH per token
+   *   expiryTTL: 7 * 24 * 60 * 60, // 7 days
+   * });
+   * ```
+   */
+  async createInstantOrder(params) {
+    const wallet = this.requireWallet();
+    const visibility = params.privateBuyers && params.privateBuyers.length > 0 ? 1 /* PRIVATE */ : 0 /* PUBLIC */;
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1e3) + (params.expiryTTL ?? 7 * 24 * 60 * 60)
+    );
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      sellToken: params.sellToken,
+      sellAmount: params.sellAmount,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createOrderInstant",
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a VESTED order
+   *
+   * Seller deposits tokens that vest over time for the buyer.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.marketplace.createVestedOrder({
+   *   sellToken: '0x...',
+   *   sellAmount: parseEther('10000'),
+   *   payToken: '0x...', // USDC
+   *   pricePerToken: 1000000n, // 1 USDC (6 decimals)
+   *   vestingDuration: 365 * 24 * 60 * 60, // 1 year
+   *   cliffDuration: 30 * 24 * 60 * 60, // 30 day cliff
+   *   startMode: 'upon_fill', // Vesting starts when order is filled
+   * });
+   * ```
+   */
+  async createVestedOrder(params) {
+    const wallet = this.requireWallet();
+    const visibility = params.privateBuyers && params.privateBuyers.length > 0 ? 1 /* PRIVATE */ : 0 /* PUBLIC */;
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1e3) + (params.expiryTTL ?? 7 * 24 * 60 * 60)
+    );
+    const cliffBps = params.cliffDuration && params.vestingDuration ? Math.floor(params.cliffDuration / params.vestingDuration * 1e4) : 0;
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      sellToken: params.sellToken,
+      sellAmount: params.sellAmount,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry,
+      vest: {
+        startMode: params.startMode === "fixed_timestamp" ? 1 /* FIXED_TIMESTAMP */ : 0 /* UPON_FILL */,
+        startAt: BigInt(params.fixedStartTime ?? 0),
+        durationSec: params.vestingDuration,
+        stepSec: 0,
+        // Linear vesting
+        cliffBps
+      }
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createOrderVested",
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Create a TRADABLE order
+   *
+   * List an unvested campaign position for sale. No upfront deposit -
+   * the position is transferred when the order is filled.
+   *
+   * @example
+   * ```typescript
+   * // Must have a position in a VestedAirdrop campaign with trading enabled
+   * const result = await sdk.marketplace.createTradableOrder({
+   *   campaignId: 10n,
+   *   pricePerToken: parseEther('0.05'), // 0.05 ETH per token
+   *   payToken: zeroAddress, // Native ETH
+   *   expiryTTL: 30 * 24 * 60 * 60, // 30 days
+   * });
+   * console.log('Order created, tx:', result.hash);
+   * ```
+   */
+  async createTradableOrder(params) {
+    const wallet = this.requireWallet();
+    const visibility = params.privateBuyers && params.privateBuyers.length > 0 ? 1 /* PRIVATE */ : 0 /* PUBLIC */;
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1e3) + (params.expiryTTL ?? 30 * 24 * 60 * 60)
+    );
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      campaignId: params.campaignId,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry,
+      escrowRouting: viem.zeroAddress
+      // Default to no escrow routing
+    };
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "createOrderTradable",
+      args: [args]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Order Settlement
+  // ============================================================================
+  /**
+   * Fill an order (buy)
+   *
+   * For native payment orders, send ETH as value.
+   * For token payment orders, approve the Diamond first.
+   *
+   * @example
+   * ```typescript
+   * // Get quote first
+   * const quote = await sdk.marketplace.getQuote(orderId);
+   *
+   * // Fill with native ETH
+   * const result = await sdk.marketplace.fillOrder(orderId, {
+   *   value: quote.totalPrice,
+   * });
+   *
+   * // Or fill with ERC20 (approve first)
+   * await sdk.approve(payToken, quote.totalPrice);
+   * await sdk.marketplace.fillOrder(orderId);
+   * ```
+   */
+  async fillOrder(orderId, options) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "fillOrder",
+      args: [orderId],
+      value: options?.value
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Fill an order using Permit2 (gasless token approval)
+   */
+  async fillOrderWithPermit(params) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "fillOrderWithPermit",
+      args: [params.orderId, params.permit2Payload]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Cancel an order (seller only)
+   *
+   * Returns deposited tokens to seller.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.marketplace.cancelOrder(orderId);
+   * ```
+   */
+  async cancelOrder(orderId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "cancelOrder",
+      args: [orderId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Expire an order (anyone can call after expiry)
+   *
+   * Returns deposited tokens to seller.
+   */
+  async expireOrder(orderId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "expireOrder",
+      args: [orderId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Order Queries
+  // ============================================================================
+  /**
+   * Get order information by ID
+   *
+   * @example
+   * ```typescript
+   * const order = await sdk.marketplace.getOrder(1n);
+   * console.log('Seller:', order.seller);
+   * console.log('Price:', formatEther(order.totalPrice));
+   * console.log('Status:', order.status);
+   * ```
+   */
+  async getOrder(orderId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "getOrder",
+      args: [orderId]
+    });
+    return this.parseOrderInfo(result);
+  }
+  /**
+   * Get order quote (price breakdown)
+   *
+   * @example
+   * ```typescript
+   * const quote = await sdk.marketplace.getQuote(orderId);
+   * console.log('Total price:', formatEther(quote.totalPrice));
+   * console.log('Protocol fee:', formatEther(quote.protocolFee));
+   * ```
+   */
+  async getQuote(orderId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "quote",
+      args: [orderId]
+    });
+    const order = await this.getOrder(orderId);
+    return {
+      orderId,
+      totalPrice: result.price,
+      protocolFee: result.feeAmount,
+      buyerReceives: order.sellAmount,
+      sellerReceives: result.proceeds,
+      isValid: order.status === "open" && order.expiresAt > Math.floor(Date.now() / 1e3),
+      expiresAt: order.expiresAt
+    };
+  }
+  /**
+   * Get detailed quote for filling an order
+   */
+  async getQuoteFill(orderId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "quoteFill",
+      args: [orderId]
+    });
+    return result;
+  }
+  /**
+   * Get next order ID (also indicates total orders created)
+   */
+  async getNextOrderId() {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "nextOrderId",
+      args: []
+    });
+    return result;
+  }
+  /**
+   * Get orders by seller with pagination
+   */
+  async getOrdersBySeller(seller, offset = 0, limit = 100) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "ordersOf",
+      args: [seller, BigInt(offset), BigInt(limit)]
+    });
+    return result.map((order) => this.parseOrderInfo(order));
+  }
+  /**
+   * Get orders for a campaign
+   */
+  async getOrdersForCampaign(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "ordersByCampaign",
+      args: [campaignId]
+    });
+    return result;
+  }
+  /**
+   * Get active order for a campaign
+   */
+  async getActiveOrderForCampaign(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "getActiveOrderForCampaign",
+      args: [campaignId]
+    });
+    return result;
+  }
+  /**
+   * Preview available amount to sell for a campaign
+   */
+  async previewAvailableToSell(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "previewAvailableToSell",
+      args: [campaignId]
+    });
+    return {
+      futureUnlockable: result.futureUnlockable,
+      claimableNow: result.claimableNow,
+      asOf: Number(result.asOf)
+    };
+  }
+  /**
+   * Get all open orders
+   */
+  async getOpenOrders(limit = 100) {
+    const nextId = await this.getNextOrderId();
+    const orders = [];
+    for (let i = 0n; i < nextId && orders.length < limit; i++) {
+      try {
+        const order = await this.getOrder(i);
+        if (order.status === "open") {
+          orders.push(order);
+        }
+      } catch {
+      }
+    }
+    return orders;
+  }
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  /**
+   * Check if trading is allowed for a campaign
+   */
+  async isTradingEnabled(campaignId) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "isTradeLocked",
+      args: [campaignId]
+    });
+    return !result;
+  }
+  // ============================================================================
+  // Trade Policy (Creator Functions)
+  // ============================================================================
+  /**
+   * Lock trading for a campaign (creator only)
+   *
+   * Prevents new orders from being created for this campaign.
+   */
+  async lockTrading(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "setTradeLocked",
+      args: [campaignId, true]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Unlock trading for a campaign (creator only)
+   */
+  async unlockTrading(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "setTradeLocked",
+      args: [campaignId, false]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Utility Functions
+  // ============================================================================
+  /**
+   * Calculate total price for a given amount at price per token
+   */
+  calculateTotalPrice(amount, pricePerToken) {
+    return amount * pricePerToken / BigInt(1e18);
+  }
+  /**
+   * Check if payment is in native token (ETH/BNB/etc)
+   */
+  isNativePayment(payToken) {
+    return payToken === viem.zeroAddress;
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error(
+        "Wallet client required for write operations. Initialize SDK with a signer."
+      );
+    }
+    return this.walletClient;
+  }
+  parseOrderInfo(order) {
+    const orderTypeMap = {
+      0: "instant",
+      1: "vested",
+      2: "tradable"
+    };
+    const statusMap = {
+      0: "open",
+      1: "filled",
+      2: "canceled",
+      3: "expired"
+    };
+    const result = {
+      id: order.id,
+      orderType: orderTypeMap[order.kind] ?? "instant",
+      seller: order.seller,
+      sellToken: order.sellToken,
+      sellAmount: order.sellAmount,
+      payToken: order.payToken,
+      totalPrice: order.price,
+      pricePerToken: order.sellAmount > 0n ? order.price * BigInt(1e18) / order.sellAmount : 0n,
+      status: statusMap[order.status] ?? "open",
+      createdAt: 0,
+      // Not stored in Order struct
+      expiresAt: Number(order.expiry)
+    };
+    if (order.campaignId > 0n) {
+      result.campaignId = order.campaignId;
+    }
+    if (order.vest.durationSec > 0) {
+      result.vestingDuration = order.vest.durationSec;
+    }
+    if (order.vest.cliffBps > 0) {
+      result.cliffDuration = Math.floor(order.vest.durationSec * order.vest.cliffBps / 1e4);
+    }
+    return result;
+  }
+  createTransactionResult(hash) {
+    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
+        };
+      }
+    };
+  }
+};
+var AutomationModule = class {
+  constructor(publicClient, walletClient, diamondAddress) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.diamondAddress = diamondAddress;
+  }
+  // ============================================================================
+  // Auto-Withdraw (for Vesting campaigns)
+  // ============================================================================
+  /**
+   * Enable auto-withdraw for a vesting campaign
+   *
+   * Keepers will automatically claim vested tokens on behalf of recipients.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.automation.enableAutoWithdraw({
+   *   campaignId: 1n,
+   *   frequency: 7 * 24 * 60 * 60, // Weekly
+   *   tipAmount: parseEther('0.1'), // 0.1 ETH for keeper
+   * });
+   * ```
+   */
+  async enableAutoWithdraw(params) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "enableAutoWithdraw",
+      args: [params.campaignId, BigInt(params.frequency)],
+      value: params.tipAmount ?? 0n
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Disable auto-withdraw for a campaign
+   *
+   * Returns remaining tip balance to caller.
+   */
+  async disableAutoWithdraw(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "disableAutoWithdraw",
+      args: [campaignId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Auto-Release (for Lock campaigns)
+  // ============================================================================
+  /**
+   * Enable auto-release for a lock campaign
+   *
+   * Keepers will automatically release tokens when unlock time passes.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.automation.enableAutoRelease({
+   *   campaignId: 5n,
+   *   frequency: 3600, // Check every hour
+   *   tipAmount: parseEther('0.05'), // 0.05 ETH for keeper
+   * });
+   * ```
+   */
+  async enableAutoRelease(params) {
+    const wallet = this.requireWallet();
+    const frequency = params.frequency ?? 3600;
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "enableAutoReleaseLock",
+      args: [params.campaignId, BigInt(frequency)],
+      value: params.tipAmount ?? 0n
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Disable auto-release for a lock campaign
+   */
+  async disableAutoRelease(campaignId) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "disableAutoReleaseLock",
+      args: [campaignId]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Automation Status Queries
+  // ============================================================================
+  /**
+   * Get auto-withdraw status for a campaign
+   *
+   * @example
+   * ```typescript
+   * const status = await sdk.automation.getAutoWithdrawStatus(campaignId);
+   * console.log('Enabled:', status.enabled);
+   * console.log('Next run:', new Date(status.nextRun * 1000));
+   * console.log('Tip balance:', formatEther(status.tipBalance));
+   * ```
+   */
+  async getAutoWithdrawStatus(campaignId) {
+    const [config, pendingCount, cursor] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.diamondAddress,
+        abi: diamond.DIAMOND_ABI,
+        functionName: "automationConfig",
+        args: [campaignId]
+      }),
+      this.publicClient.readContract({
+        address: this.diamondAddress,
+        abi: diamond.DIAMOND_ABI,
+        functionName: "recipientsPending",
+        args: [campaignId]
+      }),
+      this.publicClient.readContract({
+        address: this.diamondAddress,
+        abi: diamond.DIAMOND_ABI,
+        functionName: "regCursor",
+        args: [campaignId]
+      })
+    ]);
+    const [enabled, frequency, lastRun] = config;
+    const nextRun = Number(lastRun) + Number(frequency);
+    return {
+      enabled,
+      lastRun: Number(lastRun),
+      nextRun,
+      frequency: Number(frequency),
+      tipBalance: 0n,
+      // Tip balance is managed internally
+      recipientsProcessed: Number(cursor),
+      totalRecipients: Number(pendingCount) + Number(cursor)
+    };
+  }
+  /**
+   * Get auto-release status for a lock campaign
+   */
+  async getAutoReleaseStatus(campaignId) {
+    const config = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "automationLockConfig",
+      args: [campaignId]
+    });
+    const [enabled, frequency, lastRun] = config;
+    const nextRun = Number(lastRun) + Number(frequency);
+    return {
+      enabled,
+      frequency: Number(frequency),
+      lastRun: Number(lastRun),
+      nextRun
+    };
+  }
+  /**
+   * Preview automation for specific recipients
+   */
+  async previewAutomation(campaignId, recipients) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "automationPreviewFor",
+      args: [campaignId, recipients]
+    });
+    return {
+      pendingCount: result[0],
+      nextFeeWei: result[1],
+      escrowWei: result[2]
+    };
+  }
+  /**
+   * Get automation run statistics
+   */
+  async getAutomationStats(campaignId, lockMode = false) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "automationRunStats",
+      args: [campaignId, lockMode]
+    });
+    return {
+      runsObserved: Number(result.runsObserved),
+      avgRecipientsPerRun: Number(result.avgRecipientsPerRun),
+      lastRecipientsProcessed: Number(result.lastRecipientsProcessed),
+      maxRecipientsPerRun: Number(result.maxRecipientsPerRun)
+    };
+  }
+  /**
+   * Check if auto-withdraw is currently runnable
+   *
+   * Returns true if cooldown has passed and there are pending recipients.
+   */
+  async isAutoWithdrawRunnable(campaignId) {
+    const status = await this.getAutoWithdrawStatus(campaignId);
+    const now = Math.floor(Date.now() / 1e3);
+    return status.enabled && now >= status.nextRun && status.recipientsProcessed < status.totalRecipients;
+  }
+  /**
+   * Check if auto-release is currently runnable
+   */
+  async isAutoReleaseRunnable(campaignId) {
+    const status = await this.getAutoReleaseStatus(campaignId);
+    const now = Math.floor(Date.now() / 1e3);
+    return status.enabled && now >= status.nextRun;
+  }
+  // ============================================================================
+  // Keeper Functions (for automation operators)
+  // ============================================================================
+  /**
+   * Execute auto-withdraw for specific recipients (keeper only)
+   *
+   * @example
+   * ```typescript
+   * // Get recipients from registry or external source
+   * const recipients = ['0x...', '0x...', '0x...'];
+   * await sdk.automation.executeAutoWithdraw(campaignId, recipients);
+   * ```
+   */
+  async executeAutoWithdraw(campaignId, recipients) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "autoWithdraw",
+      args: [campaignId, recipients]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Execute auto-withdraw using registry cursor (keeper only)
+   *
+   * Processes up to batchSize recipients from the registry.
+   */
+  async executeAutoWithdrawNext(campaignId, batchSize = 50) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "autoWithdrawNext",
+      args: [campaignId, BigInt(batchSize)]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Execute auto-release for specific recipients (keeper only)
+   */
+  async executeAutoRelease(campaignId, recipients) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "autoReleaseLock",
+      args: [campaignId, recipients]
+    });
+    return this.createTransactionResult(hash);
+  }
+  /**
+   * Execute auto-release using registry cursor (keeper only)
+   */
+  async executeAutoReleaseNext(campaignId, batchSize = 50) {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account,
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "autoReleaseLockNext",
+      args: [campaignId, BigInt(batchSize)]
+    });
+    return this.createTransactionResult(hash);
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error(
+        "Wallet client required for write operations. Initialize SDK with a signer."
+      );
+    }
+    return this.walletClient;
+  }
+  createTransactionResult(hash) {
+    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
+        };
+      }
+    };
+  }
+};
+
+// src/api/index.ts
+var ApiClient = class {
+  baseUrl;
+  chainId;
+  constructor(baseUrl, chainId) {
+    this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    this.chainId = chainId;
+  }
+  // ============================================================================
+  // Campaign Queries
+  // ============================================================================
+  /**
+   * Get campaigns with optional filtering
+   *
+   * @example
+   * ```typescript
+   * const campaigns = await sdk.api.getCampaigns({
+   *   kind: 'vested_airdrop',
+   *   status: 'active',
+   *   page: 1,
+   *   pageSize: 20,
+   * });
+   * ```
+   */
+  async getCampaigns(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.kind) searchParams.set("kind", params.kind);
+    if (params.creator) searchParams.set("creator", params.creator);
+    if (params.token) searchParams.set("token", params.token);
+    if (params.status) searchParams.set("status", params.status);
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    if (params.sortBy) searchParams.set("sortBy", params.sortBy);
+    if (params.sortOrder) searchParams.set("sortOrder", params.sortOrder);
+    searchParams.set("chainId", String(this.chainId));
+    return this.fetch(
+      `/v1/campaigns?${searchParams.toString()}`
+    );
+  }
+  /**
+   * Get a single campaign by ID
+   */
+  async getCampaign(campaignId) {
+    return this.fetch(
+      `/v1/campaigns/${campaignId}?chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get campaign recipients
+   */
+  async getCampaignRecipients(campaignId, params = {}) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("chainId", String(this.chainId));
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    return this.fetch(
+      `/v1/campaigns/${campaignId}/recipients?${searchParams.toString()}`
+    );
+  }
+  /**
+   * Get campaign activity/claims
+   */
+  async getCampaignActivity(campaignId, params = {}) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("chainId", String(this.chainId));
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    return this.fetch(
+      `/v1/campaigns/${campaignId}/activity?${searchParams.toString()}`
+    );
+  }
+  // ============================================================================
+  // Order Queries
+  // ============================================================================
+  /**
+   * Get marketplace orders with optional filtering
+   *
+   * @example
+   * ```typescript
+   * const orders = await sdk.api.getOrders({
+   *   orderType: 'tradable',
+   *   status: 'open',
+   *   sortBy: 'totalPrice',
+   *   sortOrder: 'asc',
+   * });
+   * ```
+   */
+  async getOrders(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.orderType) searchParams.set("orderType", params.orderType);
+    if (params.seller) searchParams.set("seller", params.seller);
+    if (params.sellToken) searchParams.set("sellToken", params.sellToken);
+    if (params.payToken) searchParams.set("payToken", params.payToken);
+    if (params.status) searchParams.set("status", params.status);
+    if (params.campaignId) searchParams.set("campaignId", params.campaignId);
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    if (params.sortBy) searchParams.set("sortBy", params.sortBy);
+    if (params.sortOrder) searchParams.set("sortOrder", params.sortOrder);
+    searchParams.set("chainId", String(this.chainId));
+    return this.fetch(
+      `/v1/marketplace/orders?${searchParams.toString()}`
+    );
+  }
+  /**
+   * Get a single order by ID
+   */
+  async getOrder(orderId) {
+    return this.fetch(
+      `/v1/marketplace/orders/${orderId}?chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get order price quote
+   */
+  async getOrderQuote(orderId) {
+    return this.fetch(
+      `/v1/marketplace/orders/${orderId}/quote?chainId=${this.chainId}`
+    );
+  }
+  // ============================================================================
+  // Staking Queries
+  // ============================================================================
+  /**
+   * Get staking pools with optional filtering
+   */
+  async getStakingPools(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.stakeToken) searchParams.set("stakeToken", params.stakeToken);
+    if (params.rewardToken) searchParams.set("rewardToken", params.rewardToken);
+    if (params.creator) searchParams.set("creator", params.creator);
+    if (params.isActive !== void 0)
+      searchParams.set("isActive", String(params.isActive));
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    searchParams.set("chainId", String(this.chainId));
+    return this.fetch(
+      `/v1/staking/pools?${searchParams.toString()}`
+    );
+  }
+  /**
+   * Get a single staking pool by ID
+   */
+  async getStakingPool(poolId) {
+    return this.fetch(
+      `/v1/staking/pools/${poolId}?chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get stakers for a pool
+   */
+  async getPoolStakers(poolId, params = {}) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("chainId", String(this.chainId));
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    return this.fetch(
+      `/v1/staking/pools/${poolId}/stakers?${searchParams.toString()}`
+    );
+  }
+  // ============================================================================
+  // Wallet Queries
+  // ============================================================================
+  /**
+   * Get wallet activity summary
+   *
+   * @example
+   * ```typescript
+   * const activity = await sdk.api.getWalletActivity(address);
+   * console.log('Campaigns:', activity.campaigns.length);
+   * console.log('Open orders:', activity.openOrders.length);
+   * console.log('Stakes:', activity.stakes.length);
+   * ```
+   */
+  async getWalletActivity(address) {
+    return this.fetch(
+      `/v1/wallets/${address}?chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get wallet claims history
+   */
+  async getWalletClaims(address, params = {}) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("chainId", String(this.chainId));
+    if (params.page) searchParams.set("page", String(params.page));
+    if (params.pageSize) searchParams.set("pageSize", String(params.pageSize));
+    return this.fetch(
+      `/v1/wallets/${address}/claims?${searchParams.toString()}`
+    );
+  }
+  /**
+   * Get wallet positions (campaigns where wallet has allocations)
+   */
+  async getWalletPositions(address) {
+    return this.fetch(
+      `/v1/wallets/${address}/positions?chainId=${this.chainId}`
+    );
+  }
+  // ============================================================================
+  // Token Queries
+  // ============================================================================
+  /**
+   * Search for tokens
+   *
+   * @example
+   * ```typescript
+   * const tokens = await sdk.api.searchTokens('USDC');
+   * ```
+   */
+  async searchTokens(query) {
+    return this.fetch(
+      `/v1/tokens?q=${encodeURIComponent(query)}&chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get token information by address
+   */
+  async getToken(address) {
+    return this.fetch(
+      `/v1/tokens/${address}?chainId=${this.chainId}`
+    );
+  }
+  /**
+   * Get token price
+   */
+  async getTokenPrice(address) {
+    return this.fetch(
+      `/v1/tokens/${address}/price?chainId=${this.chainId}`
+    );
+  }
+  // ============================================================================
+  // Health & Status
+  // ============================================================================
+  /**
+   * Check API health
+   */
+  async health() {
+    return this.fetch("/health");
+  }
+  /**
+   * Get supported chains
+   */
+  async getChains() {
+    return this.fetch("/v1/chains");
+  }
+  // ============================================================================
+  // Actions (Transaction Preparation)
+  // ============================================================================
+  /**
+   * Prepare a claim transaction
+   *
+   * Returns the calldata for a claim transaction.
+   */
+  async prepareClaimTx(params) {
+    return this.fetch("/v1/actions/claim", {
+      method: "POST",
+      body: JSON.stringify({
+        ...params,
+        chainId: this.chainId
+      })
+    });
+  }
+  /**
+   * Prepare a fill order transaction
+   */
+  async prepareFillOrderTx(params) {
+    return this.fetch("/v1/actions/fill-order", {
+      method: "POST",
+      body: JSON.stringify({
+        ...params,
+        chainId: this.chainId
+      })
+    });
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  async fetch(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new ApiError(response.status, error);
+    }
+    return response.json();
+  }
+};
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(`API Error (${status}): ${message}`);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+
+// src/client.ts
+var CHAINS = {
+  1: {
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: ["https://eth.llamarpc.com"] } }
+  },
+  56: {
+    id: 56,
+    name: "BNB Smart Chain",
+    nativeCurrency: { name: "BNB", symbol: "BNB", decimals: 18 },
+    rpcUrls: { default: { http: ["https://bsc-dataseed.binance.org"] } }
+  },
+  31337: {
+    id: 31337,
+    name: "Anvil Local",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: ["http://127.0.0.1:8545"] } }
+  }
+};
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var WETH_ADDRESSES = {
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+  // WBNB
+  31337: "0x2bdCC0de6bE1f7D2ee689a0342D76F52E8EFABa3"
+  // Local WETH
+};
+var PepayStreamsClient = class {
+  publicClient;
+  walletClient;
+  diamondAddress;
+  chainId;
+  wethAddress;
+  permit2Address;
+  // Modules
+  campaigns;
+  claims;
+  staking;
+  marketplace;
+  automation;
+  api;
+  constructor(config) {
+    this.diamondAddress = config.diamondAddress;
+    this.chainId = config.chainId;
+    this.wethAddress = config.wethAddress ?? WETH_ADDRESSES[config.chainId] ?? "0x0000000000000000000000000000000000000000";
+    this.permit2Address = config.permit2Address ?? PERMIT2_ADDRESS;
+    const chain = CHAINS[config.chainId];
+    this.publicClient = viem.createPublicClient({
+      chain,
+      transport: viem.http(config.rpcUrl)
+    });
+    this.campaigns = new CampaignsModule(
+      this.publicClient,
+      void 0,
+      this.diamondAddress
+    );
+    this.claims = new ClaimsModule(
+      this.publicClient,
+      void 0,
+      this.diamondAddress,
+      this.chainId
+    );
+    this.staking = new StakingModule(
+      this.publicClient,
+      void 0,
+      this.diamondAddress
+    );
+    this.marketplace = new MarketplaceModule(
+      this.publicClient,
+      void 0,
+      this.diamondAddress
+    );
+    this.automation = new AutomationModule(
+      this.publicClient,
+      void 0,
+      this.diamondAddress
+    );
+    if (config.apiBaseUrl) {
+      this.api = new ApiClient(config.apiBaseUrl, config.chainId);
+    }
+  }
+  /**
+   * Create a client with a wallet for signing transactions
+   */
+  withSigner(walletClient) {
+    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) {
+    if (typeof window === "undefined" || !window.ethereum) {
+      throw new Error("Browser wallet not available");
+    }
+    const ethereum = window.ethereum;
+    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 = viem.createPublicClient({
+      chain,
+      transport: viem.custom(ethereum)
+    });
+    const walletClient = viem.createWalletClient({
+      chain,
+      transport: viem.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) : void 0
+    );
+  }
+  /**
+   * Create a client with private key (for Node.js/scripts)
+   */
+  static fromPrivateKey(config) {
+    const chain = CHAINS[config.chainId];
+    if (!chain) {
+      throw new Error(`Chain ${config.chainId} not supported`);
+    }
+    const publicClient = viem.createPublicClient({
+      chain,
+      transport: viem.http(config.rpcUrl)
+    });
+    const { privateKeyToAccount } = __require("viem/accounts");
+    const account = privateKeyToAccount(config.privateKey);
+    const walletClient = viem.createWalletClient({
+      chain,
+      transport: viem.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) : void 0
+    );
+  }
+  // ============================================================================
+  // Read-only utilities
+  // ============================================================================
+  /**
+   * Get token balance
+   */
+  async getTokenBalance(token, account) {
+    return this.publicClient.readContract({
+      address: token,
+      abi: viem.erc20Abi,
+      functionName: "balanceOf",
+      args: [account]
+    });
+  }
+  /**
+   * Get token allowance for Diamond contract
+   */
+  async getTokenAllowance(token, owner) {
+    return this.publicClient.readContract({
+      address: token,
+      abi: viem.erc20Abi,
+      functionName: "allowance",
+      args: [owner, this.diamondAddress]
+    });
+  }
+  /**
+   * Get token info (symbol, decimals, name)
+   */
+  async getTokenInfo(token) {
+    const [symbol, decimals, name] = await Promise.all([
+      this.publicClient.readContract({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "symbol"
+      }),
+      this.publicClient.readContract({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "decimals"
+      }),
+      this.publicClient.readContract({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "name"
+      })
+    ]);
+    return { symbol, decimals, name };
+  }
+  /**
+   * Get version of a specific facet
+   *
+   * @param facetAddress - The address of the facet to query
+   */
+  async getFacetVersion(facetAddress) {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "getVersion",
+      args: [facetAddress]
+    });
+    return result;
+  }
+  /**
+   * Get all facet versions
+   */
+  async getAllVersions() {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "getAllVersions"
+    });
+    const [facets, versions] = result;
+    return { facets, versions };
+  }
+  /**
+   * Check if Diamond contract is in emergency pause
+   */
+  async isEmergencyPaused() {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: diamond.DIAMOND_ABI,
+      functionName: "isEmergencyPaused"
+    });
+    return result;
+  }
+};
+var PepayStreamsClientWithSigner = class extends PepayStreamsClient {
+  walletClient;
+  campaigns;
+  claims;
+  staking;
+  marketplace;
+  automation;
+  constructor(publicClient, walletClient, diamondAddress, chainId, wethAddress, permit2Address, apiClient) {
+    const config = {
+      rpcUrl: "",
+      // Not used, we pass clients directly
+      diamondAddress,
+      chainId,
+      wethAddress,
+      permit2Address
+    };
+    super(config);
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    if (apiClient) {
+      this.api = apiClient;
+    }
+    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() {
+    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, amount) {
+    const hash = await this.walletClient.writeContract({
+      chain: this.walletClient.chain,
+      account: this.walletClient.account,
+      address: token,
+      abi: viem.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) {
+    const MAX_UINT256 = 2n ** 256n - 1n;
+    return this.approve(token, MAX_UINT256);
+  }
+  /**
+   * Check and approve if needed
+   */
+  async ensureAllowance(token, requiredAmount) {
+    const currentAllowance = await this.getTokenAllowance(
+      token,
+      this.address
+    );
+    if (currentAllowance >= requiredAmount) {
+      return null;
+    }
+    return this.approve(token, requiredAmount);
+  }
+  /**
+   * Get native balance (ETH/BNB)
+   */
+  async getNativeBalance() {
+    return this.publicClient.getBalance({ address: this.address });
+  }
+};
+
+Object.defineProperty(exports, "CampaignKind", {
+  enumerable: true,
+  get: function () { return shared.CampaignKind; }
+});
+Object.defineProperty(exports, "ChangePolicy", {
+  enumerable: true,
+  get: function () { return shared.ChangePolicy; }
+});
+Object.defineProperty(exports, "DeliveryKind", {
+  enumerable: true,
+  get: function () { return shared.DeliveryKind; }
+});
+Object.defineProperty(exports, "OrderStatus", {
+  enumerable: true,
+  get: function () { return shared.OrderStatus; }
+});
+Object.defineProperty(exports, "StartMode", {
+  enumerable: true,
+  get: function () { return shared.StartMode; }
+});
+Object.defineProperty(exports, "StatusBits", {
+  enumerable: true,
+  get: function () { return shared.StatusBits; }
+});
+Object.defineProperty(exports, "Visibility", {
+  enumerable: true,
+  get: function () { return shared.Visibility; }
+});
+exports.ApiClient = ApiClient;
+exports.ApiError = ApiError;
+exports.AutomationModule = AutomationModule;
+exports.CampaignsModule = CampaignsModule;
+exports.ClaimsModule = ClaimsModule;
+exports.MarketplaceModule = MarketplaceModule;
+exports.PepayStreamsClient = PepayStreamsClient;
+exports.PepayStreamsClientWithSigner = PepayStreamsClientWithSigner;
+exports.StakingModule = StakingModule;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map