@aastar/sdk 0.20.8 → 0.21.0

package/dist/index.cjs

@@ -0,0 +1,2818 @@
+'use strict';
+
+var chunk3HZEIFBW_cjs = require('./chunk-3HZEIFBW.cjs');
+var chunk63JM67L7_cjs = require('./chunk-63JM67L7.cjs');
+var chunkDEUBKZH5_cjs = require('./chunk-DEUBKZH5.cjs');
+var chunkIJN776TA_cjs = require('./chunk-IJN776TA.cjs');
+var chunkZ4GZ6DQA_cjs = require('./chunk-Z4GZ6DQA.cjs');
+var chunkXQROKLZI_cjs = require('./chunk-XQROKLZI.cjs');
+var chunkM7HXR7G5_cjs = require('./chunk-M7HXR7G5.cjs');
+var chunkWR4OZUXR_cjs = require('./chunk-WR4OZUXR.cjs');
+var chunkY4EJX7UA_cjs = require('./chunk-Y4EJX7UA.cjs');
+var chunkGAMSWXWI_cjs = require('./chunk-GAMSWXWI.cjs');
+var chunk5JFYTJOE_cjs = require('./chunk-5JFYTJOE.cjs');
+var chunkCIEYY3A6_cjs = require('./chunk-CIEYY3A6.cjs');
+var chunkMXJEULSE_cjs = require('./chunk-MXJEULSE.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+var viem = require('viem');
+var accounts = require('viem/accounts');
+var fs = require('fs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+function createEndUserClient({
+  chain,
+  transport,
+  account,
+  addresses
+}) {
+  const client = viem.createClient({
+    chain,
+    transport,
+    account
+  }).extend(viem.publicActions).extend(viem.walletActions);
+  const chainDefaults = chunkMXJEULSE_cjs.getCanonicalAddresses(chain.id);
+  if (!chainDefaults && !addresses) {
+    throw new Error(
+      `[createEndUserClient] No canonical addresses for chainId ${chain.id}. Pass \`addresses\` explicitly, or use a supported chain: ${chunkMXJEULSE_cjs.describeSupportedChains()}.`
+    );
+  }
+  const usedAddresses = { ...chunkMXJEULSE_cjs.CORE_ADDRESSES, ...chunkMXJEULSE_cjs.TOKEN_ADDRESSES, ...chunkMXJEULSE_cjs.TEST_ACCOUNT_ADDRESSES, ...chainDefaults, ...addresses };
+  const actions = {
+    ...chunkCIEYY3A6_cjs.registryActions(usedAddresses.registry)(client),
+    ...chunkCIEYY3A6_cjs.sbtActions(usedAddresses.mySBT)(client),
+    ...chunkCIEYY3A6_cjs.superPaymasterActions(usedAddresses.superPaymaster)(client),
+    ...chunkCIEYY3A6_cjs.paymasterActions(usedAddresses.paymasterV4)(client)
+  };
+  return Object.assign(client, actions, {
+    async onboard({ community, roleId, roleData }) {
+      console.log("\u{1F464} Onboarding user to community...");
+      const result = await this.joinAndActivate({ community, roleId, roleData });
+      console.log(`\u2705 User onboarded! SBT ID: ${result.sbtId}`);
+      return { tx: result.tx, sbtId: result.sbtId };
+    },
+    async joinAndActivate({ community, roleId, roleData }) {
+      const accountToUse = account;
+      if (!accountToUse) throw new Error("Account required for joinAndActivate");
+      console.log(`   SDK: Joining community ${community}...`);
+      let finalData;
+      if (roleData) {
+        finalData = roleData;
+      } else {
+        const { encodeAbiParameters: encodeAbiParameters3 } = await import('viem');
+        finalData = encodeAbiParameters3(
+          [
+            { name: "account", type: "address" },
+            { name: "community", type: "address" },
+            { name: "avatarURI", type: "string" },
+            { name: "ensName", type: "string" },
+            { name: "stakeAmount", type: "uint256" }
+          ],
+          [accountToUse.address, community, "", "", 0n]
+          // Use minimum stake (Registry will use roleConfig.minStake)
+        );
+      }
+      const regTx = await client.writeContract({
+        address: usedAddresses.registry,
+        abi: chunkCIEYY3A6_cjs.RegistryABI,
+        functionName: "registerRoleSelf",
+        args: [roleId, finalData],
+        account: accountToUse,
+        chain
+      });
+      await client.waitForTransactionReceipt({ hash: regTx });
+      const sbtId = await actions.getUserSBT({ user: accountToUse.address });
+      console.log(`   SDK: User joined. SBT ID: ${sbtId}`);
+      let credit = 0n;
+      try {
+        const factoryAbi = viem.parseAbi(["function communityToToken(address) view returns (address)"]);
+        const tokenAddress = await client.readContract({
+          address: usedAddresses.xPNTsFactory,
+          abi: factoryAbi,
+          functionName: "communityToToken",
+          args: [community]
+        });
+        credit = await actions.getAvailableCredit({
+          user: client.aaAddress || accountToUse.address,
+          token: tokenAddress
+        });
+        console.log(`   SDK: Activation complete. Current Credit: ${credit} points.`);
+      } catch (error) {
+        console.log(`   SDK: Credit system not available (${error.message.split("\n")[0]}). Continuing...`);
+      }
+      return {
+        tx: regTx,
+        sbtId,
+        initialCredit: credit
+      };
+    },
+    async executeGasless({ target, data, value = 0n, operator }) {
+      const accountToUse = account;
+      if (!accountToUse) throw new Error("Wallet account required for gasless execution");
+      const { accountAddress } = await this.createSmartAccount({ owner: accountToUse.address });
+      console.log(`   SDK: Executing gasless via AA ${accountAddress} Sponsored by ${operator}`);
+      let nonce = 0n;
+      try {
+        nonce = await client.readContract({
+          address: usedAddresses.entryPoint,
+          abi: [{
+            type: "function",
+            name: "getNonce",
+            inputs: [{ type: "address", name: "sender" }, { type: "uint192", name: "key" }],
+            outputs: [{ type: "uint256" }],
+            stateMutability: "view"
+          }],
+          functionName: "getNonce",
+          args: [accountAddress, 0n]
+          // 0 = default nonce key
+        });
+      } catch (e) {
+        console.warn(`   \u26A0\uFE0F  Failed to fetch nonce from EntryPoint, using default 0:`, e.message);
+        nonce = 0n;
+      }
+      const { encodeFunctionData: encodeFunctionData2, concat: concat2, pad: pad2, keccak256: keccak2565 } = await import('viem');
+      const executeData = encodeFunctionData2({
+        abi: [{ type: "function", name: "execute", inputs: [{ type: "address" }, { type: "uint256" }, { type: "bytes" }] }],
+        functionName: "execute",
+        args: [target, value, data]
+      });
+      const accountGasLimits = concat2([
+        pad2(`0x${1e5.toString(16)}`, { dir: "left", size: 16 }),
+        // verification
+        pad2(`0x${1e5.toString(16)}`, { dir: "left", size: 16 })
+        // call
+      ]);
+      const gasFees = concat2([
+        pad2(`0x${2e9.toString(16)}`, { dir: "left", size: 16 }),
+        // 2 gwei
+        pad2(`0x${2e9.toString(16)}`, { dir: "left", size: 16 })
+        // 2 gwei
+      ]);
+      const paymasterVerificationGas = 250000n;
+      const paymasterPostOpGas = 50000n;
+      const paymasterAndData = concat2([
+        usedAddresses.superPaymaster,
+        pad2(`0x${paymasterVerificationGas.toString(16)}`, { dir: "left", size: 16 }),
+        pad2(`0x${paymasterPostOpGas.toString(16)}`, { dir: "left", size: 16 }),
+        operator
+      ]);
+      const userOp = {
+        sender: accountAddress,
+        nonce,
+        initCode: "0x",
+        callData: executeData,
+        accountGasLimits,
+        preVerificationGas: 50000n,
+        gasFees,
+        paymasterAndData,
+        signature: "0x"
+      };
+      const entryPointAddress = usedAddresses.entryPoint || "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+      const userOpHash = await client.readContract({
+        address: entryPointAddress,
+        abi: [{
+          type: "function",
+          name: "getUserOpHash",
+          inputs: [{
+            type: "tuple",
+            components: [
+              { name: "sender", type: "address" },
+              { name: "nonce", type: "uint256" },
+              { name: "initCode", type: "bytes" },
+              { name: "callData", type: "bytes" },
+              { name: "accountGasLimits", type: "bytes32" },
+              { name: "preVerificationGas", type: "uint256" },
+              { name: "gasFees", type: "bytes32" },
+              { name: "paymasterAndData", type: "bytes" },
+              { name: "signature", type: "bytes" }
+            ]
+          }],
+          outputs: [{ type: "bytes32" }],
+          stateMutability: "view"
+        }],
+        functionName: "getUserOpHash",
+        args: [userOp]
+      });
+      const signature = await accountToUse.signMessage({
+        message: { raw: userOpHash }
+      });
+      userOp.signature = signature;
+      console.log(`   SDK: Submitting UserOp ${userOpHash}...`);
+      const tx = await client.writeContract({
+        address: entryPointAddress,
+        abi: [{
+          type: "function",
+          name: "handleOps",
+          inputs: [
+            {
+              type: "tuple[]",
+              components: [
+                { name: "sender", type: "address" },
+                { name: "nonce", type: "uint256" },
+                { name: "initCode", type: "bytes" },
+                { name: "callData", type: "bytes" },
+                { name: "accountGasLimits", type: "bytes32" },
+                { name: "preVerificationGas", type: "uint256" },
+                { name: "gasFees", type: "bytes32" },
+                { name: "paymasterAndData", type: "bytes" },
+                { name: "signature", type: "bytes" }
+              ]
+            },
+            { name: "beneficiary", type: "address" }
+          ],
+          outputs: [],
+          stateMutability: "nonpayable"
+        }],
+        functionName: "handleOps",
+        args: [[userOp], accountToUse.address],
+        account,
+        chain
+      });
+      await client.waitForTransactionReceipt({ hash: tx });
+      return tx;
+    },
+    async checkJoinRequirements(address) {
+      const accountToUse = address || account?.address;
+      if (!accountToUse) throw new Error("Account address required for requirement check");
+      const { RequirementChecker: RequirementChecker2 } = await import('./src-CUHI6G6W.cjs');
+      const checker = new RequirementChecker2(client, usedAddresses);
+      return await checker.checkRequirements({
+        address: accountToUse,
+        requiredGToken: 440000000000000000n,
+        // 0.44 GT (stake + burn)
+        requireSBT: false
+      });
+    },
+    async createSmartAccount({ owner, salt = 0n }) {
+      const { SimpleAccountFactoryABI: SimpleAccountFactoryABI2 } = await import('./src-CUHI6G6W.cjs');
+      const { encodeFunctionData: encodeFunctionData2, concat: concat2 } = await import('viem');
+      let factoryAddress = usedAddresses.simpleAccountFactory;
+      console.log(`   SDK: Using SimpleAccountFactory: ${factoryAddress} (Owner: ${owner}, Salt: ${salt})`);
+      if (!factoryAddress || factoryAddress === "0x0000000000000000000000000000000000000000") {
+        console.warn("   \u26A0\uFE0F  SimpleAccountFactory not found in configuration. Using default fallback.");
+        factoryAddress = "0x9406Cc6185a346906296840746125a0E44976454";
+      }
+      const accountAddress = await client.readContract({
+        address: factoryAddress,
+        abi: SimpleAccountFactoryABI2,
+        functionName: "getAddress",
+        args: [owner, salt]
+      });
+      const createAccountData = encodeFunctionData2({
+        abi: SimpleAccountFactoryABI2,
+        functionName: "createAccount",
+        args: [owner, salt]
+      });
+      const initCode = concat2([factoryAddress, createAccountData]);
+      const byteCode = await client.getBytecode({ address: accountAddress });
+      const isDeployed = byteCode !== void 0 && byteCode !== "0x";
+      return { accountAddress, initCode, isDeployed };
+    },
+    async deploySmartAccount({ owner, salt = 0n, fundWithETH = 0n }) {
+      const { accountAddress, isDeployed } = await this.createSmartAccount({ owner, salt });
+      const { formatEther: formatEther2 } = await import('viem');
+      let deployHash = "0x0";
+      if (isDeployed) {
+        console.log(`   \u2139\uFE0F Account ${accountAddress} already deployed.`);
+      } else {
+        const { SimpleAccountFactoryABI: SimpleAccountFactoryABI2 } = await import('./src-CUHI6G6W.cjs');
+        let factoryAddress = usedAddresses.simpleAccountFactory;
+        if (!factoryAddress || factoryAddress === "0x0000000000000000000000000000000000000000") {
+          factoryAddress = "0x9406Cc6185a346906296840746125a0E44976454";
+        }
+        console.log(`   \u{1F3ED} Deploying Smart Account for ${owner}...`);
+        deployHash = await client.writeContract({
+          address: factoryAddress,
+          abi: SimpleAccountFactoryABI2,
+          functionName: "createAccount",
+          args: [owner, salt],
+          account,
+          chain
+        });
+        await client.waitForTransactionReceipt({ hash: deployHash });
+        console.log(`   \u2705 Deployed at ${accountAddress}`);
+      }
+      if (fundWithETH > 0n) {
+        console.log(`   \u26FD Funding account with ${formatEther2(fundWithETH)} ETH...`);
+        const tx = await client.sendTransaction({
+          to: accountAddress,
+          value: fundWithETH,
+          account,
+          chain
+        });
+        await client.waitForTransactionReceipt({ hash: tx });
+      }
+      return { accountAddress, deployTxHash: deployHash, isDeployed: true };
+    }
+  });
+}
+var RoleIds = {
+  PAYMASTER_SUPER: viem.keccak256(viem.stringToBytes("PAYMASTER_SUPER")),
+  DVT: viem.keccak256(viem.stringToBytes("DVT")),
+  // Replaced PAYMASTER
+  PAYMASTER_AOA: viem.keccak256(viem.stringToBytes("PAYMASTER_AOA")),
+  KMS: viem.keccak256(viem.stringToBytes("KMS")),
+  COMMUNITY: viem.keccak256(viem.stringToBytes("COMMUNITY")),
+  ENDUSER: viem.keccak256(viem.stringToBytes("ENDUSER")),
+  ANODE: viem.keccak256(viem.stringToBytes("ANODE"))
+};
+var RoleDataFactory = {
+  /**
+   * Data for SuperPaymaster Operator (Empty)
+   */
+  paymasterSuper: () => "0x",
+  /**
+   * Data for Generic DVT Role (Empty)
+   */
+  dvt: () => "0x",
+  /**
+   * Data for Community Registration (matches Registry.sol CommunityRoleData)
+   * NOTE: Solidity's abi.encode(struct) adds a 32-byte offset prefix (0x20)
+   * which is required for abi.decode(struct) to work correctly.
+   * 
+   * @param params.name Community Name (defaults to 'TestCommunity')
+   * @param params.ensName ENS name (optional)
+   * @param params.website Website URL (optional)
+   * @param params.description Community description (optional)
+   * @param params.logoURI Logo URI string (optional)
+   * @param params.stakeAmount Stake amount (defaults to 0)
+   */
+  community: (params) => {
+    return viem.encodeAbiParameters(
+      [{
+        type: "tuple",
+        components: [
+          { name: "name", type: "string" },
+          { name: "ensName", type: "string" },
+          { name: "website", type: "string" },
+          { name: "description", type: "string" },
+          { name: "logoURI", type: "string" },
+          { name: "stakeAmount", type: "uint256" }
+        ]
+      }],
+      [[
+        params?.name || "TestCommunity",
+        params?.ensName || "",
+        params?.website || "",
+        params?.description || "",
+        params?.logoURI || "",
+        params?.stakeAmount || 0n
+      ]]
+    );
+  },
+  /**
+   * Data for EndUser (matches Registry.sol EndUserRoleData)
+   */
+  endUser: (params) => {
+    return viem.encodeAbiParameters(
+      [{
+        type: "tuple",
+        components: [
+          { name: "account", type: "address" },
+          { name: "community", type: "address" },
+          { name: "avatarURI", type: "string" },
+          { name: "ensName", type: "string" },
+          { name: "stakeAmount", type: "uint256" }
+        ]
+      }],
+      [[
+        params?.account || viem.zeroAddress,
+        params?.community || viem.zeroAddress,
+        params?.avatarURI || "",
+        params?.ensName || "",
+        params?.stakeAmount || 0n
+      ]]
+    );
+  },
+  decodeCommunity: (data) => {
+    const decoded = viem.decodeAbiParameters(
+      [{
+        type: "tuple",
+        components: [
+          { name: "name", type: "string" },
+          { name: "ensName", type: "string" },
+          { name: "website", type: "string" },
+          { name: "description", type: "string" },
+          { name: "logoURI", type: "string" },
+          { name: "stakeAmount", type: "uint256" }
+        ]
+      }],
+      data
+    );
+    const result = decoded[0];
+    if (Array.isArray(result)) {
+      const [n, e, w, d, l, s] = result;
+      return { name: n, ensName: e, website: w, description: d, logoURI: l, stakeAmount: s };
+    } else {
+      return {
+        name: result.name,
+        ensName: result.ensName,
+        website: result.website,
+        description: result.description,
+        logoURI: result.logoURI,
+        stakeAmount: result.stakeAmount
+      };
+    }
+  },
+  decodeEndUser: (data) => {
+    const decoded = viem.decodeAbiParameters(
+      [{
+        type: "tuple",
+        components: [
+          { name: "account", type: "address" },
+          { name: "community", type: "address" },
+          { name: "avatarURI", type: "string" },
+          { name: "ensName", type: "string" },
+          { name: "stakeAmount", type: "uint256" }
+        ]
+      }],
+      data
+    );
+    const result = decoded[0];
+    if (Array.isArray(result)) {
+      const [a, c, av, en, s] = result;
+      return { account: a, community: c, avatarURI: av, ensName: en, stakeAmount: s };
+    } else {
+      return {
+        account: result.account,
+        community: result.community,
+        avatarURI: result.avatarURI,
+        ensName: result.ensName,
+        stakeAmount: result.stakeAmount
+      };
+    }
+  }
+};
+var CustomErrors = {
+  RoleNotConfigured: "RoleNotConfigured(bytes32,bool)",
+  RoleAlreadyGranted: "RoleAlreadyGranted(bytes32,address)",
+  InsufficientStake: "InsufficientStake(uint256,uint256)"
+};
+function decodeContractError(error) {
+  if (!error || typeof error !== "object") return null;
+  if (error.name === "ContractFunctionExecutionError" || error.walk) {
+    const internalError = error.walk ? error.walk((e) => e.data) : error;
+    const data = internalError?.data;
+    if (data) {
+      try {
+        const decoded = viem.decodeErrorResult({
+          abi: chunkCIEYY3A6_cjs.RegistryABI,
+          data
+        });
+        if (decoded.errorName === "RoleNotConfigured") {
+          const [roleId, isActive] = decoded.args;
+          return `RoleNotConfigured: Role ${roleId} is ${isActive ? "ACTIVE" : "INACTIVE"} in Registry.`;
+        }
+        if (decoded.errorName === "RoleAlreadyGranted") {
+          const [roleId, user] = decoded.args;
+          return `RoleAlreadyGranted: User ${user} already has role ${roleId}.`;
+        }
+        if (decoded.errorName === "InsufficientStake") {
+          const [stake, minStake] = decoded.args;
+          return `InsufficientStake: Provided ${stake}, Required ${minStake}.`;
+        }
+        return `${decoded.errorName}: ${decoded.args}`;
+      } catch (e) {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+// src/clients/operator.ts
+function createOperatorClient({
+  chain,
+  transport,
+  account,
+  addresses
+}) {
+  const client = viem.createClient({
+    chain,
+    transport,
+    account
+  }).extend(viem.publicActions).extend(viem.walletActions);
+  const chainDefaults = chunkMXJEULSE_cjs.getCanonicalAddresses(chain.id);
+  if (!chainDefaults && !addresses) {
+    throw new Error(
+      `[createOperatorClient] No canonical addresses for chainId ${chain.id}. Pass \`addresses\` explicitly, or use a supported chain: ${chunkMXJEULSE_cjs.describeSupportedChains()}.`
+    );
+  }
+  const usedAddresses = { ...chunkMXJEULSE_cjs.CORE_ADDRESSES, ...chunkMXJEULSE_cjs.TEST_TOKEN_ADDRESSES, ...chunkMXJEULSE_cjs.TEST_ACCOUNT_ADDRESSES, ...chainDefaults, ...addresses };
+  const spActions = chunkCIEYY3A6_cjs.superPaymasterActions(usedAddresses.superPaymaster)(client);
+  const regActions = chunkCIEYY3A6_cjs.registryActions(usedAddresses.registry)(client);
+  const stkActions = chunkCIEYY3A6_cjs.stakingActions(usedAddresses.gTokenStaking)(client);
+  const pmV4Actions = chunkCIEYY3A6_cjs.paymasterActions(usedAddresses.paymasterV4)(client);
+  const actions = {
+    ...stkActions,
+    ...spActions,
+    ...pmV4Actions,
+    ...regActions,
+    async setup(args) {
+      console.log("\u2699\uFE0F Setting up operator...");
+      const txs = await this._onboardOperator(args);
+      console.log(`\u2705 Operator setup complete! Transactions: ${txs.length}`);
+      return { txs };
+    },
+    async onboardOperator(args) {
+      return this.onboardFully(args);
+    },
+    async onboardFully(args) {
+      return this._onboardOperator(args);
+    },
+    async deployPaymasterV4({ version = "v4.1", initData = "0x" } = {}) {
+      console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
+      const tx = await client.writeContract({
+        address: usedAddresses.paymasterFactory,
+        abi: chunkCIEYY3A6_cjs.PaymasterFactoryABI,
+        functionName: "deployPaymaster",
+        args: [version, initData],
+        account,
+        chain
+      });
+      await client.waitForTransactionReceipt({ hash: tx });
+      return tx;
+    },
+    async _onboardOperator({ stakeAmount, depositAmount, roleId, roleData }) {
+      const txs = [];
+      const accountToUse = account;
+      if (!accountToUse) throw new Error("Account required for onboarding");
+      try {
+        console.log("   SDK: Fetching role config for entry burn...");
+        const roleConfig = await client.readContract({
+          address: usedAddresses.registry,
+          abi: chunkCIEYY3A6_cjs.RegistryABI,
+          functionName: "roleConfigs",
+          args: [roleId]
+        });
+        const entryBurn = roleConfig[1];
+        const totalStakeNeeded = stakeAmount + entryBurn;
+        console.log(`   SDK: Approving GToken (Stake: ${stakeAmount}, Burn: ${entryBurn})...`);
+        const approveGToken = await client.writeContract({
+          address: usedAddresses.gToken,
+          abi: viem.erc20Abi,
+          functionName: "approve",
+          args: [usedAddresses.gTokenStaking, totalStakeNeeded],
+          account: accountToUse,
+          chain
+        });
+        await client.waitForTransactionReceipt({ hash: approveGToken });
+        txs.push(approveGToken);
+        let data;
+        if (roleData && roleData !== "0x") {
+          data = roleData;
+        } else {
+          console.log(`   SDK: Auto-generating roleData for roleId ${roleId}...`);
+          if (roleId === viem.keccak256(viem.stringToBytes("COMMUNITY"))) {
+            data = RoleDataFactory.community();
+          } else if (roleId === viem.keccak256(viem.stringToBytes("ENDUSER"))) {
+            data = RoleDataFactory.endUser();
+          } else if (roleId === viem.keccak256(viem.stringToBytes("PAYMASTER_SUPER"))) {
+            data = RoleDataFactory.paymasterSuper();
+          } else {
+            data = RoleDataFactory.paymasterSuper();
+          }
+        }
+        console.log(`   SDK: Checking if role already granted...`);
+        const hasRoleResult = await client.readContract({
+          address: usedAddresses.registry,
+          abi: chunkCIEYY3A6_cjs.RegistryABI,
+          functionName: "hasRole",
+          args: [roleId, accountToUse.address]
+        });
+        if (hasRoleResult) {
+          console.log(`   \u2139\uFE0F  Role already granted, skipping registration`);
+        } else {
+          console.log(`   SDK: Registering role ${roleId}...`);
+          const registerTx = await actions.registerRoleSelf({
+            roleId,
+            data,
+            account: accountToUse
+          });
+          await client.waitForTransactionReceipt({ hash: registerTx });
+          txs.push(registerTx);
+        }
+        if (depositAmount > 0n) {
+          console.log("   SDK: Depositing aPNTs via depositFor...");
+          const depositTx = await client.writeContract({
+            address: usedAddresses.superPaymaster,
+            abi: chunkCIEYY3A6_cjs.SuperPaymasterABI,
+            functionName: "depositFor",
+            args: [accountToUse.address, depositAmount],
+            account: accountToUse,
+            chain
+          });
+          await client.waitForTransactionReceipt({ hash: depositTx });
+          txs.push(depositTx);
+        }
+        return txs;
+      } catch (error) {
+        const decodedMsg = decodeContractError(error);
+        throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
+      }
+    },
+    async onboardToSuperPaymaster(args) {
+      return this.onboardOperator(args);
+    },
+    async configureOperator({ xPNTsToken, treasury, account: accountOverride }) {
+      const tx = await spActions.configureOperator({
+        xPNTsToken,
+        opTreasury: treasury,
+        account: accountOverride || account
+      });
+      await client.waitForTransactionReceipt({ hash: tx });
+      return tx;
+    },
+    async getOperatorStatus(accountAddress) {
+      try {
+        const hasRole = await client.readContract({
+          address: usedAddresses.registry,
+          abi: chunkCIEYY3A6_cjs.RegistryABI,
+          functionName: "hasRole",
+          args: [viem.keccak256(viem.stringToBytes("PAYMASTER_SUPER")), accountAddress]
+        });
+        let operatorType = null;
+        let superPaymasterInfo = null;
+        let paymasterV4Info = null;
+        if (hasRole && usedAddresses.superPaymaster) {
+          const operatorData = await client.readContract({
+            address: usedAddresses.superPaymaster,
+            abi: chunkCIEYY3A6_cjs.SuperPaymasterABI,
+            functionName: "operators",
+            args: [accountAddress]
+          });
+          if (operatorData && operatorData[1]) {
+            operatorType = "super";
+            const xPNTsTokenAddr = operatorData[3];
+            let exchangeRate = 0n;
+            if (xPNTsTokenAddr && xPNTsTokenAddr !== viem.zeroAddress) {
+              try {
+                exchangeRate = await client.readContract({
+                  address: xPNTsTokenAddr,
+                  abi: chunkCIEYY3A6_cjs.xPNTsTokenABI,
+                  functionName: "exchangeRate"
+                });
+              } catch (rateErr) {
+                const msg = rateErr instanceof Error ? rateErr.message : String(rateErr);
+                if (!msg.includes("ContractFunctionExecutionError") && !msg.includes("code: -32")) {
+                  console.warn(`   \u26A0\uFE0F Unexpected error reading exchangeRate from ${xPNTsTokenAddr}:`, msg);
+                }
+              }
+            }
+            superPaymasterInfo = {
+              hasRole: true,
+              isConfigured: true,
+              balance: operatorData[0],
+              exchangeRate,
+              treasury: operatorData[6]
+            };
+          }
+        }
+        if (usedAddresses.paymasterFactory && usedAddresses.paymasterFactory !== viem.zeroAddress) {
+          try {
+            const pmAddr = await client.readContract({
+              address: usedAddresses.paymasterFactory,
+              abi: chunkCIEYY3A6_cjs.PaymasterFactoryABI,
+              functionName: "getPaymasterByOperator",
+              args: [accountAddress]
+            });
+            if (pmAddr !== viem.zeroAddress) {
+              operatorType = operatorType || "v4";
+              paymasterV4Info = {
+                address: pmAddr,
+                balance: await client.getBalance({ address: pmAddr })
+              };
+            }
+          } catch (e) {
+            console.warn(`   \u26A0\uFE0F Failed to fetch V4 info from factory ${usedAddresses.paymasterFactory}:`, e);
+          }
+        }
+        return { type: operatorType, superPaymaster: superPaymasterInfo, paymasterV4: paymasterV4Info };
+      } catch (error) {
+        console.error("Error in getOperatorStatus:", error);
+        return { type: null, superPaymaster: null, paymasterV4: null };
+      }
+    }
+  };
+  return Object.assign(client, actions);
+}
+function createCommunityClient({
+  chain,
+  transport,
+  account,
+  addresses
+}) {
+  const client = viem.createClient({
+    chain,
+    transport,
+    account
+  }).extend(viem.publicActions).extend(viem.walletActions);
+  const chainDefaults = chunkMXJEULSE_cjs.getCanonicalAddresses(chain.id);
+  if (!chainDefaults && !addresses) {
+    throw new Error(
+      `[createCommunityClient] No canonical addresses for chainId ${chain.id}. Pass \`addresses\` explicitly, or use a supported chain: ${chunkMXJEULSE_cjs.describeSupportedChains()}.`
+    );
+  }
+  const usedAddresses = { ...chunkMXJEULSE_cjs.CORE_ADDRESSES, ...chunkMXJEULSE_cjs.TEST_TOKEN_ADDRESSES, ...chainDefaults, ...addresses };
+  const registryActionsObj = chunkCIEYY3A6_cjs.registryActions(usedAddresses.registry)(client);
+  const sbtActionsObj = chunkCIEYY3A6_cjs.sbtActions(usedAddresses.mySBT)(client);
+  const launch = async (args) => {
+    try {
+      console.log(`\u{1F680} Launching community: ${args.name}`);
+      if (!account) {
+        throw new Error("Account is required for launch()");
+      }
+      const uniqueName = `${args.name}_${Date.now()}`;
+      console.log(`   \u{1F4DD} Unique name: ${uniqueName}`);
+      const roleData = RoleDataFactory.community({
+        name: uniqueName,
+        ensName: "",
+        website: args.website || "",
+        description: args.description || "",
+        logoURI: args.logoURI || "",
+        stakeAmount: 0n
+      });
+      console.log(`   \u2705 RoleData generated:`, roleData);
+      console.log(`   \u{1F4CA} RoleData type:`, typeof roleData);
+      console.log(`   \u{1F4CF} RoleData length:`, roleData?.length);
+      const hasRole = await client.readContract({
+        address: usedAddresses.registry,
+        abi: chunkCIEYY3A6_cjs.RegistryABI,
+        functionName: "hasRole",
+        args: [RoleIds.COMMUNITY, account.address]
+      });
+      let registerTx;
+      if (hasRole) {
+        console.log(`   \u2139\uFE0F  Account already has COMMUNITY role. Skipping registration.`);
+      } else {
+        if (usedAddresses.gToken && usedAddresses.gTokenStaking) {
+          console.log(`   \u{1F4B0} Checking GToken allowance...`);
+          const balance = await client.readContract({
+            address: usedAddresses.gToken,
+            abi: viem.erc20Abi,
+            functionName: "balanceOf",
+            args: [account.address]
+          });
+          if (balance < 50000000000000000000n) {
+            console.warn(`   \u26A0\uFE0F Warning: Low GToken balance (${balance}). Registration may fail if minStake > balance.`);
+          }
+          const allowance = await client.readContract({
+            address: usedAddresses.gToken,
+            abi: viem.erc20Abi,
+            functionName: "allowance",
+            args: [account.address, usedAddresses.gTokenStaking]
+          });
+          if (allowance < 50000000000000000000n) {
+            console.log(`   \u{1F513} Approving GToken for Staking...`);
+            const approveTx = await client.writeContract({
+              address: usedAddresses.gToken,
+              abi: viem.erc20Abi,
+              functionName: "approve",
+              args: [usedAddresses.gTokenStaking, 115792089237316195423570985008687907853269984665640564039457584007913129639935n],
+              // MaxUint256
+              account
+            });
+            console.log(`   \u2705 Approved: ${approveTx}`);
+            await client.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        console.log(`   \u{1F4E4} Registering community role...`);
+        try {
+          registerTx = await registryActionsObj.registerRole({
+            roleId: RoleIds.COMMUNITY,
+            user: account.address,
+            data: roleData,
+            account
+          });
+          console.log(`   \u2705 Community registered: ${registerTx}`);
+        } catch (e) {
+          const isRoleError = e.message?.includes("RoleAlreadyGranted") || e.cause?.data?.errorName === "RoleAlreadyGranted" || e.name === "RoleAlreadyGranted" || e.name === "RoleAlreadyGranted";
+          if (isRoleError) {
+            console.log(`   \u2139\uFE0F  Role already granted (caught in tx). Skipping.`);
+          } else {
+            throw e;
+          }
+        }
+      }
+      let tokenAddress = "0x0000000000000000000000000000000000000000";
+      const txs = [];
+      if (registerTx) txs.push(registerTx);
+      if (usedAddresses.xPNTsFactory) {
+        if (!client.account) {
+          throw new Error("Client account is required for token deployment");
+        }
+        const factoryAbi = [
+          {
+            type: "function",
+            name: "deployxPNTsToken",
+            inputs: [
+              { name: "name", type: "string" },
+              { name: "symbol", type: "string" },
+              { name: "communityName", type: "string" },
+              { name: "communityENS", type: "string" },
+              { name: "exchangeRate", type: "uint256" },
+              { name: "paymasterAOA", type: "address" }
+            ],
+            outputs: [{ name: "token", type: "address" }],
+            stateMutability: "nonpayable"
+          },
+          {
+            type: "function",
+            name: "getTokenAddress",
+            inputs: [{ name: "community", type: "address" }],
+            outputs: [{ name: "token", type: "address" }],
+            stateMutability: "view"
+          }
+        ];
+        try {
+          const existingToken = await client.readContract({
+            address: usedAddresses.xPNTsFactory,
+            abi: factoryAbi,
+            functionName: "getTokenAddress",
+            args: [account.address]
+          });
+          if (existingToken && existingToken !== "0x0000000000000000000000000000000000000000") {
+            console.log(`   \u2139\uFE0F  Found existing token at ${existingToken}`);
+            tokenAddress = existingToken;
+            return { tokenAddress, txs };
+          }
+        } catch (e) {
+          console.warn(`   \u26A0\uFE0F Failed to check for existing token:`, e);
+        }
+        console.log(`   \u{1F3ED} Deploying Token via Factory: ${usedAddresses.xPNTsFactory}`);
+        try {
+          const { request } = await client.simulateContract({
+            address: usedAddresses.xPNTsFactory,
+            abi: factoryAbi,
+            functionName: "deployxPNTsToken",
+            args: [
+              args.tokenName,
+              args.tokenSymbol,
+              args.name,
+              // communityName
+              args.website || "",
+              // communityENS (mapping website to ENS param for now)
+              1000000000000000000n,
+              // exchangeRate 1e18 (1:1)
+              "0x0000000000000000000000000000000000000000"
+              // paymasterAOA (optional)
+            ],
+            account: client.account
+          });
+          const deployTx = await client.writeContract(request);
+          console.log(`   \u{1F4E4} Deploy Token Tx: ${deployTx}`);
+          txs.push(deployTx);
+          const receipt = await client.waitForTransactionReceipt({ hash: deployTx });
+          const newTokenAddress = await client.readContract({
+            address: usedAddresses.xPNTsFactory,
+            abi: factoryAbi,
+            functionName: "getTokenAddress",
+            args: [account.address]
+          });
+          if (newTokenAddress) {
+            tokenAddress = newTokenAddress;
+            console.log(`   \u{1FA99} Token Deployed: ${tokenAddress}`);
+          }
+        } catch (deployError) {
+          console.warn("   \u26A0\uFE0F Failed to deploy token, but community registered:", deployError);
+        }
+      }
+      return { tokenAddress, txs };
+    } catch (error) {
+      console.error("\u274C Error in launch():", error);
+      const errorMessage = error.message || "";
+      const errorData = error.data?.errorName || "";
+      const errorString = JSON.stringify(error);
+      if (errorMessage.includes("RoleAlreadyGranted") || errorData === "RoleAlreadyGranted" || errorString.includes("RoleAlreadyGranted")) {
+        throw new Error(`Account ${account?.address || "unknown"} already has COMMUNITY role. Please use a different account or exit the role first.`);
+      }
+      if (errorMessage.includes("InsufficientStake")) {
+        throw new Error("Insufficient stake. Please ensure you have enough GToken staked.");
+      }
+      if (errorMessage.includes("RoleNotConfigured")) {
+        throw new Error("COMMUNITY role is not configured in the Registry contract.");
+      }
+      throw error;
+    }
+  };
+  const getCommunityInfo = async (accountAddress) => {
+    try {
+      const hasRole = await client.readContract({
+        address: usedAddresses.registry,
+        abi: chunkCIEYY3A6_cjs.RegistryABI,
+        functionName: "hasRole",
+        args: [RoleIds.COMMUNITY, accountAddress]
+      });
+      if (!hasRole) {
+        return {
+          hasRole: false,
+          tokenAddress: null,
+          communityData: null
+        };
+      }
+      const factoryAbi = [
+        {
+          inputs: [{ name: "community", type: "address" }],
+          name: "getTokenAddress",
+          outputs: [{ name: "", type: "address" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ];
+      const tokenAddress = await client.readContract({
+        address: usedAddresses.xPNTsFactory,
+        abi: factoryAbi,
+        functionName: "getTokenAddress",
+        args: [accountAddress]
+      });
+      const metadata = await client.readContract({
+        address: usedAddresses.registry,
+        abi: chunkCIEYY3A6_cjs.RegistryABI,
+        functionName: "roleMetadata",
+        args: [RoleIds.COMMUNITY, accountAddress]
+      });
+      let communityData = {
+        name: "Community",
+        ensName: "",
+        website: "",
+        description: "",
+        logoURI: ""
+      };
+      if (metadata && metadata !== "0x") {
+        try {
+          const decoded = RoleDataFactory.decodeCommunity(metadata);
+          communityData = {
+            name: decoded.name || "Community",
+            ensName: decoded.ensName || "",
+            website: decoded.website || "",
+            description: decoded.description || "",
+            logoURI: decoded.logoURI || ""
+          };
+        } catch (e) {
+          console.warn("   \u26A0\uFE0F Failed to decode community metadata:", e);
+        }
+      }
+      return {
+        hasRole: true,
+        tokenAddress: tokenAddress && tokenAddress !== "0x0000000000000000000000000000000000000000" ? tokenAddress : null,
+        communityData: metadata && metadata !== "0x" ? communityData : null
+      };
+    } catch (error) {
+      console.error("Error fetching community info:", error);
+      return {
+        hasRole: false,
+        tokenAddress: null,
+        communityData: null
+      };
+    }
+  };
+  return Object.assign(client, registryActionsObj, sbtActionsObj, {
+    launch,
+    getCommunityInfo
+  });
+}
+var ADDRESS_PLACEHOLDER = "0x0000000000000000000000000000000000000000";
+function createAdminClient({
+  chain,
+  transport,
+  account,
+  addresses
+}) {
+  const baseClient = viem.createClient({ chain, transport, account }).extend(viem.publicActions).extend(viem.walletActions);
+  const chainDefaults = chunkMXJEULSE_cjs.getCanonicalAddresses(chain.id);
+  if (!chainDefaults && !addresses) {
+    throw new Error(
+      `[createAdminClient] No canonical addresses for chainId ${chain.id}. Pass \`addresses\` explicitly, or use a supported chain: ${chunkMXJEULSE_cjs.describeSupportedChains()}.`
+    );
+  }
+  const usedAddresses = { ...chunkMXJEULSE_cjs.CORE_ADDRESSES, ...chunkMXJEULSE_cjs.TOKEN_ADDRESSES, ...chainDefaults, ...addresses };
+  const actions = {
+    ...chunkCIEYY3A6_cjs.registryActions(usedAddresses.registry)(baseClient),
+    ...chunkCIEYY3A6_cjs.superPaymasterActions(usedAddresses.superPaymaster)(baseClient),
+    ...chunkCIEYY3A6_cjs.paymasterActions(usedAddresses.paymasterV4)(baseClient),
+    ...chunkCIEYY3A6_cjs.stakingActions(usedAddresses.gTokenStaking)(baseClient),
+    ...chunkCIEYY3A6_cjs.sbtActions(usedAddresses.mySBT)(baseClient),
+    ...chunkCIEYY3A6_cjs.dvtActions(ADDRESS_PLACEHOLDER)(baseClient),
+    ...chunkCIEYY3A6_cjs.xPNTsFactoryActions(usedAddresses.xPNTsFactory || "0x")(baseClient),
+    ...chunkCIEYY3A6_cjs.aggregatorActions(ADDRESS_PLACEHOLDER)(baseClient)
+  };
+  return Object.assign(baseClient, actions);
+}
+var ExperimentClient = class {
+  records = [];
+  scenarioId;
+  group;
+  constructor(scenarioId, group) {
+    this.scenarioId = scenarioId;
+    this.group = group;
+  }
+  /**
+   * Record a transaction result
+   */
+  recordTx(txHash, receipt, status, meta) {
+    const gasUsed = BigInt(receipt.gasUsed || 0);
+    const gasPrice = BigInt(receipt.effectiveGasPrice || 0);
+    const costBN = gasUsed * gasPrice;
+    const record = {
+      id: `${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      scenario: this.scenarioId,
+      group: this.group,
+      txHash,
+      gasUsed,
+      gasPrice,
+      costETH: viem.formatEther(costBN),
+      status,
+      timestamp: Date.now(),
+      meta
+    };
+    this.records.push(record);
+    return record;
+  }
+  /**
+   * Measure an async task (transaction) automatically
+   */
+  async measureTx(taskName, txPromise, publicClient) {
+    console.log(`[Experiment: ${this.group}] Executing: ${taskName}...`);
+    const start = Date.now();
+    try {
+      const hash = await txPromise;
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      this.recordTx(hash, receipt, "Success", { latency: Date.now() - start });
+      const gasUsed = BigInt(receipt.gasUsed || 0);
+      const gasPrice = BigInt(receipt.effectiveGasPrice || 0);
+      console.log(`   \u2705 Success! Gas: ${gasUsed} | Cost: ${viem.formatEther(gasUsed * gasPrice)} ETH`);
+      return hash;
+    } catch (e) {
+      console.error(`   \u274C Failed: ${taskName}`, e);
+      throw e;
+    }
+  }
+  getRecords() {
+    return this.records;
+  }
+};
+var KeyManager = class {
+  /**
+   * 生成单个密钥对
+   * @param name - 密钥名称（如 'Jason', 'Anni'）
+   */
+  static generateKeyPair(name) {
+    const privateKey = accounts.generatePrivateKey();
+    const account = accounts.privateKeyToAccount(privateKey);
+    return {
+      name,
+      privateKey,
+      address: account.address
+    };
+  }
+  /**
+   * 批量生成密钥对
+   * @param names - 密钥名称数组
+   */
+  static generateKeyPairs(names) {
+    return names.map((name) => this.generateKeyPair(name));
+  }
+  /**
+   * 生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）
+   * @param count - 数量
+   * @param prefix - 名称前缀（默认 'Operator'）
+   */
+  static generateMultiple(count, prefix = "Operator") {
+    const names = Array.from({ length: count }, (_, i) => `${prefix}_${i + 1}`);
+    return this.generateKeyPairs(names);
+  }
+  /**
+   * 保存密钥到 .env 文件
+   * @param filePath - 文件路径（绝对路径）
+   * @param keys - 密钥对数组
+   * @param overwrite - 是否覆盖已存在的文件（默认 false）
+   */
+  static saveToEnvFile(filePath, keys, overwrite = false) {
+    if (fs__namespace.existsSync(filePath) && !overwrite) {
+      throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
+    }
+    const content = keys.map(
+      (k) => `${k.name.toUpperCase().replace(/\s+/g, "_")}_PRIVATE_KEY=${k.privateKey}`
+    ).join("\n") + "\n";
+    fs__namespace.writeFileSync(filePath, content, { mode: 384 });
+    console.log(`\u2705 Keys saved to ${filePath} (${keys.length} keys)`);
+  }
+  /**
+   * 从 .env 文件加载密钥
+   * @param filePath - 文件路径（绝对路径）
+   * @returns 密钥对数组
+   */
+  static loadFromEnvFile(filePath) {
+    if (!fs__namespace.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs__namespace.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim() && !line.startsWith("#"));
+    return lines.map((line) => {
+      const [key, value] = line.split("=");
+      const name = key.replace(/_PRIVATE_KEY$/, "").toLowerCase().replace(/_/g, " ");
+      const privateKey = value.trim();
+      const account = accounts.privateKeyToAccount(privateKey);
+      return {
+        name,
+        privateKey,
+        address: account.address
+      };
+    });
+  }
+  /**
+   * 保存密钥到 JSON 文件（包含地址信息）
+   * @param filePath - 文件路径（绝对路径）
+   * @param keys - 密钥对数组
+   * @param overwrite - 是否覆盖已存在的文件（默认 false）
+   */
+  static saveToJsonFile(filePath, keys, overwrite = false) {
+    if (fs__namespace.existsSync(filePath) && !overwrite) {
+      throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
+    }
+    const data = {
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      keys: keys.map((k) => ({
+        name: k.name,
+        privateKey: k.privateKey,
+        address: k.address
+      }))
+    };
+    fs__namespace.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+    console.log(`\u2705 Keys saved to ${filePath} (${keys.length} keys)`);
+  }
+  /**
+   * 从 JSON 文件加载密钥
+   * @param filePath - 文件路径（绝对路径）
+   */
+  static loadFromJsonFile(filePath) {
+    if (!fs__namespace.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs__namespace.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return data.keys.map((k) => ({
+      name: k.name,
+      privateKey: k.privateKey,
+      address: k.address
+    }));
+  }
+  /**
+   * 打印密钥信息（隐藏私钥）
+   * @param keys - 密钥对数组
+   */
+  static printKeys(keys, showPrivateKey = false) {
+    console.log("\n\u{1F511} Generated Keys:");
+    console.log("\u2500".repeat(80));
+    keys.forEach((k, i) => {
+      console.log(`${i + 1}. ${k.name}`);
+      console.log(`   Address: ${k.address}`);
+      if (showPrivateKey) {
+        console.log(`   Private Key: ${k.privateKey}`);
+      } else {
+        console.log(`   Private Key: ${k.privateKey.slice(0, 10)}...${k.privateKey.slice(-8)}`);
+      }
+    });
+    console.log("\u2500".repeat(80));
+  }
+};
+var FundingManager = class {
+  /**
+   * 创建 PublicClient 和 WalletClient
+   */
+  static createClients(params) {
+    const account = accounts.privateKeyToAccount(params.supplierKey);
+    const transport = viem.http(params.rpcUrl);
+    const publicClient = viem.createPublicClient({
+      chain: params.chain,
+      transport
+    });
+    const walletClient = viem.createWalletClient({
+      account,
+      chain: params.chain,
+      transport
+    });
+    return { publicClient, walletClient, account };
+  }
+  /**
+   * 充值 ETH 到目标地址
+   * @param params - 充值参数
+   * @returns 充值结果
+   */
+  static async fundWithETH(params) {
+    try {
+      const { publicClient, walletClient } = this.createClients(params);
+      const amount = viem.parseEther(params.amount);
+      console.log(`\u{1F4B8} Funding ${params.targetAddress} with ${params.amount} ETH...`);
+      const hash = await walletClient.sendTransaction({
+        account: walletClient.account,
+        chain: params.chain,
+        to: params.targetAddress,
+        value: amount
+      });
+      console.log(`   Transaction Sent: ${hash}`);
+      await publicClient.waitForTransactionReceipt({ hash });
+      console.log(`   \u2705 ETH Funded.`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      console.error(`   \u274C ETH Funding Failed:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * 充值 ERC20 Token 到目标地址
+   * @param params - 充值参数
+   * @returns 充值结果
+   */
+  static async fundWithToken(params) {
+    try {
+      const { publicClient, walletClient, account } = this.createClients(params);
+      const amount = viem.parseEther(params.amount);
+      console.log(`\u{1F4B8} Funding ${params.targetAddress} with ${params.amount} tokens...`);
+      const { request } = await publicClient.simulateContract({
+        account,
+        address: params.tokenAddress,
+        abi: viem.erc20Abi,
+        functionName: "transfer",
+        args: [params.targetAddress, amount]
+      });
+      const hash = await walletClient.writeContract(request);
+      console.log(`   Transaction Sent: ${hash}`);
+      await publicClient.waitForTransactionReceipt({ hash });
+      console.log(`   \u2705 Token Funded.`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      console.error(`   \u274C Token Funding Failed:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * 检查 ETH 余额
+   * @param params - 基础参数
+   * @returns ETH 余额（wei）
+   */
+  static async getETHBalance(params) {
+    const { publicClient } = this.createClients(params);
+    return await publicClient.getBalance({ address: params.targetAddress });
+  }
+  /**
+   * 检查 ERC20 Token 余额
+   * @param params - 基础参数
+   * @param tokenAddress - Token 合约地址
+   * @returns Token 余额
+   */
+  static async getTokenBalance(params, tokenAddress) {
+    const { publicClient } = this.createClients(params);
+    return await publicClient.readContract({
+      address: tokenAddress,
+      abi: viem.erc20Abi,
+      functionName: "balanceOf",
+      args: [params.targetAddress]
+    });
+  }
+  /**
+   * 智能充值：检查余额，不足时自动充值
+   * @param params - 充值参数
+   * @returns 充值结果数组
+   */
+  static async ensureFunding(params) {
+    const results = [];
+    const { publicClient } = this.createClients(params);
+    if (params.minETH && params.targetETH) {
+      const ethBalance = await publicClient.getBalance({ address: params.targetAddress });
+      const minETH = viem.parseEther(params.minETH);
+      viem.parseEther(params.targetETH);
+      if (ethBalance < minETH) {
+        console.log(`\u26A0\uFE0F  ETH balance (${Number(ethBalance) / 1e18}) below threshold (${params.minETH})`);
+        const result = await this.fundWithETH({
+          ...params,
+          amount: params.targetETH
+        });
+        results.push(result);
+      } else {
+        console.log(`\u2705 Sufficient ETH: ${Number(ethBalance) / 1e18} ETH`);
+        results.push({ success: true });
+      }
+    }
+    if (params.token) {
+      const tokenBalance = await this.getTokenBalance(params, params.token.address);
+      const minToken = params.token.minBalance ? viem.parseEther(params.token.minBalance) : 0n;
+      const targetToken = params.token.targetAmount ? viem.parseEther(params.token.targetAmount) : 0n;
+      if (tokenBalance < minToken && targetToken > 0n) {
+        console.log(`\u26A0\uFE0F  Token balance (${Number(tokenBalance) / 1e18}) below threshold (${params.token.minBalance})`);
+        const result = await this.fundWithToken({
+          ...params,
+          tokenAddress: params.token.address,
+          amount: params.token.targetAmount
+        });
+        results.push(result);
+      } else {
+        console.log(`\u2705 Sufficient Token: ${Number(tokenBalance) / 1e18}`);
+        results.push({ success: true });
+      }
+    }
+    return results;
+  }
+  /**
+   * 批量充值 ETH
+   * @param params - 基础参数
+   * @param targets - 目标地址和金额数组
+   * @returns 充值结果数组
+   */
+  static async batchFundETH(params, targets) {
+    const results = [];
+    for (const target of targets) {
+      const result = await this.fundWithETH({
+        ...params,
+        targetAddress: target.address,
+        amount: target.amount
+      });
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * 批量充值 Token
+   * @param params - 基础参数
+   * @param tokenAddress - Token 合约地址
+   * @param targets - 目标地址和金额数组
+   * @returns 充值结果数组
+   */
+  static async batchFundToken(params, tokenAddress, targets) {
+    const results = [];
+    for (const target of targets) {
+      const result = await this.fundWithToken({
+        ...params,
+        targetAddress: target.address,
+        tokenAddress,
+        amount: target.amount
+      });
+      results.push(result);
+    }
+    return results;
+  }
+};
+var UserOperationBuilder = class {
+  /**
+   * Packs verificationGasLimit and callGasLimit into a bytes32 Hex string.
+   */
+  static packAccountGasLimits(verificationGasLimit, callGasLimit) {
+    return viem.concat([
+      viem.pad(`0x${verificationGasLimit.toString(16)}`, { dir: "left", size: 16 }),
+      viem.pad(`0x${callGasLimit.toString(16)}`, { dir: "left", size: 16 })
+    ]);
+  }
+  /**
+   * Packs maxPriorityFeePerGas and maxFeePerGas into a bytes32 Hex string.
+   */
+  static packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+    return viem.concat([
+      viem.pad(`0x${maxPriorityFeePerGas.toString(16)}`, { dir: "left", size: 16 }),
+      viem.pad(`0x${maxFeePerGas.toString(16)}`, { dir: "left", size: 16 })
+    ]);
+  }
+  static estimatePreVerificationGasV07(userOp) {
+    const nonce = typeof userOp.nonce === "bigint" ? userOp.nonce : typeof userOp.nonce === "number" ? BigInt(userOp.nonce) : BigInt(userOp.nonce);
+    const preVerificationGas = typeof userOp.preVerificationGas === "bigint" ? userOp.preVerificationGas : typeof userOp.preVerificationGas === "number" ? BigInt(userOp.preVerificationGas) : BigInt(userOp.preVerificationGas);
+    const encoded = viem.encodeAbiParameters(
+      viem.parseAbiParameters("(address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)"),
+      [
+        [
+          userOp.sender,
+          nonce,
+          userOp.initCode,
+          userOp.callData,
+          userOp.accountGasLimits,
+          preVerificationGas,
+          userOp.gasFees,
+          userOp.paymasterAndData,
+          userOp.signature
+        ]
+      ]
+    );
+    const bytes = viem.toBytes(encoded);
+    let calldataCost = 0n;
+    for (const b of bytes) calldataCost += b === 0 ? 4n : 16n;
+    return calldataCost + 26000n;
+  }
+  /**
+   * Packs Paymaster parameters into the v0.7 paymasterAndData format.
+   */
+  static packPaymasterAndData(paymaster, paymasterGasLimit, paymasterPostOpGasLimit, paymasterData = "0x") {
+    return viem.concat([
+      paymaster,
+      viem.pad(`0x${paymasterGasLimit.toString(16)}`, { dir: "left", size: 16 }),
+      viem.pad(`0x${paymasterPostOpGasLimit.toString(16)}`, { dir: "left", size: 16 }),
+      paymasterData
+    ]);
+  }
+  /**
+   * Pack PaymasterV4 Deposit-Only paymasterAndData
+   * 
+   * v0.7 EntryPoint packs: [paymaster(20)][verificationGas(16)][postOpGas(16)][paymasterData]
+   * Contract extracts token at offset 52 = paymasterData[0:20]
+   * 
+   * So paymasterData format must be: [token(20)][validUntil(6)][validAfter(6)]
+   * 
+   * @param paymaster - Paymaster address (20 bytes)
+   * @param paymentToken - ERC20 token address (20 bytes, FIRST in paymasterData!)
+   * @param validUntil - Validity end timestamp (6 bytes)
+   * @param validAfter - Validity start timestamp (6 bytes)
+   */
+  static packPaymasterV4DepositData(paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymentToken, validUntil, validAfter) {
+    return viem.concat([
+      paymaster,
+      viem.pad(`0x${paymasterVerificationGasLimit.toString(16)}`, { dir: "left", size: 16 }),
+      viem.pad(`0x${paymasterPostOpGasLimit.toString(16)}`, { dir: "left", size: 16 }),
+      paymentToken,
+      viem.pad(`0x${validUntil.toString(16)}`, { dir: "left", size: 6 }),
+      viem.pad(`0x${validAfter.toString(16)}`, { dir: "left", size: 6 })
+    ]);
+  }
+  /**
+   * Computes the UserOperation hash for signing.
+   */
+  static async getUserOpHash({
+    userOp,
+    entryPoint,
+    chainId,
+    publicClient
+  }) {
+    return await publicClient.readContract({
+      address: entryPoint,
+      abi: [{
+        type: "function",
+        name: "getUserOpHash",
+        inputs: [{
+          type: "tuple",
+          components: [
+            { name: "sender", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "initCode", type: "bytes" },
+            { name: "callData", type: "bytes" },
+            { name: "accountGasLimits", type: "bytes32" },
+            { name: "preVerificationGas", type: "uint256" },
+            { name: "gasFees", type: "bytes32" },
+            { name: "paymasterAndData", type: "bytes" },
+            { name: "signature", type: "bytes" }
+          ]
+        }],
+        outputs: [{ type: "bytes32" }],
+        stateMutability: "view"
+      }],
+      functionName: "getUserOpHash",
+      args: [userOp]
+    });
+  }
+  /**
+   * Formats a PackedUserOperation into a JSON-RPC compatible object with hex-encoded strings.
+   */
+  static jsonifyUserOp(userOp) {
+    const result = {
+      sender: userOp.sender,
+      nonce: userOp.nonce,
+      initCode: userOp.initCode,
+      callData: userOp.callData,
+      accountGasLimits: userOp.accountGasLimits,
+      preVerificationGas: userOp.preVerificationGas,
+      gasFees: userOp.gasFees,
+      paymasterAndData: userOp.paymasterAndData,
+      signature: userOp.signature
+    };
+    const toCompactHex = (val) => {
+      if (typeof val === "bigint") return `0x${val.toString(16)}`;
+      if (typeof val === "number") return `0x${val.toString(16)}`;
+      if (typeof val === "string") {
+        if (val === "0x") return "0x0";
+        if (val === "0x0") return "0x0";
+        return val.replace(/^0x0+(?!$)/, "0x");
+      }
+      return val;
+    };
+    result.nonce = toCompactHex(result.nonce);
+    result.preVerificationGas = toCompactHex(result.preVerificationGas);
+    return result;
+  }
+  /**
+   * Converts a PackedUserOperation to the Alchemy-specific v0.7 JSON format.
+   * @param userOp - The packed UserOperation
+   * @param options - Optional configuration
+   * @param options.paymasterVerificationGasLimit - Gas limit for paymaster verification (default: 200000)
+   * @param options.paymasterPostOpGasLimit - Gas limit for paymaster postOp (default: 200000)
+   */
+  static toAlchemyUserOperation(userOp, options) {
+    const toHexStr = (val) => {
+      if (val === void 0 || val === null) return void 0;
+      if (typeof val === "bigint") return `0x${val.toString(16)}`;
+      if (typeof val === "number") return `0x${val.toString(16)}`;
+      if (typeof val === "string" && !val.startsWith("0x")) return `0x${val}`;
+      return val;
+    };
+    const result = {
+      sender: userOp.sender,
+      nonce: toHexStr(userOp.nonce),
+      callData: userOp.callData,
+      signature: userOp.signature
+    };
+    if (userOp.accountGasLimits && userOp.accountGasLimits !== "0x") {
+      const val = userOp.accountGasLimits.toString().startsWith("0x") ? userOp.accountGasLimits.slice(2) : userOp.accountGasLimits;
+      const padded = val.padStart(64, "0");
+      const verificationGasLimit = BigInt("0x" + padded.slice(0, 32));
+      const callGasLimit = BigInt("0x" + padded.slice(32, 64));
+      result.verificationGasLimit = `0x${verificationGasLimit.toString(16)}`;
+      result.callGasLimit = `0x${callGasLimit.toString(16)}`;
+    }
+    if (userOp.gasFees && userOp.gasFees !== "0x") {
+      const val = userOp.gasFees.toString().startsWith("0x") ? userOp.gasFees.slice(2) : userOp.gasFees;
+      const padded = val.padStart(64, "0");
+      const maxPriorityFeePerGas = BigInt("0x" + padded.slice(0, 32));
+      const maxFeePerGas = BigInt("0x" + padded.slice(32, 64));
+      result.maxPriorityFeePerGas = `0x${maxPriorityFeePerGas.toString(16)}`;
+      result.maxFeePerGas = `0x${maxFeePerGas.toString(16)}`;
+    }
+    if (userOp.preVerificationGas) {
+      result.preVerificationGas = `0x${BigInt(userOp.preVerificationGas).toString(16)}`;
+    }
+    if (userOp.initCode && userOp.initCode !== "0x") {
+      const initCode = userOp.initCode.toString();
+      result.factory = initCode.slice(0, 42);
+      result.factoryData = "0x" + initCode.slice(42);
+    }
+    if (userOp.paymasterAndData && userOp.paymasterAndData !== "0x") {
+      const pmd = userOp.paymasterAndData.toString().startsWith("0x") ? userOp.paymasterAndData.slice(2) : userOp.paymasterAndData;
+      if (pmd.length >= 104) {
+        result.paymaster = "0x" + pmd.slice(0, 40);
+        const vGas = BigInt("0x" + pmd.slice(40, 72));
+        const pGas = BigInt("0x" + pmd.slice(72, 104));
+        result.paymasterVerificationGasLimit = `0x${vGas.toString(16)}`;
+        result.paymasterPostOpGasLimit = `0x${pGas.toString(16)}`;
+        result.paymasterData = "0x" + pmd.slice(104);
+      } else if (pmd.length >= 40) {
+        result.paymaster = "0x" + pmd.slice(0, 40);
+        result.paymasterData = "0x" + pmd.slice(40);
+        const defaultGasLimit = 200000n;
+        result.paymasterVerificationGasLimit = `0x${(options?.paymasterVerificationGasLimit || defaultGasLimit).toString(16)}`;
+        result.paymasterPostOpGasLimit = `0x${(options?.paymasterPostOpGasLimit || defaultGasLimit).toString(16)}`;
+      }
+    }
+    return result;
+  }
+};
+var UserOpScenarioType = /* @__PURE__ */ ((UserOpScenarioType2) => {
+  UserOpScenarioType2["NATIVE"] = "NATIVE";
+  UserOpScenarioType2["GASLESS_V4"] = "GASLESS_V4";
+  UserOpScenarioType2["SUPER_BPNT"] = "SUPER_BPNT";
+  UserOpScenarioType2["SUPER_CPNT"] = "SUPER_CPNT";
+  UserOpScenarioType2["SUPER_CUSTOM"] = "SUPER_CUSTOM";
+  return UserOpScenarioType2;
+})(UserOpScenarioType || {});
+var UserOpScenarioBuilder = class {
+  /**
+   * Builds a signed PackedUserOperation for a token transfer based on the specified scenario.
+   */
+  static async buildTransferScenario(type, params) {
+    const {
+      sender,
+      ownerAccount,
+      recipient,
+      tokenAddress,
+      amount,
+      entryPoint,
+      chainId,
+      publicClient,
+      paymaster,
+      operator,
+      paymasterGasLimit = 100000n,
+      paymasterPostOpGasLimit = 40000n,
+      nonceKey = 0n,
+      gasToken
+    } = params;
+    const transferData = viem.encodeFunctionData({
+      abi: [{ name: "transfer", type: "function", inputs: [{ type: "address", name: "to" }, { type: "uint256", name: "amount" }], outputs: [{ type: "bool" }] }],
+      functionName: "transfer",
+      args: [recipient, amount]
+    });
+    const callData = viem.encodeFunctionData({
+      abi: [{ name: "execute", type: "function", inputs: [{ type: "address" }, { type: "uint256" }, { type: "bytes" }] }],
+      functionName: "execute",
+      args: [tokenAddress, 0n, transferData]
+    });
+    const userOp = {
+      sender,
+      nonce: await publicClient.readContract({
+        address: entryPoint,
+        abi: [{ name: "getNonce", type: "function", inputs: [{ type: "address" }, { type: "uint192" }], outputs: [{ type: "uint256" }] }],
+        functionName: "getNonce",
+        args: [sender, nonceKey]
+      }),
+      initCode: "0x",
+      callData,
+      accountGasLimits: UserOperationBuilder.packAccountGasLimits(type === "NATIVE" /* NATIVE */ ? 75000n : 250000n, 150000n),
+      preVerificationGas: 80000n,
+      gasFees: UserOperationBuilder.packGasFees(2000000000n, 2000000000n),
+      // 2 Gwei
+      paymasterAndData: "0x",
+      signature: "0x"
+    };
+    if (type === "NATIVE" /* NATIVE */) {
+      userOp.paymasterAndData = "0x";
+    } else if (type === "GASLESS_V4" /* GASLESS_V4 */) {
+      const pm = paymaster;
+      const token = gasToken || tokenAddress;
+      const validUntil = BigInt(Math.floor(Date.now() / 1e3) + 3600);
+      const validAfter = BigInt(Math.floor(Date.now() / 1e3) - 100);
+      if (!pm) throw new Error("paymaster address required for GASLESS_V4");
+      if (!token) throw new Error("gasToken or tokenAddress required for GASLESS_V4");
+      userOp.paymasterAndData = UserOperationBuilder.packPaymasterV4DepositData(
+        pm,
+        paymasterGasLimit,
+        // paymasterVerificationGasLimit
+        paymasterPostOpGasLimit,
+        // paymasterPostOpGasLimit
+        token,
+        // Payment token
+        validUntil,
+        validAfter
+      );
+    } else if (type.startsWith("SUPER_")) {
+      if (!paymaster || !operator) throw new Error("Paymaster and Operator required for SuperPM scenarios");
+      userOp.paymasterAndData = UserOperationBuilder.packPaymasterAndData(
+        paymaster,
+        paymasterGasLimit,
+        paymasterPostOpGasLimit,
+        operator
+      );
+    }
+    const opHash = await UserOperationBuilder.getUserOpHash({
+      userOp,
+      entryPoint,
+      chainId,
+      publicClient
+    });
+    const signature = await ownerAccount.signMessage({
+      message: { raw: opHash }
+    });
+    userOp.signature = signature;
+    const jsonUserOp = UserOperationBuilder.jsonifyUserOp(userOp);
+    return { userOp: jsonUserOp, opHash };
+  }
+};
+
+Object.defineProperty(exports, "ChannelClient", {
+  enumerable: true,
+  get: function () { return chunk3HZEIFBW_cjs.ChannelClient; }
+});
+Object.defineProperty(exports, "VOUCHER_TYPES", {
+  enumerable: true,
+  get: function () { return chunk3HZEIFBW_cjs.VOUCHER_TYPES; }
+});
+Object.defineProperty(exports, "getVoucherDomain", {
+  enumerable: true,
+  get: function () { return chunk3HZEIFBW_cjs.getVoucherDomain; }
+});
+Object.defineProperty(exports, "signVoucher", {
+  enumerable: true,
+  get: function () { return chunk3HZEIFBW_cjs.signVoucher; }
+});
+Object.defineProperty(exports, "CommunityClient", {
+  enumerable: true,
+  get: function () { return chunk63JM67L7_cjs.CommunityClient; }
+});
+Object.defineProperty(exports, "UserLifecycle", {
+  enumerable: true,
+  get: function () { return chunk63JM67L7_cjs.UserLifecycle; }
+});
+Object.defineProperty(exports, "UserClient", {
+  enumerable: true,
+  get: function () { return chunkDEUBKZH5_cjs.UserClient; }
+});
+Object.defineProperty(exports, "OperatorLifecycle", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.OperatorLifecycle; }
+});
+Object.defineProperty(exports, "PaymasterOperatorClient", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.PaymasterOperatorClient; }
+});
+Object.defineProperty(exports, "ProposalState", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.ProposalState; }
+});
+Object.defineProperty(exports, "ProtocolClient", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.ProtocolClient; }
+});
+Object.defineProperty(exports, "ProtocolGovernance", {
+  enumerable: true,
+  get: function () { return chunkZ4GZ6DQA_cjs.ProtocolGovernance; }
+});
+Object.defineProperty(exports, "AirAccount", {
+  enumerable: true,
+  get: function () { return chunkXQROKLZI_cjs.src_exports; }
+});
+Object.defineProperty(exports, "KMS", {
+  enumerable: true,
+  get: function () { return chunkXQROKLZI_cjs.src_exports; }
+});
+Object.defineProperty(exports, "UserOpClient", {
+  enumerable: true,
+  get: function () { return chunkM7HXR7G5_cjs.UserOpClient; }
+});
+Object.defineProperty(exports, "createEOAWalletClient", {
+  enumerable: true,
+  get: function () { return chunkM7HXR7G5_cjs.createEOAWalletClient; }
+});
+Object.defineProperty(exports, "getUserOpHash", {
+  enumerable: true,
+  get: function () { return chunkM7HXR7G5_cjs.getUserOpHash; }
+});
+Object.defineProperty(exports, "packUserOpLimits", {
+  enumerable: true,
+  get: function () { return chunkM7HXR7G5_cjs.packUserOpLimits; }
+});
+Object.defineProperty(exports, "toSimpleSmartAccount", {
+  enumerable: true,
+  get: function () { return chunkM7HXR7G5_cjs.toSimpleSmartAccount; }
+});
+Object.defineProperty(exports, "ReputationClient", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.ReputationClient; }
+});
+Object.defineProperty(exports, "checkMySBT", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.checkMySBT; }
+});
+Object.defineProperty(exports, "getMySBTId", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.getMySBTId; }
+});
+Object.defineProperty(exports, "FinanceClient", {
+  enumerable: true,
+  get: function () { return chunkY4EJX7UA_cjs.FinanceClient; }
+});
+Object.defineProperty(exports, "PaymasterClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterClient; }
+});
+Object.defineProperty(exports, "PaymasterManager", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterManager; }
+});
+Object.defineProperty(exports, "PaymasterOperator", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterOperator; }
+});
+Object.defineProperty(exports, "SuperPaymasterAdminClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.SuperPaymasterAdminClient; }
+});
+Object.defineProperty(exports, "SuperPaymasterClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.SuperPaymasterClient; }
+});
+Object.defineProperty(exports, "buildPaymasterData", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.buildPaymasterData; }
+});
+Object.defineProperty(exports, "buildSuperPaymasterData", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.buildSuperPaymasterData; }
+});
+Object.defineProperty(exports, "checkEligibility", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.checkEligibility; }
+});
+Object.defineProperty(exports, "formatUserOpV07", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.formatUserOpV07; }
+});
+Object.defineProperty(exports, "getPaymasterV4Middleware", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getPaymasterV4Middleware; }
+});
+Object.defineProperty(exports, "getSuperPaymasterMiddleware", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getSuperPaymasterMiddleware; }
+});
+Object.defineProperty(exports, "getUserOpHashV07", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getUserOpHashV07; }
+});
+Object.defineProperty(exports, "tuneGasLimit", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.tuneGasLimit; }
+});
+Object.defineProperty(exports, "EIP3009_TYPES", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.EIP3009_TYPES; }
+});
+Object.defineProperty(exports, "FacilitatorClient", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.FacilitatorClient; }
+});
+Object.defineProperty(exports, "GTOKEN_EIP712_DOMAIN", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.GTOKEN_EIP712_DOMAIN; }
+});
+Object.defineProperty(exports, "HEADER_PAYMENT_REQUIRED", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.HEADER_PAYMENT_REQUIRED; }
+});
+Object.defineProperty(exports, "HEADER_PAYMENT_RESPONSE", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.HEADER_PAYMENT_RESPONSE; }
+});
+Object.defineProperty(exports, "HEADER_PAYMENT_SIGNATURE", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.HEADER_PAYMENT_SIGNATURE; }
+});
+Object.defineProperty(exports, "HEADER_V1_PAYMENT", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.HEADER_V1_PAYMENT; }
+});
+Object.defineProperty(exports, "HEADER_V1_PAYMENT_RESPONSE", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.HEADER_V1_PAYMENT_RESPONSE; }
+});
+Object.defineProperty(exports, "X402Client", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.X402Client; }
+});
+Object.defineProperty(exports, "decodePaymentPayload", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.decodePaymentPayload; }
+});
+Object.defineProperty(exports, "decodePaymentRequired", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.decodePaymentRequired; }
+});
+Object.defineProperty(exports, "decodeSettleResponse", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.decodeSettleResponse; }
+});
+Object.defineProperty(exports, "encodePaymentPayload", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.encodePaymentPayload; }
+});
+Object.defineProperty(exports, "encodePaymentRequired", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.encodePaymentRequired; }
+});
+Object.defineProperty(exports, "encodeSettleResponse", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.encodeSettleResponse; }
+});
+Object.defineProperty(exports, "extractPaymentRequired", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.extractPaymentRequired; }
+});
+Object.defineProperty(exports, "extractSettleResponse", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.extractSettleResponse; }
+});
+Object.defineProperty(exports, "generateNonce", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.generateNonce; }
+});
+Object.defineProperty(exports, "getEIP3009Domain", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.getEIP3009Domain; }
+});
+Object.defineProperty(exports, "signCancelAuthorization", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.signCancelAuthorization; }
+});
+Object.defineProperty(exports, "signGTokenTransferWithAuthorization", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.signGTokenTransferWithAuthorization; }
+});
+Object.defineProperty(exports, "signReceiveWithAuthorization", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.signReceiveWithAuthorization; }
+});
+Object.defineProperty(exports, "signTransferWithAuthorization", {
+  enumerable: true,
+  get: function () { return chunk5JFYTJOE_cjs.signTransferWithAuthorization; }
+});
+Object.defineProperty(exports, "AASTAR_COMMUNITY", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AASTAR_COMMUNITY; }
+});
+Object.defineProperty(exports, "AAStarAirAccountFactoryV7ABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarAirAccountFactoryV7ABI; }
+});
+Object.defineProperty(exports, "AAStarAirAccountFactoryV7Artifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarAirAccountFactoryV7Artifact; }
+});
+Object.defineProperty(exports, "AAStarAirAccountV7ABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarAirAccountV7ABI; }
+});
+Object.defineProperty(exports, "AAStarAirAccountV7Artifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarAirAccountV7Artifact; }
+});
+Object.defineProperty(exports, "AAStarBLSAggregatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarBLSAggregatorABI; }
+});
+Object.defineProperty(exports, "AAStarBLSAggregatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarBLSAggregatorArtifact; }
+});
+Object.defineProperty(exports, "AAStarBLSAlgorithmABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarBLSAlgorithmABI; }
+});
+Object.defineProperty(exports, "AAStarBLSAlgorithmArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarBLSAlgorithmArtifact; }
+});
+Object.defineProperty(exports, "AAStarValidatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarValidatorABI; }
+});
+Object.defineProperty(exports, "AAStarValidatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AAStarValidatorArtifact; }
+});
+Object.defineProperty(exports, "ALL_ROLES", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ALL_ROLES; }
+});
+Object.defineProperty(exports, "AgentRegistryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AgentRegistryABI; }
+});
+Object.defineProperty(exports, "AgentRegistryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AgentRegistryArtifact; }
+});
+Object.defineProperty(exports, "AirAccountDelegateABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AirAccountDelegateABI; }
+});
+Object.defineProperty(exports, "AirAccountDelegateArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AirAccountDelegateArtifact; }
+});
+Object.defineProperty(exports, "AirAccountExtensionABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AirAccountExtensionABI; }
+});
+Object.defineProperty(exports, "AirAccountExtensionArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AirAccountExtensionArtifact; }
+});
+Object.defineProperty(exports, "AuthorizationState", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.AuthorizationState; }
+});
+Object.defineProperty(exports, "BLSAggregatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSAggregatorABI; }
+});
+Object.defineProperty(exports, "BLSAggregatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSAggregatorArtifact; }
+});
+Object.defineProperty(exports, "BLSHelpers", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSHelpers; }
+});
+Object.defineProperty(exports, "BLSSigner", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSSigner; }
+});
+Object.defineProperty(exports, "BLSValidatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSValidatorABI; }
+});
+Object.defineProperty(exports, "BLSValidatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLSValidatorArtifact; }
+});
+Object.defineProperty(exports, "BLS_POP_DST", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BLS_POP_DST; }
+});
+Object.defineProperty(exports, "BRANDING", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BRANDING; }
+});
+Object.defineProperty(exports, "BREAD_COMMUNITY", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BREAD_COMMUNITY; }
+});
+Object.defineProperty(exports, "BaseClient", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BaseClient; }
+});
+Object.defineProperty(exports, "BundlerClient", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.BundlerClient; }
+});
+Object.defineProperty(exports, "COMMUNITIES", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.COMMUNITIES; }
+});
+Object.defineProperty(exports, "CONTRACTS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.CONTRACTS; }
+});
+Object.defineProperty(exports, "CONTRACT_METADATA", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.CONTRACT_METADATA; }
+});
+Object.defineProperty(exports, "CalldataParserRegistryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.CalldataParserRegistryABI; }
+});
+Object.defineProperty(exports, "CalldataParserRegistryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.CalldataParserRegistryArtifact; }
+});
+Object.defineProperty(exports, "ContractConfigManager", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ContractConfigManager; }
+});
+Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.DEFAULT_ADMIN_ROLE; }
+});
+Object.defineProperty(exports, "DVTValidatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.DVTValidatorABI; }
+});
+Object.defineProperty(exports, "DVTValidatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.DVTValidatorArtifact; }
+});
+Object.defineProperty(exports, "DVT_TIER_T2", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.DVT_TIER_T2; }
+});
+Object.defineProperty(exports, "DVT_TIER_T3", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.DVT_TIER_T3; }
+});
+Object.defineProperty(exports, "EntryPointABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.EntryPointABI; }
+});
+Object.defineProperty(exports, "EntryPointArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.EntryPointArtifact; }
+});
+Object.defineProperty(exports, "EntryPointVersion", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.EntryPointVersion; }
+});
+Object.defineProperty(exports, "ForceExitModuleABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ForceExitModuleABI; }
+});
+Object.defineProperty(exports, "ForceExitModuleArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ForceExitModuleArtifact; }
+});
+Object.defineProperty(exports, "GTokenABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenABI; }
+});
+Object.defineProperty(exports, "GTokenArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenArtifact; }
+});
+Object.defineProperty(exports, "GTokenAuthorizationABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenAuthorizationABI; }
+});
+Object.defineProperty(exports, "GTokenAuthorizationArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenAuthorizationArtifact; }
+});
+Object.defineProperty(exports, "GTokenStakingABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenStakingABI; }
+});
+Object.defineProperty(exports, "GTokenStakingArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.GTokenStakingArtifact; }
+});
+Object.defineProperty(exports, "INITIAL_ROLE_STAKES", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.INITIAL_ROLE_STAKES; }
+});
+Object.defineProperty(exports, "LINKS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.LINKS; }
+});
+Object.defineProperty(exports, "MicroPaymentChannelABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.MicroPaymentChannelABI; }
+});
+Object.defineProperty(exports, "MicroPaymentChannelArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.MicroPaymentChannelArtifact; }
+});
+Object.defineProperty(exports, "MySBTABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.MySBTABI; }
+});
+Object.defineProperty(exports, "MySBTArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.MySBTArtifact; }
+});
+Object.defineProperty(exports, "NETWORKS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.NETWORKS; }
+});
+Object.defineProperty(exports, "NodeType", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.NodeType; }
+});
+Object.defineProperty(exports, "PaymasterABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PaymasterABI; }
+});
+Object.defineProperty(exports, "PaymasterArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PaymasterArtifact; }
+});
+Object.defineProperty(exports, "PaymasterFactoryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PaymasterFactoryABI; }
+});
+Object.defineProperty(exports, "PaymasterFactoryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PaymasterFactoryArtifact; }
+});
+Object.defineProperty(exports, "PolicyDecision", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PolicyDecision; }
+});
+Object.defineProperty(exports, "PolicyRegistryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PolicyRegistryABI; }
+});
+Object.defineProperty(exports, "PolicyRegistryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.PolicyRegistryArtifact; }
+});
+Object.defineProperty(exports, "ROLE_ANODE", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_ANODE; }
+});
+Object.defineProperty(exports, "ROLE_COMMUNITY", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_COMMUNITY; }
+});
+Object.defineProperty(exports, "ROLE_DVT", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_DVT; }
+});
+Object.defineProperty(exports, "ROLE_ENDUSER", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_ENDUSER; }
+});
+Object.defineProperty(exports, "ROLE_KMS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_KMS; }
+});
+Object.defineProperty(exports, "ROLE_NAMES", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_NAMES; }
+});
+Object.defineProperty(exports, "ROLE_PAYMASTER_AOA", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_PAYMASTER_AOA; }
+});
+Object.defineProperty(exports, "ROLE_PAYMASTER_SUPER", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_PAYMASTER_SUPER; }
+});
+Object.defineProperty(exports, "ROLE_PERMISSION_LEVELS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ROLE_PERMISSION_LEVELS; }
+});
+Object.defineProperty(exports, "RegistryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.RegistryABI; }
+});
+Object.defineProperty(exports, "RegistryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.RegistryArtifact; }
+});
+Object.defineProperty(exports, "ReputationSystemABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ReputationSystemABI; }
+});
+Object.defineProperty(exports, "ReputationSystemArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.ReputationSystemArtifact; }
+});
+Object.defineProperty(exports, "RequirementChecker", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.RequirementChecker; }
+});
+Object.defineProperty(exports, "RolePermissionLevel", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.RolePermissionLevel; }
+});
+Object.defineProperty(exports, "SEPOLIA_CONTRACTS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SEPOLIA_CONTRACTS; }
+});
+Object.defineProperty(exports, "SEPOLIA_V2_VERSIONS", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SEPOLIA_V2_VERSIONS; }
+});
+Object.defineProperty(exports, "SepoliaFaucetAPI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SepoliaFaucetAPI; }
+});
+Object.defineProperty(exports, "SessionKeyValidatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SessionKeyValidatorABI; }
+});
+Object.defineProperty(exports, "SessionKeyValidatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SessionKeyValidatorArtifact; }
+});
+Object.defineProperty(exports, "SimpleAccountABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SimpleAccountABI; }
+});
+Object.defineProperty(exports, "SimpleAccountArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SimpleAccountArtifact; }
+});
+Object.defineProperty(exports, "SimpleAccountFactoryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SimpleAccountFactoryABI; }
+});
+Object.defineProperty(exports, "SimpleAccountFactoryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SimpleAccountFactoryArtifact; }
+});
+Object.defineProperty(exports, "StateValidator", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.StateValidator; }
+});
+Object.defineProperty(exports, "SuperPaymasterABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SuperPaymasterABI; }
+});
+Object.defineProperty(exports, "SuperPaymasterArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.SuperPaymasterArtifact; }
+});
+Object.defineProperty(exports, "V2_SUMMARY", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.V2_SUMMARY; }
+});
+Object.defineProperty(exports, "X402FacilitatorABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.X402FacilitatorABI; }
+});
+Object.defineProperty(exports, "X402FacilitatorArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.X402FacilitatorArtifact; }
+});
+Object.defineProperty(exports, "accountActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.accountActions; }
+});
+Object.defineProperty(exports, "accountFactoryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.accountFactoryActions; }
+});
+Object.defineProperty(exports, "agentActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.agentActions; }
+});
+Object.defineProperty(exports, "agentRegistryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.agentRegistryActions; }
+});
+Object.defineProperty(exports, "aggregatorActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.aggregatorActions; }
+});
+Object.defineProperty(exports, "airAccountActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.airAccountActions; }
+});
+Object.defineProperty(exports, "airAccountExtensionActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.airAccountExtensionActions; }
+});
+Object.defineProperty(exports, "airAccountFactoryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.airAccountFactoryActions; }
+});
+Object.defineProperty(exports, "blsAlgorithmActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.blsAlgorithmActions; }
+});
+Object.defineProperty(exports, "channelActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.channelActions; }
+});
+Object.defineProperty(exports, "createAAStarPublicClient", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.createAAStarPublicClient; }
+});
+Object.defineProperty(exports, "createHeliosTransport", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.createHeliosTransport; }
+});
+Object.defineProperty(exports, "dvtActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.dvtActions; }
+});
+Object.defineProperty(exports, "encodeDVTAccountSignature", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.encodeDVTAccountSignature; }
+});
+Object.defineProperty(exports, "encodeDVTVerifierProof", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.encodeDVTVerifierProof; }
+});
+Object.defineProperty(exports, "encodeG2Point", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.encodeG2Point; }
+});
+Object.defineProperty(exports, "entryPointActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.entryPointActions; }
+});
+Object.defineProperty(exports, "forceExitActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.forceExitActions; }
+});
+Object.defineProperty(exports, "gTokenActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.gTokenActions; }
+});
+Object.defineProperty(exports, "gTokenAuthorizationActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.gTokenAuthorizationActions; }
+});
+Object.defineProperty(exports, "getAddressUrl", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getAddressUrl; }
+});
+Object.defineProperty(exports, "getAllCommunityConfigs", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getAllCommunityConfigs; }
+});
+Object.defineProperty(exports, "getAllV2Contracts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getAllV2Contracts; }
+});
+Object.defineProperty(exports, "getBlockExplorer", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getBlockExplorer; }
+});
+Object.defineProperty(exports, "getChainId", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getChainId; }
+});
+Object.defineProperty(exports, "getCommunities", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getCommunities; }
+});
+Object.defineProperty(exports, "getCommunity", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getCommunity; }
+});
+Object.defineProperty(exports, "getCommunityConfig", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getCommunityConfig; }
+});
+Object.defineProperty(exports, "getContract", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getContract; }
+});
+Object.defineProperty(exports, "getContractNetworks", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getContractNetworks; }
+});
+Object.defineProperty(exports, "getContracts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getContracts; }
+});
+Object.defineProperty(exports, "getCoreContracts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getCoreContracts; }
+});
+Object.defineProperty(exports, "getDeploymentDate", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getDeploymentDate; }
+});
+Object.defineProperty(exports, "getEntryPoint", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getEntryPoint; }
+});
+Object.defineProperty(exports, "getNetwork", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getNetwork; }
+});
+Object.defineProperty(exports, "getPaymasterV4_1", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getPaymasterV4_1; }
+});
+Object.defineProperty(exports, "getRoleName", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getRoleName; }
+});
+Object.defineProperty(exports, "getRpcUrl", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getRpcUrl; }
+});
+Object.defineProperty(exports, "getSimpleAccountFactory", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getSimpleAccountFactory; }
+});
+Object.defineProperty(exports, "getSuperPaymasterV2", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getSuperPaymasterV2; }
+});
+Object.defineProperty(exports, "getTestAccounts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getTestAccounts; }
+});
+Object.defineProperty(exports, "getTestTokenContracts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getTestTokenContracts; }
+});
+Object.defineProperty(exports, "getTokenContracts", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getTokenContracts; }
+});
+Object.defineProperty(exports, "getTxUrl", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getTxUrl; }
+});
+Object.defineProperty(exports, "getV2ContractByAddress", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getV2ContractByAddress; }
+});
+Object.defineProperty(exports, "getV2ContractByName", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getV2ContractByName; }
+});
+Object.defineProperty(exports, "getV2ContractsByDate", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.getV2ContractsByDate; }
+});
+Object.defineProperty(exports, "hashToFieldU0U1", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.hashToFieldU0U1; }
+});
+Object.defineProperty(exports, "isContractNetworkSupported", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.isContractNetworkSupported; }
+});
+Object.defineProperty(exports, "isRegisteredCommunity", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.isRegisteredCommunity; }
+});
+Object.defineProperty(exports, "isV2Contract", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.isV2Contract; }
+});
+Object.defineProperty(exports, "lookupAddress", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.lookupAddress; }
+});
+Object.defineProperty(exports, "paymasterActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.paymasterActions; }
+});
+Object.defineProperty(exports, "paymasterFactoryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.paymasterFactoryActions; }
+});
+Object.defineProperty(exports, "policyRegistryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.policyRegistryActions; }
+});
+Object.defineProperty(exports, "registryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.registryActions; }
+});
+Object.defineProperty(exports, "reputationActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.reputationActions; }
+});
+Object.defineProperty(exports, "resolveEns", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.resolveEns; }
+});
+Object.defineProperty(exports, "resolveEnsVerified", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.resolveEnsVerified; }
+});
+Object.defineProperty(exports, "sbtActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.sbtActions; }
+});
+Object.defineProperty(exports, "sessionKeyValidatorActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.sessionKeyValidatorActions; }
+});
+Object.defineProperty(exports, "stakingActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.stakingActions; }
+});
+Object.defineProperty(exports, "superPaymasterActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.superPaymasterActions; }
+});
+Object.defineProperty(exports, "tokenActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.tokenActions; }
+});
+Object.defineProperty(exports, "x402Actions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.x402Actions; }
+});
+Object.defineProperty(exports, "x402IsNonceUsed", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.x402IsNonceUsed; }
+});
+Object.defineProperty(exports, "x402NonceKey", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.x402NonceKey; }
+});
+Object.defineProperty(exports, "xPNTsFactoryABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsFactoryABI; }
+});
+Object.defineProperty(exports, "xPNTsFactoryActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsFactoryActions; }
+});
+Object.defineProperty(exports, "xPNTsFactoryArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsFactoryArtifact; }
+});
+Object.defineProperty(exports, "xPNTsTokenABI", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsTokenABI; }
+});
+Object.defineProperty(exports, "xPNTsTokenActions", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsTokenActions; }
+});
+Object.defineProperty(exports, "xPNTsTokenArtifact", {
+  enumerable: true,
+  get: function () { return chunkCIEYY3A6_cjs.xPNTsTokenArtifact; }
+});
+Object.defineProperty(exports, "AGENT_IDENTITY_REGISTRY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.AGENT_IDENTITY_REGISTRY_ADDRESS; }
+});
+Object.defineProperty(exports, "AGENT_REPUTATION_REGISTRY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.AGENT_REPUTATION_REGISTRY_ADDRESS; }
+});
+Object.defineProperty(exports, "ALL_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.ALL_ADDRESSES; }
+});
+Object.defineProperty(exports, "APNTS_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.APNTS_ADDRESS; }
+});
+Object.defineProperty(exports, "BLS_AGGREGATOR_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.BLS_AGGREGATOR_ADDRESS; }
+});
+Object.defineProperty(exports, "BLS_VALIDATOR_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.BLS_VALIDATOR_ADDRESS; }
+});
+Object.defineProperty(exports, "BPS_DENOMINATOR", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.BPS_DENOMINATOR; }
+});
+Object.defineProperty(exports, "CANONICAL_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.CANONICAL_ADDRESSES; }
+});
+Object.defineProperty(exports, "CHAIN_MAINNET", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.CHAIN_MAINNET; }
+});
+Object.defineProperty(exports, "CHAIN_SEPOLIA", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.CHAIN_SEPOLIA; }
+});
+Object.defineProperty(exports, "COMMUNITY_OWNERS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.COMMUNITY_OWNERS; }
+});
+Object.defineProperty(exports, "CONTRACT_SRC_HASH", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.CONTRACT_SRC_HASH; }
+});
+Object.defineProperty(exports, "CORE_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.CORE_ADDRESSES; }
+});
+Object.defineProperty(exports, "DEFAULT_APNTS_PRICE_USD", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_APNTS_PRICE_USD; }
+});
+Object.defineProperty(exports, "DEFAULT_CALL_GAS_LIMIT", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_CALL_GAS_LIMIT; }
+});
+Object.defineProperty(exports, "DEFAULT_GAS_TOKEN_MINT_AMOUNT", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_GAS_TOKEN_MINT_AMOUNT; }
+});
+Object.defineProperty(exports, "DEFAULT_PRE_VERIFICATION_GAS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_PRE_VERIFICATION_GAS; }
+});
+Object.defineProperty(exports, "DEFAULT_TIMEOUT_MS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_TIMEOUT_MS; }
+});
+Object.defineProperty(exports, "DEFAULT_TOKEN_NAME", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_TOKEN_NAME; }
+});
+Object.defineProperty(exports, "DEFAULT_TOKEN_SYMBOL", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_TOKEN_SYMBOL; }
+});
+Object.defineProperty(exports, "DEFAULT_USDT_MINT_AMOUNT", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_USDT_MINT_AMOUNT; }
+});
+Object.defineProperty(exports, "DEFAULT_VERIFICATION_GAS_LIMIT", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DEFAULT_VERIFICATION_GAS_LIMIT; }
+});
+Object.defineProperty(exports, "DVT_VALIDATOR_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.DVT_VALIDATOR_ADDRESS; }
+});
+Object.defineProperty(exports, "ENTRY_POINT_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.ENTRY_POINT_ADDRESS; }
+});
+Object.defineProperty(exports, "FAUCET_API_URL", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.FAUCET_API_URL; }
+});
+Object.defineProperty(exports, "GTOKEN_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.GTOKEN_ADDRESS; }
+});
+Object.defineProperty(exports, "GTOKEN_STAKING_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.GTOKEN_STAKING_ADDRESS; }
+});
+Object.defineProperty(exports, "MAX_SERVICE_FEE", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.MAX_SERVICE_FEE; }
+});
+Object.defineProperty(exports, "MICRO_PAYMENT_CHANNEL_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.MICRO_PAYMENT_CHANNEL_ADDRESS; }
+});
+Object.defineProperty(exports, "MONITORING_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.MONITORING_ADDRESSES; }
+});
+Object.defineProperty(exports, "NODE_STAKE_AMOUNTS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.NODE_STAKE_AMOUNTS; }
+});
+Object.defineProperty(exports, "OFFICIAL_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.OFFICIAL_ADDRESSES; }
+});
+Object.defineProperty(exports, "PAYMASTER_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.PAYMASTER_ADDRESSES; }
+});
+Object.defineProperty(exports, "PAYMASTER_FACTORY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.PAYMASTER_FACTORY_ADDRESS; }
+});
+Object.defineProperty(exports, "PAYMASTER_V4_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.PAYMASTER_V4_ADDRESS; }
+});
+Object.defineProperty(exports, "PAYMASTER_V4_IMPL_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.PAYMASTER_V4_IMPL_ADDRESS; }
+});
+Object.defineProperty(exports, "REGISTRY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.REGISTRY_ADDRESS; }
+});
+Object.defineProperty(exports, "REPUTATION_SYSTEM_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.REPUTATION_SYSTEM_ADDRESS; }
+});
+Object.defineProperty(exports, "SBT_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.SBT_ADDRESS; }
+});
+Object.defineProperty(exports, "SERVICE_FEE_RATE", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.SERVICE_FEE_RATE; }
+});
+Object.defineProperty(exports, "SUPER_PAYMASTER_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.SUPER_PAYMASTER_ADDRESS; }
+});
+Object.defineProperty(exports, "TEST_ACCOUNT_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.TEST_ACCOUNT_ADDRESSES; }
+});
+Object.defineProperty(exports, "TEST_ACCOUNT_POOL_SIZE", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.TEST_ACCOUNT_POOL_SIZE; }
+});
+Object.defineProperty(exports, "TEST_COMMUNITIES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.TEST_COMMUNITIES; }
+});
+Object.defineProperty(exports, "TEST_TOKEN_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.TEST_TOKEN_ADDRESSES; }
+});
+Object.defineProperty(exports, "TOKEN_ADDRESSES", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.TOKEN_ADDRESSES; }
+});
+Object.defineProperty(exports, "XPNTS_FACTORY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.XPNTS_FACTORY_ADDRESS; }
+});
+Object.defineProperty(exports, "applyConfig", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.applyConfig; }
+});
+Object.defineProperty(exports, "describeSupportedChains", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.describeSupportedChains; }
+});
+Object.defineProperty(exports, "getCanonicalAddresses", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.getCanonicalAddresses; }
+});
+Object.defineProperty(exports, "isSupportedChainId", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.isSupportedChainId; }
+});
+Object.defineProperty(exports, "listSupportedChainIds", {
+  enumerable: true,
+  get: function () { return chunkMXJEULSE_cjs.listSupportedChainIds; }
+});
+exports.CustomErrors = CustomErrors;
+exports.ExperimentClient = ExperimentClient;
+exports.FundingManager = FundingManager;
+exports.KeyManager = KeyManager;
+exports.RoleDataFactory = RoleDataFactory;
+exports.RoleIds = RoleIds;
+exports.UserOpScenarioBuilder = UserOpScenarioBuilder;
+exports.UserOpScenarioType = UserOpScenarioType;
+exports.UserOperationBuilder = UserOperationBuilder;
+exports.createAdminClient = createAdminClient;
+exports.createCommunityClient = createCommunityClient;
+exports.createEndUserClient = createEndUserClient;
+exports.createOperatorClient = createOperatorClient;
+exports.decodeContractError = decodeContractError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map