@bbuilders/djeon402-sdk-client 1.0.1

package/dist/react/index.cjs

@@ -0,0 +1,1230 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Djeon402Provider: () => Djeon402Provider,
+  useApprove: () => useApprove,
+  useBalance: () => useBalance,
+  useDjeon402: () => useDjeon402,
+  useIsBlacklisted: () => useIsBlacklisted,
+  useKYCData: () => useKYCData,
+  useTokenInfo: () => useTokenInfo,
+  useTransfer: () => useTransfer,
+  useX402Receive: () => useX402Receive,
+  useX402Transfer: () => useX402Transfer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/react/provider.tsx
+var import_react = require("react");
+
+// src/client.ts
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+
+// src/modules/admin.ts
+var import_djeon402_core = require("@bbuilders/djeon402-core");
+var AdminModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get role hashes
+   */
+  async getRoles() {
+    const [minter, burner, pauser, blacklister, admin] = await Promise.all([
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core.DJEON402_ABI,
+        functionName: "MINTER_ROLE"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core.DJEON402_ABI,
+        functionName: "BURNER_ROLE"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core.DJEON402_ABI,
+        functionName: "PAUSER_ROLE"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core.DJEON402_ABI,
+        functionName: "BLACKLISTER_ROLE"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core.DJEON402_ABI,
+        functionName: "DEFAULT_ADMIN_ROLE"
+      })
+    ]);
+    return {
+      MINTER_ROLE: minter,
+      BURNER_ROLE: burner,
+      PAUSER_ROLE: pauser,
+      BLACKLISTER_ROLE: blacklister,
+      DEFAULT_ADMIN_ROLE: admin
+    };
+  }
+  /**
+   * Check if address has role
+   */
+  async hasRole(role, account) {
+    (0, import_djeon402_core.validateAddress)(account);
+    const result = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "hasRole",
+      args: [role, account]
+    });
+    return {
+      role,
+      address: account,
+      hasRole: result
+    };
+  }
+  /**
+   * Check if address is blacklisted
+   */
+  async isBlacklisted(account) {
+    (0, import_djeon402_core.validateAddress)(account);
+    const isBlacklisted = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "isBlacklisted",
+      args: [account]
+    });
+    return {
+      isBlacklisted,
+      address: account
+    };
+  }
+  /**
+   * Blacklist an address
+   */
+  async blacklist(params) {
+    const { walletClient, account } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core.validateAddress)(account);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "blacklist",
+      args: [account],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Remove from blacklist
+   */
+  async unBlacklist(params) {
+    const { walletClient, account } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core.validateAddress)(account);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "unBlacklist",
+      args: [account],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Pause contract
+   */
+  async pause(params) {
+    const { walletClient } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "pause",
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Unpause contract
+   */
+  async unpause(params) {
+    const { walletClient } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core.DJEON402_ABI,
+      functionName: "unpause",
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+};
+
+// src/modules/kyc.ts
+var import_djeon402_core2 = require("@bbuilders/djeon402-core");
+var KYCModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get KYC data for an address
+   */
+  async getData(address) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    (0, import_djeon402_core2.validateAddress)(address);
+    const kycData = await this.sdk.publicClient.readContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "getKYCData",
+      args: [address]
+    });
+    const result = kycData;
+    const [level, expiryDate, kycHash, isActive, dailyLimit, dailySpent] = result;
+    const levelNames = ["None", "Tier1", "Tier2", "Tier3"];
+    const expiryDateReadable = new Date(Number(expiryDate) * 1e3).toISOString();
+    return {
+      level,
+      levelName: levelNames[level],
+      expiryDate: Number(expiryDate),
+      expiryDateReadable,
+      kycHash,
+      isActive,
+      dailyLimit: dailyLimit.toString(),
+      dailyLimitRaw: dailyLimit.toString(),
+      dailySpent: dailySpent.toString(),
+      dailySpentRaw: dailySpent.toString(),
+      userAddress: address
+    };
+  }
+  /**
+   * Get remaining daily limit
+   */
+  async getRemainingLimit(address) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    (0, import_djeon402_core2.validateAddress)(address);
+    const remaining = await this.sdk.publicClient.readContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "getRemainingDailyLimit",
+      args: [address]
+    });
+    return {
+      address,
+      remainingLimit: remaining.toString()
+    };
+  }
+  /**
+   * Verify KYC (admin only)
+   */
+  async verify(params) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    const { walletClient, userAddress, level, expiryDate, documentHash } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    if (level < 0 || level > 3) {
+      throw new Error("Invalid KYC level. Must be 0-3");
+    }
+    const hash = await walletClient.writeContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "verifyKYC",
+      args: [userAddress, level, BigInt(expiryDate), documentHash],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Update KYC level (admin only)
+   */
+  async updateKYC(params) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    const { walletClient, userAddress, level, expiryDate = 0 } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "updateKYC",
+      args: [userAddress, level, BigInt(expiryDate)],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Revoke KYC (admin only)
+   */
+  async revokeKYC(params) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    const { walletClient, userAddress } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "revokeKYC",
+      args: [userAddress],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Set daily limit for a user (admin only)
+   */
+  async setDailyLimit(params) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    const { walletClient, userAddress, limitUSD } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    const limitInSmallestUnit = BigInt(parseFloat(limitUSD) * 1e6);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "setDailyLimit",
+      args: [userAddress, limitInSmallestUnit],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Check if a transaction amount is within the user's daily limit
+   */
+  async checkDailyLimit(params) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    const { walletClient, userAddress, amountUSD } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    const amountInSmallestUnit = BigInt(parseFloat(amountUSD) * 1e6);
+    const result = await walletClient.writeContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "checkDailyLimit",
+      args: [userAddress, amountInSmallestUnit],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    return result;
+  }
+  /**
+   * Check if a user's KYC is valid (view)
+   */
+  async isKYCValid(userAddress) {
+    if (!this.sdk.kycRegistryAddress) {
+      throw new Error("KYC Registry address not configured");
+    }
+    (0, import_djeon402_core2.validateAddress)(userAddress);
+    const result = await this.sdk.publicClient.readContract({
+      address: this.sdk.kycRegistryAddress,
+      abi: import_djeon402_core2.KYC_REGISTRY_ABI,
+      functionName: "isKYCValid",
+      args: [userAddress]
+    });
+    return result;
+  }
+};
+
+// src/modules/token.ts
+var import_djeon402_core3 = require("@bbuilders/djeon402-core");
+var TokenModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get token information
+   */
+  async getInfo() {
+    const [name, symbol, decimals, totalSupply, paused] = await Promise.all([
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "name"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "symbol"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "decimals"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "totalSupply"
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "paused"
+      })
+    ]);
+    return {
+      name,
+      symbol,
+      decimals,
+      totalSupply: (0, import_djeon402_core3.formatTokenAmount)(totalSupply, decimals),
+      totalSupplyRaw: totalSupply.toString(),
+      paused,
+      contractAddress: this.sdk.contractAddress
+    };
+  }
+  /**
+   * Get balance of an address
+   */
+  async getBalance(address) {
+    (0, import_djeon402_core3.validateAddress)(address);
+    const [balance, decimals] = await Promise.all([
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "balanceOf",
+        args: [address]
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "decimals"
+      })
+    ]);
+    return {
+      address,
+      balance: (0, import_djeon402_core3.formatTokenAmount)(balance, decimals),
+      balanceRaw: balance.toString()
+    };
+  }
+  /**
+   * Get allowance
+   */
+  async getAllowance(owner, spender) {
+    (0, import_djeon402_core3.validateAddress)(owner);
+    (0, import_djeon402_core3.validateAddress)(spender);
+    const [allowance, decimals] = await Promise.all([
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "allowance",
+        args: [owner, spender]
+      }),
+      this.sdk.publicClient.readContract({
+        address: this.sdk.contractAddress,
+        abi: import_djeon402_core3.DJEON402_ABI,
+        functionName: "decimals"
+      })
+    ]);
+    return {
+      owner,
+      spender,
+      allowance: (0, import_djeon402_core3.formatTokenAmount)(allowance, decimals),
+      allowanceRaw: allowance.toString()
+    };
+  }
+  /**
+   * Transfer tokens using wallet client
+   */
+  async transfer(params) {
+    const { walletClient, to, amount } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core3.validateAddress)(to);
+    (0, import_djeon402_core3.validateAmount)(amount);
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const amountBigInt = (0, import_djeon402_core3.parseTokenAmount)(amount, decimals);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "transfer",
+      args: [to, amountBigInt],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({
+      hash
+    });
+    return {
+      success: receipt.status === "success",
+      hash,
+      from: walletClient.account.address,
+      to,
+      amount,
+      amountRaw: amountBigInt.toString(),
+      blockNumber: receipt.blockNumber.toString(),
+      status: receipt.status
+    };
+  }
+  /**
+   * Approve spending
+   */
+  async approve(params) {
+    const { walletClient, spender, amount } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core3.validateAddress)(spender);
+    (0, import_djeon402_core3.validateAmount)(amount);
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const amountBigInt = (0, import_djeon402_core3.parseTokenAmount)(amount, decimals);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "approve",
+      args: [spender, amountBigInt],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Mint tokens (requires MINTER_ROLE)
+   */
+  async mint(params) {
+    const { walletClient, to, amount } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core3.validateAddress)(to);
+    (0, import_djeon402_core3.validateAmount)(amount);
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const amountBigInt = (0, import_djeon402_core3.parseTokenAmount)(amount, decimals);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "mint",
+      args: [to, amountBigInt],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Burn tokens (requires BURNER_ROLE)
+   */
+  async burn(params) {
+    const { walletClient, amount } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core3.validateAmount)(amount);
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const amountBigInt = (0, import_djeon402_core3.parseTokenAmount)(amount, decimals);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core3.DJEON402_ABI,
+      functionName: "burn",
+      args: [amountBigInt],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+};
+
+// src/modules/x402.ts
+var import_djeon402_core4 = require("@bbuilders/djeon402-core");
+var X402Module = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Generate a random nonce
+   */
+  generateNonce() {
+    const randomBytes = new Uint8Array(32);
+    crypto.getRandomValues(randomBytes);
+    return `0x${Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  }
+  /**
+   * Get EIP-712 domain separator
+   */
+  async getDomainSeparator() {
+    const domain = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "DOMAIN_SEPARATOR"
+    });
+    return domain;
+  }
+  /**
+   * Get authorization state (whether a nonce has been used)
+   */
+  async getAuthorizationState(authorizer, nonce) {
+    return await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "authorizationState",
+      args: [authorizer, nonce]
+    });
+  }
+  /**
+   * Sign transfer authorization using wallet
+   */
+  async signTransferWithWallet(params) {
+    const { walletClient, to, amount, validAfter = 0n, validBefore, nonce } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core4.validateAddress)(to);
+    (0, import_djeon402_core4.validateAmount)(amount);
+    const from = walletClient.account.address;
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const value = (0, import_djeon402_core4.parseTokenAmount)(amount, decimals);
+    const transferNonce = nonce || this.generateNonce();
+    const validBeforeTimestamp = validBefore ?? BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    const name = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "name"
+    });
+    const domain = {
+      name,
+      version: "1",
+      chainId: this.sdk.chainId,
+      verifyingContract: this.sdk.contractAddress
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from,
+      to,
+      value,
+      validAfter,
+      validBefore: validBeforeTimestamp,
+      nonce: transferNonce
+    };
+    const signature = await walletClient.signTypedData({
+      account: walletClient.account,
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
+    const v = parseInt(signature.slice(130, 132), 16);
+    const r = `0x${signature.slice(2, 66)}`;
+    const s = `0x${signature.slice(66, 130)}`;
+    return {
+      from,
+      to,
+      value,
+      validAfter,
+      validBefore: validBeforeTimestamp,
+      nonce: transferNonce,
+      v,
+      r,
+      s
+    };
+  }
+  /**
+   * Sign receive authorization using wallet (receiver signs)
+   */
+  async signReceiveWithWallet(params) {
+    const { walletClient, from, amount, validAfter = 0n, validBefore, nonce } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    (0, import_djeon402_core4.validateAddress)(from);
+    (0, import_djeon402_core4.validateAmount)(amount);
+    const to = walletClient.account.address;
+    const decimals = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "decimals"
+    });
+    const value = (0, import_djeon402_core4.parseTokenAmount)(amount, decimals);
+    const receiveNonce = nonce || this.generateNonce();
+    const validBeforeTimestamp = validBefore ?? BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    const name = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "name"
+    });
+    const domain = {
+      name,
+      version: "1",
+      chainId: this.sdk.chainId,
+      verifyingContract: this.sdk.contractAddress
+    };
+    const types = {
+      ReceiveWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from,
+      to,
+      value,
+      validAfter,
+      validBefore: validBeforeTimestamp,
+      nonce: receiveNonce
+    };
+    const signature = await walletClient.signTypedData({
+      account: walletClient.account,
+      domain,
+      types,
+      primaryType: "ReceiveWithAuthorization",
+      message
+    });
+    const v = parseInt(signature.slice(130, 132), 16);
+    const r = `0x${signature.slice(2, 66)}`;
+    const s = `0x${signature.slice(66, 130)}`;
+    return {
+      from,
+      to,
+      value,
+      validAfter,
+      validBefore: validBeforeTimestamp,
+      nonce: receiveNonce,
+      v,
+      r,
+      s
+    };
+  }
+  /**
+   * Execute receive with authorization (caller must be the receiver)
+   */
+  async executeReceive(params) {
+    const { walletClient, authorization } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    const { from, to, value, validAfter, validBefore, nonce, v, r, s } = authorization;
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "receiveWithAuthorization",
+      args: [from, to, value, validAfter, validBefore, nonce, v, r, s],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Sign cancel authorization using wallet
+   */
+  async signCancelWithWallet(params) {
+    const { walletClient, authorizer, nonce: authNonce } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    const name = await this.sdk.publicClient.readContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "name"
+    });
+    const domain = {
+      name,
+      version: "1",
+      chainId: this.sdk.chainId,
+      verifyingContract: this.sdk.contractAddress
+    };
+    const types = {
+      CancelAuthorization: [
+        { name: "authorizer", type: "address" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = { authorizer, nonce: authNonce };
+    const signature = await walletClient.signTypedData({
+      account: walletClient.account,
+      domain,
+      types,
+      primaryType: "CancelAuthorization",
+      message
+    });
+    const v = parseInt(signature.slice(130, 132), 16);
+    const r = `0x${signature.slice(2, 66)}`;
+    const s = `0x${signature.slice(66, 130)}`;
+    return { authorizer, nonce: authNonce, v, r, s };
+  }
+  /**
+   * Cancel an authorization (marks nonce as used)
+   */
+  async cancelAuthorization(params) {
+    const { walletClient } = params;
+    const { authorizer, nonce, v, r, s } = await this.signCancelWithWallet(params);
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "cancelAuthorization",
+      args: [authorizer, nonce, v, r, s],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Execute transfer with authorization (relayer function)
+   */
+  async executeTransfer(params) {
+    const { walletClient, authorization } = params;
+    if (!walletClient.account) {
+      throw new Error("Wallet client must have an account");
+    }
+    const { from, to, value, validAfter, validBefore, nonce, v, r, s } = authorization;
+    const hash = await walletClient.writeContract({
+      address: this.sdk.contractAddress,
+      abi: import_djeon402_core4.DJEON402_ABI,
+      functionName: "transferWithAuthorization",
+      args: [from, to, value, validAfter, validBefore, nonce, v, r, s],
+      account: walletClient.account,
+      chain: walletClient.chain
+    });
+    const receipt = await this.sdk.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      success: receipt.status === "success",
+      hash,
+      blockNumber: receipt.blockNumber.toString()
+    };
+  }
+  /**
+   * Fetch wrapper that auto-handles 402 Payment Required responses.
+   * On 402, decodes PAYMENT-REQUIRED header, signs authorization, retries with PAYMENT-SIGNATURE.
+   */
+  async fetchWithPayment(walletClient, url, options = {}) {
+    const response = await fetch(url, options);
+    if (response.status !== 402) return response;
+    const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) {
+      throw new Error("402 response missing PAYMENT-REQUIRED header");
+    }
+    const paymentRequired = JSON.parse(atob(paymentRequiredHeader));
+    const accepted = paymentRequired.accepts?.[0];
+    if (!accepted) {
+      throw new Error("No accepted payment methods in 402 response");
+    }
+    const authData = await this.signTransferWithWallet({
+      walletClient,
+      to: accepted.payTo,
+      amount: accepted.amount
+    });
+    const paymentPayload = {
+      x402Version: paymentRequired.x402Version || 2,
+      resource: paymentRequired.resource,
+      accepted,
+      payload: {
+        signature: `0x${authData.r.slice(2)}${authData.s.slice(2)}${authData.v.toString(16).padStart(2, "0")}`,
+        authorization: {
+          from: authData.from,
+          to: authData.to,
+          value: authData.value.toString(),
+          validAfter: authData.validAfter.toString(),
+          validBefore: authData.validBefore.toString(),
+          nonce: authData.nonce
+        }
+      }
+    };
+    const encoded = btoa(JSON.stringify(paymentPayload));
+    return fetch(url, {
+      ...options,
+      headers: {
+        ...Object.fromEntries(new Headers(options.headers).entries()),
+        "PAYMENT-SIGNATURE": encoded
+      }
+    });
+  }
+};
+
+// src/client.ts
+var Djeon402ClientSDK = class {
+  constructor(config) {
+    const { rpcUrl, contractAddress, kycRegistryAddress, chainId } = config;
+    this.contractAddress = contractAddress;
+    this.kycRegistryAddress = kycRegistryAddress;
+    this.chainId = chainId;
+    const chain = chainId === 8453 ? import_chains.base : {
+      id: chainId,
+      name: "Custom Chain",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: [rpcUrl || ""] },
+        public: { http: [rpcUrl || ""] }
+      }
+    };
+    this.publicClient = (0, import_viem.createPublicClient)({
+      chain,
+      transport: (0, import_viem.http)(rpcUrl)
+    });
+    this.token = new TokenModule(this);
+    this.admin = new AdminModule(this);
+    this.kyc = new KYCModule(this);
+    this.x402 = new X402Module(this);
+  }
+  /**
+   * Get chain configuration
+   */
+  getChain() {
+    return this.chainId === 8453 ? import_chains.base : {
+      id: this.chainId,
+      name: "Custom Chain",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: [this.publicClient.transport.url || ""] },
+        public: { http: [this.publicClient.transport.url || ""] }
+      }
+    };
+  }
+};
+
+// src/react/provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var Djeon402Context = (0, import_react.createContext)(null);
+function Djeon402Provider({
+  children,
+  config
+}) {
+  const sdk = (0, import_react.useMemo)(() => {
+    return new Djeon402ClientSDK({
+      contractAddress: config.contractAddress,
+      kycRegistryAddress: config.kycRegistryAddress,
+      chainId: config.chainId,
+      rpcUrl: config.rpcUrl || ""
+    });
+  }, [config.contractAddress, config.kycRegistryAddress, config.chainId, config.rpcUrl]);
+  const value = (0, import_react.useMemo)(() => ({ sdk, config }), [sdk, config]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Djeon402Context.Provider, { value, children });
+}
+function useDjeon402() {
+  const context = (0, import_react.useContext)(Djeon402Context);
+  if (!context) {
+    throw new Error("useDjeon402 must be used within Djeon402Provider");
+  }
+  return context;
+}
+
+// src/react/useApprove.ts
+var import_react_query = require("@tanstack/react-query");
+var import_wagmi = require("wagmi");
+function useApprove() {
+  const { sdk } = useDjeon402();
+  const { data: walletClient } = (0, import_wagmi.useWalletClient)();
+  const queryClient = (0, import_react_query.useQueryClient)();
+  const mutation = (0, import_react_query.useMutation)({
+    mutationFn: async ({ spender, amount }) => {
+      if (!walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      return sdk.token.approve({ walletClient, spender, amount });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["djeon402", "allowance"] });
+    }
+  });
+  return {
+    approve: mutation.mutateAsync,
+    isLoading: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data
+  };
+}
+
+// src/react/useBalance.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useBalance(address) {
+  const { sdk } = useDjeon402();
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["djeon402", "balance", sdk.contractAddress, address],
+    queryFn: () => {
+      if (!address) throw new Error("Address is required");
+      return sdk.token.getBalance(address);
+    },
+    enabled: !!address,
+    staleTime: 1e4
+    // 10 seconds
+  });
+}
+
+// src/react/useIsBlacklisted.ts
+var import_react_query3 = require("@tanstack/react-query");
+function useIsBlacklisted(address) {
+  const { sdk } = useDjeon402();
+  return (0, import_react_query3.useQuery)({
+    queryKey: ["djeon402", "blacklist", sdk.contractAddress, address],
+    queryFn: () => {
+      if (!address) throw new Error("Address is required");
+      return sdk.admin.isBlacklisted(address);
+    },
+    enabled: !!address,
+    staleTime: 3e4
+    // 30 seconds
+  });
+}
+
+// src/react/useKYCData.ts
+var import_react_query4 = require("@tanstack/react-query");
+function useKYCData(address) {
+  const { sdk } = useDjeon402();
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["djeon402", "kyc", sdk.kycRegistryAddress, address],
+    queryFn: () => {
+      if (!address) throw new Error("Address is required");
+      return sdk.kyc.getData(address);
+    },
+    enabled: !!address && !!sdk.kycRegistryAddress,
+    staleTime: 3e4
+    // 30 seconds
+  });
+}
+
+// src/react/useTokenInfo.ts
+var import_react_query5 = require("@tanstack/react-query");
+function useTokenInfo() {
+  const { sdk } = useDjeon402();
+  return (0, import_react_query5.useQuery)({
+    queryKey: ["djeon402", "tokenInfo", sdk.contractAddress],
+    queryFn: () => sdk.token.getInfo(),
+    staleTime: 6e4
+    // 1 minute
+  });
+}
+
+// src/react/useTransfer.ts
+var import_react_query6 = require("@tanstack/react-query");
+var import_wagmi2 = require("wagmi");
+function useTransfer() {
+  const { sdk } = useDjeon402();
+  const { data: walletClient } = (0, import_wagmi2.useWalletClient)();
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  const mutation = (0, import_react_query6.useMutation)({
+    mutationFn: async ({ to, amount }) => {
+      if (!walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      return sdk.token.transfer({ walletClient, to, amount });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["djeon402", "balance"] });
+    }
+  });
+  return {
+    transfer: mutation.mutateAsync,
+    isLoading: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data
+  };
+}
+
+// src/react/useX402Receive.ts
+var import_react_query7 = require("@tanstack/react-query");
+var import_wagmi3 = require("wagmi");
+function useX402Receive() {
+  const { sdk } = useDjeon402();
+  const { data: walletClient } = (0, import_wagmi3.useWalletClient)();
+  const mutation = (0, import_react_query7.useMutation)({
+    mutationFn: async (params) => {
+      if (!walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      return sdk.x402.signReceiveWithWallet({
+        walletClient,
+        ...params
+      });
+    }
+  });
+  return {
+    signReceive: mutation.mutateAsync,
+    isLoading: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    authorization: mutation.data
+  };
+}
+
+// src/react/useX402Transfer.ts
+var import_react_query8 = require("@tanstack/react-query");
+var import_wagmi4 = require("wagmi");
+function useX402Transfer() {
+  const { sdk } = useDjeon402();
+  const { data: walletClient } = (0, import_wagmi4.useWalletClient)();
+  const mutation = (0, import_react_query8.useMutation)({
+    mutationFn: async (params) => {
+      if (!walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      return sdk.x402.signTransferWithWallet({
+        walletClient,
+        ...params
+      });
+    }
+  });
+  return {
+    signTransfer: mutation.mutateAsync,
+    isLoading: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    authorization: mutation.data
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Djeon402Provider,
+  useApprove,
+  useBalance,
+  useDjeon402,
+  useIsBlacklisted,
+  useKYCData,
+  useTokenInfo,
+  useTransfer,
+  useX402Receive,
+  useX402Transfer
+});
+//# sourceMappingURL=index.cjs.map