@actalink/commonlib 0.0.8 → 0.0.9

package/dist/index.js

@@ -517,20 +517,33 @@ function getTokenByChainIdAndAddress(chainId, address) {
 }
 
 // src/deposit.ts
-import { toHex as toHex2, zeroAddress as zeroAddress4 } from "viem";
+import { toHex as toHex2, zeroAddress as zeroAddress3 } from "viem";
 
 // src/account.ts
 import {
   http as http2,
   getAddress as getAddress2,
-  parseAbi as parseAbi2
+  parseAbi as parseAbi2,
+  encodeFunctionData as encodeFunctionData2,
+  concatHex,
+  pad
 } from "viem";
+import { parseAccount } from "viem/utils";
 import {
   createPaymasterClient,
   formatUserOperationRequest
 } from "viem/account-abstraction";
-import { addressToEmptyAccount, createKernelAccount as createKernelAccount2 } from "@zerodev/sdk";
-import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import {
+  addressToEmptyAccount,
+  createKernelAccount,
+  createKernelAccountClient,
+  KernelV3AccountAbi
+} from "@zerodev/sdk";
+import {
+  getEntryPoint,
+  KERNEL_V3_1,
+  VALIDATOR_TYPE
+} from "@zerodev/sdk/constants";
 import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
 import { createSmartAccountClient } from "permissionless";
 import { createPimlicoClient } from "permissionless/clients/pimlico";
@@ -648,924 +661,981 @@ var ViemClient = class {
   }
 };
 
-// src/utils.ts
-import {
-  constants,
-  fixSignedData,
-  toSigner,
-  KernelV3AccountAbi,
-  KernelFactoryStakerAbi,
-  KernelV3FactoryAbi,
-  KernelV3_1AccountAbi,
-  createKernelAccount
-} from "@zerodev/sdk";
-import {
-  toKernelPluginManager
-} from "@zerodev/sdk/accounts";
-import {
-  concat,
-  encodeAbiParameters,
-  keccak256,
-  slice,
-  zeroAddress as zeroAddress2,
-  decodeFunctionData
-} from "viem";
-import {
-  toAccount,
-  privateKeyToAccount
-} from "viem/accounts";
-import { getChainId, readContract } from "viem/actions";
-import { getAction } from "viem/utils";
+// src/account.ts
+import { toECDSASigner } from "@zerodev/permissions/signers";
 import {
-  getUserOperationHash
-} from "viem/account-abstraction";
+  serializePermissionAccount,
+  toPermissionValidator
+} from "@zerodev/permissions";
 import {
   toCallPolicy,
-  toGasPolicy,
-  toRateLimitPolicy,
-  toSignatureCallerPolicy,
-  toSudoPolicy,
-  toTimestampPolicy
+  CallPolicyVersion,
+  ParamCondition
 } from "@zerodev/permissions/policies";
-import { coerce, gt } from "semver";
-
-// src/api.ts
-import { toHex } from "viem";
-var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
-  HttpMethod2["Get"] = "get";
-  HttpMethod2["Post"] = "post";
-  HttpMethod2["Delete"] = "delete";
-  HttpMethod2["Update"] = "update";
-  return HttpMethod2;
-})(HttpMethod || {});
-function sendRequest(_0) {
-  return __async(this, arguments, function* ({
-    url,
-    method,
-    body,
-    headers = {}
-  }) {
-    var _a;
-    const response = yield fetch(url, {
-      method,
-      headers: __spreadProps(__spreadValues({}, headers), {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      }),
-      body: JSON.stringify(body)
-    });
-    let jsonResponse;
-    const res = yield response.json();
-    if (!response.ok) {
-      jsonResponse = {
-        error: {
-          code: response.status,
-          message: response.statusText
-        },
-        data: void 0
-      };
-      return jsonResponse;
-    }
-    if (!res) {
-      jsonResponse = {
-        error: {
-          code: 400,
-          message: "No response received."
-        },
-        data: void 0
-      };
-      return jsonResponse;
-    }
-    if (res == null ? void 0 : res.error) {
-      jsonResponse = {
-        error: {
-          code: response.status,
-          message: res.error
+var ActaAccount = class {
+  constructor(chainId, publicClient, signer) {
+    this.chainId = chainId;
+    this.signer = signer;
+    this.publicClient = publicClient;
+  }
+  createAccount() {
+    return __async(this, null, function* () {
+      const kernelVersion = KERNEL_V3_1;
+      const entryPoint = getEntryPoint("0.7");
+      const ecdsaValidator = yield signerToEcdsaValidator(this.publicClient, {
+        signer: this.signer,
+        entryPoint,
+        kernelVersion
+      });
+      const account = yield createKernelAccount(this.publicClient, {
+        plugins: {
+          sudo: ecdsaValidator
         },
-        data: void 0
-      };
-      return jsonResponse;
-    }
-    jsonResponse = {
-      data: res.data,
-      message: (_a = res.message) != null ? _a : "Success",
-      error: void 0
-    };
-    return jsonResponse;
-  });
-}
-function createSessionAPICall(url, sessionBodyParams) {
-  return __async(this, null, function* () {
-    const response = yield sendRequest({
-      url,
-      method: "post" /* Post */,
-      body: sessionBodyParams
-    });
-    return response.data;
-  });
-}
-function verifySessionAPICall(url, sessionId) {
-  return __async(this, null, function* () {
-    const response = yield sendRequest({
-      url,
-      method: "get" /* Get */
+        entryPoint,
+        kernelVersion
+      });
+      return account;
     });
-    return response.data;
-  });
-}
-function scheduleRecurringPaymentsAPICall(url, params) {
-  return __async(this, null, function* () {
-    const parsedParams = __spreadProps(__spreadValues({}, params), {
-      amount: toHex(params.amount)
+  }
+  createAccountHelpers() {
+    return __async(this, null, function* () {
+      const account = yield this.createAccount();
+      const entryPoint = getEntryPoint("0.7");
+      const paymasterClient = createPaymasterClient({
+        transport: http2(getPimlicoRpcByChainId(this.chainId))
+      });
+      const pimlicoClient = createPimlicoClient({
+        chain: getChainById(this.chainId),
+        transport: http2(getPimlicoRpcByChainId(this.chainId)),
+        entryPoint
+      });
+      const accountClient = createSmartAccountClient({
+        account,
+        chain: getChainById(this.chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: http2(getPimlicoRpcByChainId(this.chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          })
+        }
+      });
+      const kernelAccountClient = createKernelAccountClient({
+        account,
+        chain: getChainById(this.chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: http2(getPimlicoRpcByChainId(this.chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          })
+        }
+      });
+      return {
+        paymasterClient,
+        pimlicoClient,
+        accountClient,
+        kernelAccountClient
+      };
     });
-    const response = yield sendRequest({
-      url,
-      method: "post" /* Post */,
-      body: parsedParams
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver
+      } = parameters;
+      if (amount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (receiver === signerAddress) {
+        throw new Error("Receiver cannot be the same as the signer.");
+      }
+      const account = yield this.createAccount();
+      const { accountClient, pimlicoClient } = yield this.createAccountHelpers();
+      const fromAddress = signerAddress;
+      const smartAccountAddress = account.address;
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not found.");
+      }
+      const quotes = yield pimlicoClient.getTokenQuotes({
+        tokens: [token2.address],
+        chain: getChainById(chainId)
+      });
+      const { postOpGas, exchangeRate, paymaster } = quotes[0];
+      const userOperation = yield accountClient.prepareUserOperation({
+        calls: [
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              fromAddress,
+              "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+              BigInt(0)
+            ]
+          },
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [fromAddress, receiver, BigInt(0)]
+          }
+        ]
+      });
+      const userOperationMaxGas = userOperation.preVerificationGas + userOperation.callGasLimit + userOperation.verificationGasLimit + (userOperation.paymasterPostOpGasLimit || BigInt(0)) + (userOperation.paymasterVerificationGasLimit || BigInt(0));
+      const userOperationMaxCost = BigInt(
+        userOperationMaxGas * userOperation.maxFeePerGas
+      );
+      const estimatedGasCostInToken = (userOperationMaxCost + postOpGas * userOperation.maxFeePerGas) * exchangeRate / BigInt(1e18);
+      const ActalinkFeesInToken = amount * BigInt(20) / BigInt(1e4);
+      const estimatedTotalFeesInToken = estimatedGasCostInToken + ActalinkFeesInToken;
+      const feeInclusiveAmountInToken = amount - estimatedTotalFeesInToken;
+      const feeExclusiveAmountInToken = amount + estimatedTotalFeesInToken;
+      return {
+        estimatedGasCostInToken,
+        ActalinkFeesInToken,
+        estimatedTotalFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        paymaster,
+        userOperation
+      };
     });
-    return response.data;
-  });
-}
-function createBillingSessionAPICall(url, sessionBodyParams) {
-  return __async(this, null, function* () {
-    const response = yield sendRequest({
-      url,
-      method: "post" /* Post */,
-      body: sessionBodyParams
-    });
-    return response.data;
-  });
-}
-function fetchBillingSessionDetails(url) {
-  return __async(this, null, function* () {
-    const response = yield sendRequest({
-      url,
-      method: "get" /* Get */
-    });
-    return response.data;
-  });
-}
-function executeSinglePaymentAPICall(url, userOperation, paymentParams, serviceParams) {
-  return __async(this, null, function* () {
-    const params = {
-      userOperation,
-      paymentParams,
-      serviceParams
-    };
-    const response = yield sendRequest({
-      url,
-      method: "post" /* Post */,
-      body: params
-    });
-    return response.data;
-  });
-}
-
-// src/utils.ts
-var ECDSA_SIGNER_CONTRACT = "0x6A6F069E2a08c2468e7724Ab3250CdBFBA14D4FF";
-var billingServiceUrl = "https://api.acta.link/billing/v1/";
-var toSignerId = (signer) => {
-  return encodeAbiParameters(
-    [{ name: "signerData", type: "bytes" }],
-    [concat([signer.signerContractAddress, signer.getSignerData()])]
-  );
-};
-function toECDSASigner(_0) {
-  return __async(this, arguments, function* (signer, signerContractAddress = ECDSA_SIGNER_CONTRACT) {
-    const viemSigner = yield toSigner({ signer });
-    const account = toAccount({
-      address: viemSigner.address,
-      signMessage(_02) {
-        return __async(this, arguments, function* ({ message }) {
-          return fixSignedData(yield viemSigner.signMessage({ message }));
-        });
-      },
-      signTransaction(_, __) {
-        return __async(this, null, function* () {
-          throw new Error("Smart account signer doesn't need to sign transactions");
-        });
-      },
-      signTypedData(typedData) {
-        return __async(this, null, function* () {
-          return fixSignedData(
-            yield viemSigner.signTypedData(__spreadValues({}, typedData))
-          );
-        });
-      }
-    });
-    return {
-      account,
-      signerContractAddress,
-      getSignerData: () => {
-        return viemSigner.address;
-      },
-      getDummySignature: () => constants.DUMMY_ECDSA_SIG
-    };
-  });
-}
-var toPolicyId = (policies) => {
-  return encodeAbiParameters(
-    [{ name: "policiesData", type: "bytes[]" }],
-    [
-      policies.map(
-        (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
-      )
-    ]
-  );
-};
-function toPermissionValidator(_0, _1) {
-  return __async(this, arguments, function* (client, {
-    signer,
-    policies,
-    entryPoint,
-    kernelVersion: _,
-    flag = "0x0000" /* FOR_ALL_VALIDATION */
-  }) {
-    const chainId = client.chain ? client.chain.id : yield getChainId(client);
-    if (entryPoint.version !== "0.7") {
-      throw new Error("Only EntryPoint 0.7 is supported");
-    }
-    const getEnableData = (_kernelAccountAddress) => __async(null, null, function* () {
-      const enableData = encodeAbiParameters(
-        [{ name: "policyAndSignerData", type: "bytes[]" }],
-        [
-          [
-            ...policies.map(
-              (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
-            ),
-            concat([flag, signer.signerContractAddress, signer.getSignerData()])
-          ]
-        ]
-      );
-      return enableData;
-    });
-    const getPermissionId = () => {
-      const pIdData = encodeAbiParameters(
-        [{ name: "policyAndSignerData", type: "bytes[]" }],
-        [[toPolicyId(policies), flag, toSignerId(signer)]]
-      );
-      return slice(keccak256(pIdData), 0, 4);
-    };
-    return __spreadProps(__spreadValues({}, signer.account), {
-      supportedKernelVersions: ">=0.3.0",
-      validatorType: "PERMISSION",
-      address: zeroAddress2,
-      source: "PermissionValidator",
-      getEnableData,
-      getIdentifier: getPermissionId,
-      signMessage: (_02) => __async(null, [_02], function* ({ message }) {
-        return concat(["0xff", yield signer.account.signMessage({ message })]);
-      }),
-      signTypedData: (typedData) => __async(null, null, function* () {
-        return concat(["0xff", yield signer.account.signTypedData(typedData)]);
-      }),
-      signUserOperation: (userOperation) => __async(null, null, function* () {
-        const userOpHash = getUserOperationHash({
-          userOperation: __spreadProps(__spreadValues({}, userOperation), {
-            signature: "0x"
-          }),
-          entryPointAddress: entryPoint.address,
-          entryPointVersion: entryPoint.version,
-          chainId
-        });
-        const signature = yield signer.account.signMessage({
-          message: { raw: userOpHash }
-        });
-        return concat(["0xff", signature]);
-      }),
-      getNonceKey(_accountAddress, customNonceKey) {
-        return __async(this, null, function* () {
-          if (customNonceKey) {
-            return customNonceKey;
-          }
-          return BigInt(0);
-        });
-      },
-      getStubSignature(_userOperation) {
-        return __async(this, null, function* () {
-          return concat(["0xff", signer.getDummySignature()]);
-        });
-      },
-      getPluginSerializationParams: () => {
-        return {
-          policies
-        };
-      },
-      isEnabled: (kernelAccountAddress, _selector) => __async(null, null, function* () {
-        try {
-          const permissionConfig = yield getAction(
-            client,
-            readContract,
-            "readContract"
-          )({
-            abi: KernelV3AccountAbi,
-            address: kernelAccountAddress,
-            functionName: "permissionConfig",
-            args: [getPermissionId()]
-          });
-          return permissionConfig.signer === signer.signerContractAddress;
-        } catch (error) {
-          return false;
-        }
-      })
-    });
-  });
-}
-function bytesToBase64(bytes) {
-  const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join("");
-  return btoa(binString);
-}
-function isPermissionValidatorPlugin(plugin) {
-  return (plugin == null ? void 0 : plugin.getPluginSerializationParams) !== void 0;
-}
-var serializePermissionAccountParams = (params) => {
-  const replacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  };
-  const jsonString = JSON.stringify(params, replacer);
-  const uint8Array = new TextEncoder().encode(jsonString);
-  const base64String = bytesToBase64(uint8Array);
-  return base64String;
-};
-var serializePermissionAccount = (account, privateKey, enableSignature, eip7702Auth) => __async(null, null, function* () {
-  if (!isPermissionValidatorPlugin(account.kernelPluginManager))
-    throw new Error("Account plugin is not a permission validator");
-  const permissionParams = account.kernelPluginManager.getPluginSerializationParams();
-  const action = account.kernelPluginManager.getAction();
-  const validityData = account.kernelPluginManager.getValidityData();
-  const _enableSignature = enableSignature != null ? enableSignature : yield account.kernelPluginManager.getPluginEnableSignature(
-    account.address
-  );
-  const _eip7702Auth = account.authorization ? eip7702Auth != null ? eip7702Auth : yield account == null ? void 0 : account.eip7702Auth : void 0;
-  const accountParams = {
-    initCode: yield account.generateInitCode(),
-    accountAddress: account.address
-  };
-  const paramsToBeSerialized = {
-    permissionParams,
-    action,
-    validityData,
-    accountParams,
-    enableSignature: _enableSignature,
-    privateKey,
-    eip7702Auth: _eip7702Auth
-  };
-  return serializePermissionAccountParams(paramsToBeSerialized);
-});
-var isKernelVersionAfter = (kernelVersion, version) => {
-  const coercedKernelVersion = coerce(kernelVersion);
-  if (!coercedKernelVersion) return false;
-  return gt(coercedKernelVersion, version);
-};
-function base64ToBytes(base64) {
-  const binString = atob(base64);
-  return Uint8Array.from(binString, (m) => m.codePointAt(0));
-}
-var deserializePermissionAccountParams = (params) => {
-  const uint8Array = base64ToBytes(params);
-  const jsonString = new TextDecoder().decode(uint8Array);
-  return JSON.parse(jsonString);
-};
-var deserializePermissionAccount = (client, entryPoint, kernelVersion, modularPermissionAccountParams, modularSigner) => __async(null, null, function* () {
-  var _a;
-  if (entryPoint.version !== "0.7") {
-    throw new Error("Only EntryPoint 0.7 is supported");
-  }
-  const params = deserializePermissionAccountParams(
-    modularPermissionAccountParams
-  );
-  let signer;
-  if (params.privateKey)
-    signer = yield toECDSASigner(privateKeyToAccount(params.privateKey));
-  else if (modularSigner) signer = modularSigner;
-  else throw new Error("No signer or serialized sessionKey provided");
-  const modularPermissionPlugin = yield toPermissionValidator(client, {
-    signer,
-    policies: yield Promise.all(
-      ((_a = params.permissionParams.policies) == null ? void 0 : _a.map(
-        (policy) => createPolicyFromParams(policy)
-      )) || []
-    ),
-    entryPoint,
-    kernelVersion
-  });
-  const { index, validatorInitData, useMetaFactory } = decodeParamsFromInitCode(
-    params.accountParams.initCode,
-    kernelVersion
-  );
-  const kernelPluginManager = yield toKernelPluginManager(client, __spreadValues({
-    regular: modularPermissionPlugin,
-    pluginEnableSignature: params.enableSignature,
-    validatorInitData,
-    action: params.action,
-    entryPoint,
-    kernelVersion
-  }, params.validityData));
-  return createKernelAccount(client, {
-    entryPoint,
-    kernelVersion,
-    plugins: kernelPluginManager,
-    index,
-    address: params.accountParams.accountAddress,
-    useMetaFactory,
-    eip7702Auth: params.eip7702Auth
-  });
-});
-var createPolicyFromParams = (policy) => __async(null, null, function* () {
-  switch (policy.policyParams.type) {
-    case "call":
-      return yield toCallPolicy(policy.policyParams);
-    case "gas":
-      return yield toGasPolicy(policy.policyParams);
-    case "rate-limit":
-      return yield toRateLimitPolicy(policy.policyParams);
-    case "signature-caller":
-      return yield toSignatureCallerPolicy(policy.policyParams);
-    case "sudo":
-      return yield toSudoPolicy(policy.policyParams);
-    case "timestamp":
-      return yield toTimestampPolicy(policy.policyParams);
-    default:
-      throw new Error("Unsupported policy type");
-  }
-});
-var decodeParamsFromInitCode = (initCode, kernelVersion) => {
-  let index;
-  let validatorInitData;
-  let deployWithFactoryFunctionData;
-  let useMetaFactory = true;
-  if (initCode === "0x") {
-    return {
-      index: void 0,
-      validatorInitData: void 0,
-      useMetaFactory: true
-    };
-  }
-  try {
-    deployWithFactoryFunctionData = decodeFunctionData({
-      abi: KernelFactoryStakerAbi,
-      data: initCode
-    });
-  } catch (error) {
-    deployWithFactoryFunctionData = decodeFunctionData({
-      abi: KernelV3FactoryAbi,
-      data: initCode
-    });
-    useMetaFactory = false;
-  }
-  if (!deployWithFactoryFunctionData) throw new Error("Invalid initCode");
-  if (deployWithFactoryFunctionData.functionName === "deployWithFactory") {
-    index = BigInt(deployWithFactoryFunctionData.args[2]);
-    let initializeFunctionData;
-    if (kernelVersion === "0.3.0") {
-      initializeFunctionData = decodeFunctionData({
-        abi: KernelV3AccountAbi,
-        data: deployWithFactoryFunctionData.args[1]
-      });
-    } else {
-      initializeFunctionData = decodeFunctionData({
-        abi: KernelV3_1AccountAbi,
-        data: deployWithFactoryFunctionData.args[1]
-      });
-    }
-    if (!initializeFunctionData) throw new Error("Invalid initCode");
-    if (initializeFunctionData.functionName === "initialize") {
-      validatorInitData = {
-        validatorAddress: initializeFunctionData.args[0],
-        identifier: initializeFunctionData.args[0],
-        enableData: initializeFunctionData.args[2],
-        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
-      };
-    }
-  } else if (deployWithFactoryFunctionData.functionName === "createAccount") {
-    index = BigInt(deployWithFactoryFunctionData.args[1]);
-    let initializeFunctionData;
-    if (kernelVersion === "0.3.0") {
-      initializeFunctionData = decodeFunctionData({
-        abi: KernelV3AccountAbi,
-        data: deployWithFactoryFunctionData.args[0]
-      });
-    } else {
-      initializeFunctionData = decodeFunctionData({
-        abi: KernelV3_1AccountAbi,
-        data: deployWithFactoryFunctionData.args[0]
-      });
-    }
-    if (!initializeFunctionData) throw new Error("Invalid initCode");
-    if (initializeFunctionData.functionName === "initialize") {
-      validatorInitData = {
-        validatorAddress: initializeFunctionData.args[0],
-        identifier: initializeFunctionData.args[0],
-        enableData: initializeFunctionData.args[2],
-        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
-      };
-    }
-  }
-  if (index === void 0 || validatorInitData === void 0)
-    throw new Error("Invalid initCode");
-  return { index, validatorInitData, useMetaFactory };
-};
-var getPeriodInterval = (periodUnit) => {
-  switch (periodUnit) {
-    case "5mins":
-      return 5 * 60;
-    case "day":
-      return 24 * 60 * 60;
-    case "week":
-      return 7 * 24 * 60 * 60;
-    case "month":
-      return 28 * 24 * 60 * 60;
-    case "year":
-      return 365 * 24 * 60 * 60;
-    default:
-      throw new Error("Invalid period unit");
   }
-};
-var createBillingCheckoutSession = (serviceSessionparams) => __async(null, null, function* () {
-  try {
-    const sessionData = yield createBillingSessionAPICall(
-      `${billingServiceUrl}paysession/create`,
-      {
-        paylinkId: serviceSessionparams.paylinkId
+  signSinglePaymentOperation(singlePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (!this.signer) {
+          throw new Error("Signer is required for self custody payments.");
+        }
+        const {
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive,
+          allowMaxTokenApproval
+        } = singlePaymentParams;
+        if (amount <= BigInt(0)) {
+          throw new Error("Amount must be greater than 0.");
+        }
+        if (receiver === signerAddress) {
+          throw new Error("Receiver cannot be the same as the signer.");
+        }
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!token2) {
+          throw new Error("Token not found.");
+        }
+        const viemClient = new ViemClient(this.chainId, this.signer);
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster
+        } = yield this.estimateSinglePaymentGas({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive
+        });
+        const account = yield this.createAccount();
+        const { accountClient } = yield this.createAccountHelpers();
+        const fromAddress = signerAddress;
+        const smartAccountAddress = account.address;
+        const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+        const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
+        yield viemClient.checkAndApproveToken(
+          token2,
+          smartAccountAddress,
+          amountToTransfer,
+          allowMaxTokenApproval != null ? allowMaxTokenApproval : false
+        );
+        const userOperation = yield accountClient.prepareUserOperation({
+          calls: [
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [
+                fromAddress,
+                "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+                estimatedGasCostInToken
+              ]
+            },
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [fromAddress, receiver, receiverAmount]
+            }
+          ]
+        });
+        const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
+          chainId: this.chainId
+        }));
+        const rpcParameters = formatUserOperationRequest(__spreadProps(__spreadValues({}, userOperation), {
+          signature
+        }));
+        return rpcParameters;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to sign single payment operation.");
       }
-    );
-    if (sessionData) {
-      return sessionData.checkoutSessionId;
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(error.message);
-    }
-    throw new Error("Failed to create deposit session.");
-  }
-});
-var getBillingPaymentSessionDetails = (serviceSessionparams) => __async(null, null, function* () {
-  if (!serviceSessionparams.checkoutSessionId || serviceSessionparams.checkoutSessionId === "") {
-    throw new Error("checkout session ID is required.");
-  }
-  const sessionData = yield fetchBillingSessionDetails(
-    `${billingServiceUrl}paysession?checkoutSessionId=${serviceSessionparams.checkoutSessionId}`
-  );
-  return sessionData;
-});
-
-// src/account.ts
-import {
-  toCallPolicy as toCallPolicy2,
-  CallPolicyVersion,
-  ParamCondition
-} from "@zerodev/permissions/policies";
-var ActaAccount = class {
-  constructor(chainId, publicClient, signer) {
-    this.chainId = chainId;
-    this.signer = signer;
-    this.publicClient = publicClient;
+    });
   }
-  createAccount() {
+  signRecurringPayments(recurringPaymentParams) {
     return __async(this, null, function* () {
+      if (!this.signer) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver,
+        feeInclusive,
+        count,
+        intervalUnit,
+        startDate,
+        endDate,
+        allowMaxTokenApproval
+      } = recurringPaymentParams;
+      if (amount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (!signerAddress) {
+        throw new Error("Signer Connot be empty");
+      }
+      if (receiver === signerAddress) {
+        throw new Error("Receiver cannot be the same as the signer.");
+      }
+      if (!intervalUnit) {
+        throw new Error("Interval unit is required.");
+      }
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not found.");
+      }
       const kernelVersion = KERNEL_V3_1;
       const entryPoint = getEntryPoint("0.7");
-      const ecdsaValidator = yield signerToEcdsaValidator(this.publicClient, {
-        signer: this.signer,
-        entryPoint,
-        kernelVersion
-      });
-      const account = yield createKernelAccount2(this.publicClient, {
-        plugins: {
-          sudo: ecdsaValidator
-        },
-        entryPoint,
-        kernelVersion
-      });
-      return account;
-    });
-  }
-  createAccountHelpers() {
-    return __async(this, null, function* () {
+      const paymentCount = count != null ? count : 24;
       const account = yield this.createAccount();
-      const entryPoint = getEntryPoint("0.7");
-      const paymasterClient = createPaymasterClient({
-        transport: http2(getPimlicoRpcByChainId(this.chainId))
-      });
-      const pimlicoClient = createPimlicoClient({
-        chain: getChainById(this.chainId),
-        transport: http2(getPimlicoRpcByChainId(this.chainId)),
-        entryPoint
-      });
-      const accountClient = createSmartAccountClient({
-        account,
-        chain: getChainById(this.chainId),
-        paymaster: paymasterClient,
-        bundlerTransport: http2(getPimlicoRpcByChainId(this.chainId)),
-        userOperation: {
-          estimateFeesPerGas: () => __async(this, null, function* () {
-            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
-          })
+      const smartAccountAddress = account.address;
+      const viemClient = new ViemClient(this.chainId, this.signer);
+      const { paymasterClient, pimlicoClient } = yield this.createAccountHelpers();
+      const ecdsaValidator = yield signerToEcdsaValidator(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          signer: this.signer
         }
-      });
-      return { paymasterClient, pimlicoClient, accountClient };
-    });
-  }
-  estimateSinglePaymentGas(parameters) {
-    return __async(this, null, function* () {
+      );
+      const sessionKeyAddress = "0xFDEed8e268D74DF71f3Db7409F8A8290FF1263ED";
+      const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+      const emptySessionKeySigner = yield toECDSASigner({ signer: emptyAccount });
       const {
+        paymaster,
+        ActalinkFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        estimatedTotalFeesInToken,
+        userOperation,
+        estimatedGasCostInToken
+      } = yield this.estimateSinglePaymentGas({
         signerAddress,
         chainId,
         token: tokenSymbol,
         amount,
-        receiver
-      } = parameters;
-      if (amount <= BigInt(0)) {
-        throw new Error("Amount must be greater than 0.");
-      }
-      if (receiver === signerAddress) {
-        throw new Error("Receiver cannot be the same as the signer.");
-      }
-      const account = yield this.createAccount();
-      const { accountClient, pimlicoClient } = yield this.createAccountHelpers();
-      const fromAddress = signerAddress;
-      const smartAccountAddress = account.address;
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) {
-        throw new Error("Token not found.");
-      }
-      const quotes = yield pimlicoClient.getTokenQuotes({
-        tokens: [token2.address],
-        chain: getChainById(chainId)
+        receiver,
+        feeInclusive
       });
-      const { postOpGas, exchangeRate, paymaster } = quotes[0];
-      const userOperation = yield accountClient.prepareUserOperation({
-        calls: [
+      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+      const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
+      yield viemClient.checkAndApproveToken(
+        token2,
+        smartAccountAddress,
+        amountToTransfer * BigInt(paymentCount) + estimatedGasCostInToken * BigInt(2) * BigInt(paymentCount),
+        allowMaxTokenApproval != null ? allowMaxTokenApproval : false
+      );
+      const amountExclusive = amountToTransfer + amountToTransfer / BigInt(2);
+      const callPolicy = toCallPolicy({
+        policyVersion: CallPolicyVersion.V0_0_4,
+        permissions: [
           {
-            to: getAddress2(token2.address),
+            target: token2.address,
+            valueLimit: BigInt(0),
             abi: parseAbi2(["function transferFrom(address,address,uint)"]),
             functionName: "transferFrom",
             args: [
-              fromAddress,
-              "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
-              BigInt(0)
+              {
+                condition: ParamCondition.EQUAL,
+                value: getAddress2(signerAddress)
+              },
+              {
+                condition: ParamCondition.ONE_OF,
+                value: [
+                  "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+                  getAddress2(receiver)
+                ]
+              },
+              {
+                condition: ParamCondition.LESS_THAN_OR_EQUAL,
+                value: amountExclusive
+              }
             ]
-          },
+          }
+        ]
+      });
+      const permissionPlugin = yield toPermissionValidator(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          signer: emptySessionKeySigner,
+          policies: [callPolicy]
+        }
+      );
+      const serializedSessionKeyAccount = yield createKernelAccount(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin
+          }
+        }
+      );
+      const approval = yield serializePermissionAccount(
+        serializedSessionKeyAccount
+      );
+      return { approval, amountExclusive };
+    });
+  }
+  signRecurringTransactionCancellation(paymentCancellationParams) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this.signer) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      const { signerAddress, token: token2, amountExclusive, receiverAddress } = paymentCancellationParams;
+      const address = yield (_a = this.signer.account) == null ? void 0 : _a.address;
+      if (!address) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      if (address !== getAddress2(signerAddress)) {
+        throw new Error("Connected Wallet is not the owner of transaction.");
+      }
+      if (amountExclusive <= BigInt(0)) {
+        throw new Error("Amount Exclusive must be greater than 0.");
+      }
+      const kernelVersion = KERNEL_V3_1;
+      const entryPoint = getEntryPoint("0.7");
+      const viemClient = new ViemClient(this.chainId, this.signer);
+      const account = yield this.createAccount();
+      const { kernelAccountClient, accountClient } = yield this.createAccountHelpers();
+      const sessionKeyAddress = "0xFDEed8e268D74DF71f3Db7409F8A8290FF1263ED";
+      const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+      const emptySessionKeySigner = yield toECDSASigner({ signer: emptyAccount });
+      const callPolicy = toCallPolicy({
+        policyVersion: CallPolicyVersion.V0_0_4,
+        permissions: [
           {
-            to: getAddress2(token2.address),
+            target: getAddress2(token2),
+            valueLimit: BigInt(0),
             abi: parseAbi2(["function transferFrom(address,address,uint)"]),
             functionName: "transferFrom",
-            args: [fromAddress, receiver, BigInt(0)]
+            args: [
+              {
+                condition: ParamCondition.EQUAL,
+                value: getAddress2(signerAddress)
+              },
+              {
+                condition: ParamCondition.ONE_OF,
+                value: [
+                  "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+                  getAddress2(receiverAddress)
+                ]
+              },
+              {
+                condition: ParamCondition.LESS_THAN_OR_EQUAL,
+                value: amountExclusive
+              }
+            ]
           }
         ]
       });
-      const userOperationMaxGas = userOperation.preVerificationGas + userOperation.callGasLimit + userOperation.verificationGasLimit + (userOperation.paymasterPostOpGasLimit || BigInt(0)) + (userOperation.paymasterVerificationGasLimit || BigInt(0));
-      const userOperationMaxCost = BigInt(
-        userOperationMaxGas * userOperation.maxFeePerGas
+      const permissionPlugin = yield toPermissionValidator(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          signer: emptySessionKeySigner,
+          policies: [callPolicy]
+        }
       );
-      const estimatedGasCostInToken = (userOperationMaxCost + postOpGas * userOperation.maxFeePerGas) * exchangeRate / BigInt(1e18);
-      const ActalinkFeesInToken = amount * BigInt(20) / BigInt(1e4);
-      const estimatedTotalFeesInToken = estimatedGasCostInToken + ActalinkFeesInToken;
-      const feeInclusiveAmountInToken = amount - estimatedTotalFeesInToken;
-      const feeExclusiveAmountInToken = amount + estimatedTotalFeesInToken;
-      return {
-        estimatedGasCostInToken,
-        ActalinkFeesInToken,
-        estimatedTotalFeesInToken,
-        feeInclusiveAmountInToken,
-        feeExclusiveAmountInToken,
-        paymaster,
-        userOperation
+      const validatorId = concatHex([
+        VALIDATOR_TYPE[permissionPlugin.validatorType],
+        pad(permissionPlugin.getIdentifier(), {
+          size: 20,
+          dir: "right"
+        })
+      ]);
+      const parsedAccount = parseAccount(account);
+      const validatorData = yield permissionPlugin.getEnableData(
+        parsedAccount.address
+      );
+      const userOperation = yield accountClient.prepareUserOperation({
+        calls: [
+          {
+            to: parsedAccount.address,
+            data: encodeFunctionData2({
+              abi: KernelV3AccountAbi,
+              functionName: "uninstallValidation",
+              args: [validatorId, validatorData, "0x"]
+            }),
+            value: BigInt(0)
+          }
+        ]
+      });
+      const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
+        chainId: this.chainId
+      }));
+      const rpcParameters = formatUserOperationRequest(__spreadProps(__spreadValues({}, userOperation), {
+        signature
+      }));
+      return rpcParameters;
+    });
+  }
+};
+
+// src/api.ts
+import { toHex } from "viem";
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["Get"] = "get";
+  HttpMethod2["Post"] = "post";
+  HttpMethod2["Delete"] = "delete";
+  HttpMethod2["Update"] = "update";
+  return HttpMethod2;
+})(HttpMethod || {});
+function sendRequest(_0) {
+  return __async(this, arguments, function* ({
+    url,
+    method,
+    body,
+    headers = {}
+  }) {
+    var _a;
+    const response = yield fetch(url, {
+      method,
+      headers: __spreadProps(__spreadValues({}, headers), {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(body)
+    });
+    let jsonResponse;
+    const res = yield response.json();
+    if (!response.ok) {
+      jsonResponse = {
+        error: {
+          code: response.status,
+          message: response.statusText
+        },
+        data: void 0
+      };
+      return jsonResponse;
+    }
+    if (!res) {
+      jsonResponse = {
+        error: {
+          code: 400,
+          message: "No response received."
+        },
+        data: void 0
+      };
+      return jsonResponse;
+    }
+    if (res == null ? void 0 : res.error) {
+      jsonResponse = {
+        error: {
+          code: response.status,
+          message: res.error
+        },
+        data: void 0
       };
+      return jsonResponse;
+    }
+    jsonResponse = {
+      data: res.data,
+      message: (_a = res.message) != null ? _a : "Success",
+      error: void 0
+    };
+    return jsonResponse;
+  });
+}
+function createSessionAPICall(url, sessionBodyParams) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: sessionBodyParams
+    });
+    return response.data;
+  });
+}
+function verifySessionAPICall(url, sessionId) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "get" /* Get */
+    });
+    return response.data;
+  });
+}
+function scheduleRecurringPaymentsAPICall(url, params) {
+  return __async(this, null, function* () {
+    const parsedParams = __spreadProps(__spreadValues({}, params), {
+      amount: toHex(params.amount),
+      amountExclusive: toHex(params.amountExclusive)
+    });
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: parsedParams
+    });
+    return response.data;
+  });
+}
+function createBillingSessionAPICall(url, sessionBodyParams) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: sessionBodyParams
+    });
+    return response.data;
+  });
+}
+function fetchBillingSessionDetails(url) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "get" /* Get */
+    });
+    return response.data;
+  });
+}
+function executeSinglePaymentAPICall(url, userOperation, paymentParams, serviceParams) {
+  return __async(this, null, function* () {
+    const params = {
+      userOperation,
+      paymentParams,
+      serviceParams
+    };
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: params
+    });
+    return response.data;
+  });
+}
+function fetchRecurringTransactionWithId(url) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({ url, method: "get" /* Get */ });
+    return response.data;
+  });
+}
+function cancelRecurringPaymentAPICall(url, userOperation, paymentParams, serviceParams) {
+  return __async(this, null, function* () {
+    const params = {
+      userOperation,
+      paymentParams,
+      serviceParams
+    };
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: params
     });
+    return response.data;
+  });
+}
+
+// src/deposit.ts
+var transactionServiceUrl = "https://api.acta.link/transaction/v1/";
+var depositServiceUrl = "https://api.acta.link/deposit/v1/";
+var ActaDeposit = class {
+  constructor(parameters) {
+    this.count = 0;
+    this.intervalUnit = void 0;
+    this.startDate = void 0;
+    this.endDate = void 0;
+    this.serviceSessionParams = void 0;
+    this.depositSessionId = "";
+    this.status = "not_started";
+    this.serviceType = "deposit";
+    this.allowMaxTokenApproval = false;
+    var _a, _b;
+    this.connectorType = parameters.connectorType;
+    this.walletClient = parameters.walletClient;
+    this.signerAddress = parameters.signerAddress;
+    this.chainId = parameters.chainId;
+    this.token = parameters.token;
+    this.amount = parameters.amount;
+    this.receiver = parameters.receiver;
+    this.feeInclusive = parameters.feeInclusive;
+    this.paymentType = parameters.paymentType;
+    this.count = parameters.count;
+    this.intervalUnit = parameters.intervalUnit;
+    this.startDate = parameters.startDate;
+    this.endDate = parameters.endDate;
+    this.depositSessionId = (_a = parameters.depositSessionId) != null ? _a : "";
+    this.allowMaxTokenApproval = (_b = parameters.allowMaxTokenApproval) != null ? _b : false;
+    this.viemClient = new ViemClient(this.chainId, this.walletClient);
+    this.account = new ActaAccount(
+      this.chainId,
+      this.viemClient.publicClient(),
+      this.walletClient
+    );
   }
-  signSinglePaymentOperation(singlePaymentParams) {
+  createSession(serviceSessionparams) {
     return __async(this, null, function* () {
       try {
-        if (!this.signer) {
-          throw new Error("Signer is required for self custody payments.");
+        if (!this.signerAddress || this.signerAddress === zeroAddress3) {
+          throw new Error("Signer address is required.");
         }
-        const {
-          signerAddress,
-          chainId,
-          token: tokenSymbol,
-          amount,
-          receiver,
-          feeInclusive,
-          allowMaxTokenApproval
-        } = singlePaymentParams;
-        if (amount <= BigInt(0)) {
-          throw new Error("Amount must be greater than 0.");
+        if (this.paymentType !== "single" && this.paymentType !== "choose" && this.paymentType !== "recurring") {
+          throw new Error("Invalid payment type.");
         }
-        if (receiver === signerAddress) {
-          throw new Error("Receiver cannot be the same as the signer.");
+        if (!this.receiver || this.receiver === zeroAddress3) {
+          throw new Error("Receiver is required.");
         }
-        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (this.paymentType === "recurring" && (this.count === void 0 || this.count === 0)) {
+          throw new Error("Count is required for recurring payments.");
+        }
+        if (this.paymentType === "recurring" && this.intervalUnit === void 0) {
+          throw new Error("Interval unit is required for recurring payments.");
+        }
+        if (this.depositSessionId !== "") {
+          const session2 = yield verifySessionAPICall(
+            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+            this.depositSessionId
+          );
+          this.depositSessionId = session2.sessionId;
+          return session2.sessionId;
+        }
+        const token2 = getTokenByChainIdAndSymbol(this.chainId, this.token);
         if (!token2) {
-          throw new Error("Token not found.");
+          throw new Error("Token not supported.");
+        }
+        const session = yield createSessionAPICall(
+          `${depositServiceUrl}session`,
+          {
+            paymentParams: {
+              signerAddress: this.signerAddress,
+              chainId: this.chainId,
+              token: token2.address,
+              amount: toHex2(this.amount),
+              receiver: this.receiver,
+              feeInclusive: this.feeInclusive,
+              serviceType: "deposit",
+              paymentType: this.paymentType,
+              count: this.count,
+              intervalUnit: this.intervalUnit,
+              startDate: this.startDate,
+              endDate: this.endDate
+            },
+            serviceSessionParams: serviceSessionparams
+          }
+        );
+        this.depositSessionId = session.sessionId;
+        this.status = "session_created";
+        const sessionId = session.sessionId;
+        return sessionId;
+      } catch (error) {
+        this.status = "session_fetch_failed";
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create deposit session.");
+      }
+    });
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      try {
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
         }
-        const viemClient = new ViemClient(this.chainId, this.signer);
         const {
           estimatedGasCostInToken,
           ActalinkFeesInToken,
           feeInclusiveAmountInToken,
           feeExclusiveAmountInToken,
           estimatedTotalFeesInToken,
-          paymaster
-        } = yield this.estimateSinglePaymentGas({
-          signerAddress,
-          chainId,
-          token: tokenSymbol,
-          amount,
-          receiver,
-          feeInclusive
-        });
-        const account = yield this.createAccount();
-        const { accountClient } = yield this.createAccountHelpers();
-        const fromAddress = signerAddress;
-        const smartAccountAddress = account.address;
-        const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
-        const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
-        yield viemClient.checkAndApproveToken(
-          token2,
-          smartAccountAddress,
-          amountToTransfer,
-          allowMaxTokenApproval != null ? allowMaxTokenApproval : false
-        );
-        const userOperation = yield accountClient.prepareUserOperation({
-          calls: [
-            {
-              to: getAddress2(token2.address),
-              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
-              functionName: "transferFrom",
-              args: [
-                fromAddress,
-                "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
-                estimatedGasCostInToken
-              ]
-            },
-            {
-              to: getAddress2(token2.address),
-              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
-              functionName: "transferFrom",
-              args: [fromAddress, receiver, receiverAmount]
-            }
-          ]
+          paymaster,
+          userOperation
+        } = yield this.account.estimateSinglePaymentGas(parameters);
+        return {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to estimate single payment gas.");
+      }
+    });
+  }
+  createPayment(servicePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (this.paymentType === "single") {
+          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
+            depositSessionId: this.depositSessionId
+          }) : servicePaymentParams;
+          const id = yield this.createSinglePayment(paymentParams);
+          return id;
+        }
+        if (this.paymentType === "choose") {
+        }
+        if (this.paymentType === "recurring") {
+          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
+            depositSessionId: this.depositSessionId
+          }) : servicePaymentParams;
+          const id = yield this.createRecurringPayments(paymentParams);
+          return id;
+        }
+      } catch (error) {
+        this.status = "payment_failed";
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create payment.");
+      }
+    });
+  }
+  createSinglePayment(servicePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
+        }
+        if (!this.depositSessionId || this.depositSessionId === "") {
+          throw new Error("Deposit session ID is required.");
+        }
+        if (this.depositSessionId !== "") {
+          const session = yield verifySessionAPICall(
+            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+            this.depositSessionId
+          );
+          this.depositSessionId = session.sessionId;
+        }
+        const signerAddress = this.signerAddress;
+        const chainId = this.chainId;
+        const tokenSymbol = this.token;
+        const amount = this.amount;
+        const receiver = this.receiver;
+        const feeInclusive = this.feeInclusive;
+        const serviceType = this.serviceType;
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!token2) {
+          throw new Error("Token not supported.");
+        }
+        const rpcParameters = yield this.account.signSinglePaymentOperation({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive,
+          allowMaxTokenApproval: this.allowMaxTokenApproval
         });
-        const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
-          chainId: this.chainId
-        }));
-        const rpcParameters = formatUserOperationRequest(__spreadProps(__spreadValues({}, userOperation), {
-          signature
-        }));
-        return rpcParameters;
+        const txn = yield executeSinglePaymentAPICall(
+          `${transactionServiceUrl}execute/single`,
+          rpcParameters,
+          {
+            senderAddress: signerAddress,
+            receiverAddress: receiver,
+            chainId,
+            tokenAddress: token2.address,
+            amount: toHex2(amount),
+            feeInclusive,
+            serviceType
+          },
+          servicePaymentParams
+        );
+        return txn.transaction.id;
       } catch (error) {
         if (error instanceof Error) {
           throw new Error(error.message);
         }
-        throw new Error("Failed to sign single payment operation.");
+        throw new Error("Failed to create payment.");
       }
     });
   }
-  signRecurringPayments(recurringPaymentParams) {
+  // private async pollPayment(interval: number) {
+  //   const intervalId = setInterval(async () => {
+  //     const result = await fetch(
+  //       `${this.serviceUrl}/v1/${this.serviceType}/status?id=${this.depositSessionId}`,
+  //       {
+  //         method: "GET",
+  //         headers: {
+  //           "Content-Type": "application/json",
+  //         },
+  //       }
+  //     );
+  //     const res = await result.json();
+  //     const status = res.data.status;
+  //     if (status === "success" || status === "failed") {
+  //       this.status =
+  //         status === "success" ? "payment_completed" : "payment_failed";
+  //       clearInterval(intervalId);
+  //     }
+  //   }, interval);
+  //   return () => clearInterval(intervalId);
+  // }
+  createRecurringPayments(servicePaymentParams) {
     return __async(this, null, function* () {
-      if (!this.signer) {
+      if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+        throw new Error("Only self custody payments are supported.");
+      }
+      if (!this.depositSessionId || this.depositSessionId === "") {
+        throw new Error("Deposit session ID is required.");
+      }
+      if (!this.walletClient) {
         throw new Error("Signer is required for self custody payments.");
       }
-      const {
+      if (this.depositSessionId !== "") {
+        const session = yield verifySessionAPICall(
+          `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+          this.depositSessionId
+        );
+        this.depositSessionId = session.sessionId;
+      }
+      const signerAddress = this.signerAddress;
+      const chainId = this.chainId;
+      const tokenSymbol = this.token;
+      const amount = this.amount;
+      const receiver = this.receiver;
+      const feeInclusive = this.feeInclusive;
+      const count = this.count;
+      const intervalUnit = this.intervalUnit;
+      const startDate = this.startDate;
+      const endDate = this.endDate;
+      const serviceType = this.serviceType;
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not supported.");
+      }
+      if (!chainId || !count || !intervalUnit || !startDate || !endDate) {
+        throw new Error("Invalid parameters.");
+      }
+      const { approval, amountExclusive } = yield this.account.signRecurringPayments({
         signerAddress,
         chainId,
         token: tokenSymbol,
         amount,
-        receiver,
         feeInclusive,
         count,
         intervalUnit,
         startDate,
         endDate,
-        allowMaxTokenApproval
-      } = recurringPaymentParams;
-      if (amount <= BigInt(0)) {
-        throw new Error("Amount must be greater than 0.");
-      }
-      if (receiver === signerAddress) {
-        throw new Error("Receiver cannot be the same as the signer.");
-      }
-      if (!intervalUnit) {
-        throw new Error("Interval unit is required.");
-      }
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) {
-        throw new Error("Token not found.");
-      }
-      const kernelVersion = KERNEL_V3_1;
-      const entryPoint = getEntryPoint("0.7");
-      const paymentCount = count != null ? count : 24;
-      const account = yield this.createAccount();
-      const smartAccountAddress = account.address;
-      const viemClient = new ViemClient(this.chainId, this.signer);
-      const { paymasterClient, pimlicoClient } = yield this.createAccountHelpers();
-      const ecdsaValidator = yield signerToEcdsaValidator(
-        viemClient.publicClient(),
+        receiver,
+        allowMaxTokenApproval: this.allowMaxTokenApproval
+      });
+      const txn = yield scheduleRecurringPaymentsAPICall(
+        `${transactionServiceUrl}schedule/recurring`,
         {
-          entryPoint,
-          kernelVersion,
-          signer: this.signer
+          amount,
+          amountExclusive,
+          chainId,
+          feeInclusive,
+          intervalCount: count,
+          intervalUnit,
+          senderAddress: signerAddress,
+          receiverAddress: receiver,
+          tokenAddress: token2.address,
+          startAt: startDate,
+          endAt: endDate,
+          approval,
+          serviceParams: servicePaymentParams,
+          serviceType
         }
       );
-      const sessionKeyAddress = "0xFDEed8e268D74DF71f3Db7409F8A8290FF1263ED";
-      const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
-      const emptySessionKeySigner = yield toECDSASigner(emptyAccount);
-      const {
-        paymaster,
-        ActalinkFeesInToken,
-        feeInclusiveAmountInToken,
-        feeExclusiveAmountInToken,
-        estimatedTotalFeesInToken,
-        userOperation,
-        estimatedGasCostInToken
-      } = yield this.estimateSinglePaymentGas({
-        signerAddress,
+      return txn.recurringTransaction.id;
+    });
+  }
+  getPaymentSteps() {
+    return __async(this, null, function* () {
+      const signerAddress = this.signerAddress;
+      const chainId = this.chainId;
+      const tokenSymbol = this.token;
+      const amount = this.amount;
+      const receiver = this.receiver;
+      const feeInclusive = this.feeInclusive;
+      const count = this.count;
+      if (!signerAddress) return ["allowance", "confirm"];
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) return ["allowance", "confirm"];
+      const smartAccount = yield this.account.createAccount();
+      const { estimatedGasCostInToken, feeExclusiveAmountInToken } = yield this.account.estimateSinglePaymentGas({
         chainId,
-        token: tokenSymbol,
         amount,
+        feeInclusive,
         receiver,
-        feeInclusive
+        signerAddress,
+        token: tokenSymbol
       });
       const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
-      const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
-      yield viemClient.checkAndApproveToken(
+      let paymentAmount = (amountToTransfer + estimatedGasCostInToken * BigInt(2)) * BigInt(count != null ? count : 1);
+      const allowance = yield this.viemClient.checkTokenAllowance(
         token2,
-        smartAccountAddress,
-        amountToTransfer * BigInt(paymentCount) + estimatedGasCostInToken * BigInt(2) * BigInt(paymentCount),
-        allowMaxTokenApproval != null ? allowMaxTokenApproval : false
-      );
-      const callPolicy = toCallPolicy2({
-        policyVersion: CallPolicyVersion.V0_0_4,
-        permissions: [
-          {
-            target: token2.address,
-            valueLimit: BigInt(0),
-            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
-            functionName: "transferFrom",
-            args: [
-              {
-                condition: ParamCondition.EQUAL,
-                value: signerAddress
-              },
-              {
-                condition: ParamCondition.ONE_OF,
-                value: ["0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0", receiver]
-              },
-              {
-                condition: ParamCondition.LESS_THAN_OR_EQUAL,
-                value: amountToTransfer + amountToTransfer / BigInt(2)
-              }
-            ]
-          }
-        ]
-      });
-      const permissionPlugin = yield toPermissionValidator(
-        viemClient.publicClient(),
-        {
-          entryPoint,
-          kernelVersion,
-          signer: emptySessionKeySigner,
-          policies: [callPolicy]
-        }
-      );
-      const serializedSessionKeyAccount = yield createKernelAccount2(
-        viemClient.publicClient(),
-        {
-          entryPoint,
-          kernelVersion,
-          plugins: {
-            sudo: ecdsaValidator,
-            regular: permissionPlugin
-          }
-        }
-      );
-      const approval = yield serializePermissionAccount(
-        serializedSessionKeyAccount
+        signerAddress,
+        smartAccount.address
       );
-      return approval;
+      if (paymentAmount <= allowance) return ["confirm"];
+      return ["allowance", "confirm"];
     });
   }
 };
 
-// src/deposit.ts
-var transactionServiceUrl = "https://api.acta.link/transaction/v1/";
-var depositServiceUrl = "https://api.acta.link/deposit/v1/";
-var ActaDeposit = class {
+// src/billing.ts
+import { toHex as toHex3 } from "viem";
+var transactionServiceUrl2 = "http://localhost:8000/transaction/v1/";
+var ActaBilling = class {
   constructor(parameters) {
     this.count = 0;
     this.intervalUnit = void 0;
     this.startDate = void 0;
     this.endDate = void 0;
     this.serviceSessionParams = void 0;
-    this.depositSessionId = "";
     this.status = "not_started";
     this.serviceType = "deposit";
     this.allowMaxTokenApproval = false;
-    var _a, _b;
+    var _a;
     this.connectorType = parameters.connectorType;
     this.walletClient = parameters.walletClient;
     this.signerAddress = parameters.signerAddress;
@@ -1579,8 +1649,8 @@ var ActaDeposit = class {
     this.intervalUnit = parameters.intervalUnit;
     this.startDate = parameters.startDate;
     this.endDate = parameters.endDate;
-    this.depositSessionId = (_a = parameters.depositSessionId) != null ? _a : "";
-    this.allowMaxTokenApproval = (_b = parameters.allowMaxTokenApproval) != null ? _b : false;
+    this.allowMaxTokenApproval = (_a = parameters.allowMaxTokenApproval) != null ? _a : false;
+    this.serviceType = parameters.serviceType;
     this.viemClient = new ViemClient(this.chainId, this.walletClient);
     this.account = new ActaAccount(
       this.chainId,
@@ -1588,529 +1658,639 @@ var ActaDeposit = class {
       this.walletClient
     );
   }
-  createSession(serviceSessionparams) {
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      try {
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
+        }
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        } = yield this.account.estimateSinglePaymentGas(parameters);
+        return {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to estimate single payment gas.");
+      }
+    });
+  }
+  createSinglePayment(servicePaymentParams) {
     return __async(this, null, function* () {
       try {
-        if (!this.signerAddress || this.signerAddress === zeroAddress4) {
-          throw new Error("Signer address is required.");
-        }
-        if (this.paymentType !== "single" && this.paymentType !== "choose" && this.paymentType !== "recurring") {
-          throw new Error("Invalid payment type.");
-        }
-        if (!this.receiver || this.receiver === zeroAddress4) {
-          throw new Error("Receiver is required.");
-        }
-        if (this.paymentType === "recurring" && (this.count === void 0 || this.count === 0)) {
-          throw new Error("Count is required for recurring payments.");
-        }
-        if (this.paymentType === "recurring" && this.intervalUnit === void 0) {
-          throw new Error("Interval unit is required for recurring payments.");
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
         }
-        if (this.depositSessionId !== "") {
-          const session2 = yield verifySessionAPICall(
-            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
-            this.depositSessionId
-          );
-          this.depositSessionId = session2.sessionId;
-          return session2.sessionId;
+        if (!servicePaymentParams.checkoutSessionId || servicePaymentParams.checkoutSessionId === "") {
+          throw new Error("checkout session ID is required.");
         }
-        const token2 = getTokenByChainIdAndSymbol(this.chainId, this.token);
+        const signerAddress = this.signerAddress;
+        const chainId = this.chainId;
+        const tokenSymbol = this.token;
+        const amount = this.amount;
+        const receiver = this.receiver;
+        const feeInclusive = this.feeInclusive;
+        const serviceType = this.serviceType;
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
         if (!token2) {
           throw new Error("Token not supported.");
         }
-        const session = yield createSessionAPICall(
-          `${depositServiceUrl}session`,
+        const rpcParameters = yield this.account.signSinglePaymentOperation({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive,
+          allowMaxTokenApproval: this.allowMaxTokenApproval
+        });
+        const txn = yield executeSinglePaymentAPICall(
+          `${transactionServiceUrl2}execute/single`,
+          rpcParameters,
           {
-            paymentParams: {
-              signerAddress: this.signerAddress,
-              chainId: this.chainId,
-              token: token2.address,
-              amount: toHex2(this.amount),
-              receiver: this.receiver,
-              feeInclusive: this.feeInclusive,
-              serviceType: "deposit",
-              paymentType: this.paymentType,
-              count: this.count,
-              intervalUnit: this.intervalUnit,
-              startDate: this.startDate,
-              endDate: this.endDate
-            },
-            serviceSessionParams: serviceSessionparams
-          }
+            senderAddress: signerAddress,
+            receiverAddress: receiver,
+            chainId,
+            tokenAddress: token2.address,
+            amount: toHex3(amount),
+            feeInclusive,
+            serviceType
+          },
+          servicePaymentParams
         );
-        this.depositSessionId = session.sessionId;
-        this.status = "session_created";
-        const sessionId = session.sessionId;
-        return sessionId;
+        return txn.transaction.id;
       } catch (error) {
-        this.status = "session_fetch_failed";
         if (error instanceof Error) {
           throw new Error(error.message);
         }
-        throw new Error("Failed to create deposit session.");
+        throw new Error("Failed to create payment.");
+      }
+    });
+  }
+  createRecurringPayments(servicePaymentParams) {
+    return __async(this, null, function* () {
+      if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+        throw new Error("Only self custody payments are supported.");
+      }
+      if (!servicePaymentParams.checkoutSessionId || servicePaymentParams.checkoutSessionId === "") {
+        throw new Error("checkout session ID is required.");
+      }
+      if (!this.walletClient) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      const signerAddress = this.signerAddress;
+      const chainId = this.chainId;
+      const tokenSymbol = this.token;
+      const amount = this.amount;
+      const receiver = this.receiver;
+      const feeInclusive = this.feeInclusive;
+      const count = this.count;
+      const intervalUnit = this.intervalUnit;
+      const startDate = this.startDate;
+      const endDate = this.endDate;
+      const serviceType = this.serviceType;
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not supported.");
+      }
+      if (!chainId || !count || !intervalUnit || !startDate || !endDate) {
+        throw new Error("Invalid parameters.");
+      }
+      const { approval, amountExclusive } = yield this.account.signRecurringPayments({
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        feeInclusive,
+        count,
+        intervalUnit,
+        startDate,
+        endDate,
+        receiver,
+        allowMaxTokenApproval: this.allowMaxTokenApproval
+      });
+      const txn = yield scheduleRecurringPaymentsAPICall(
+        `${transactionServiceUrl2}schedule/recurring`,
+        {
+          amount,
+          amountExclusive,
+          chainId,
+          feeInclusive,
+          intervalCount: count,
+          intervalUnit,
+          senderAddress: signerAddress,
+          receiverAddress: receiver,
+          tokenAddress: token2.address,
+          startAt: startDate,
+          endAt: endDate,
+          approval,
+          serviceParams: servicePaymentParams,
+          serviceType
+        }
+      );
+      return txn.recurringTransaction.id;
+    });
+  }
+  getPaymentSteps() {
+    return __async(this, null, function* () {
+      const signerAddress = this.signerAddress;
+      const chainId = this.chainId;
+      const tokenSymbol = this.token;
+      const amount = this.amount;
+      const receiver = this.receiver;
+      const feeInclusive = this.feeInclusive;
+      const count = this.count;
+      if (!signerAddress) return ["allowance", "confirm"];
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) return ["allowance", "confirm"];
+      const smartAccount = yield this.account.createAccount();
+      const { estimatedGasCostInToken, feeExclusiveAmountInToken } = yield this.account.estimateSinglePaymentGas({
+        chainId,
+        amount,
+        feeInclusive,
+        receiver,
+        signerAddress,
+        token: tokenSymbol
+      });
+      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+      let paymentAmount = (amountToTransfer + estimatedGasCostInToken * BigInt(2)) * BigInt(count != null ? count : 1);
+      const allowance = yield this.viemClient.checkTokenAllowance(
+        token2,
+        signerAddress,
+        smartAccount.address
+      );
+      if (paymentAmount <= allowance) return ["confirm"];
+      return ["allowance", "confirm"];
+    });
+  }
+};
+
+// src/utils.ts
+import {
+  constants,
+  fixSignedData,
+  toSigner,
+  KernelV3AccountAbi as KernelV3AccountAbi2,
+  KernelFactoryStakerAbi,
+  KernelV3FactoryAbi,
+  KernelV3_1AccountAbi,
+  createKernelAccount as createKernelAccount2
+} from "@zerodev/sdk";
+import {
+  toKernelPluginManager
+} from "@zerodev/sdk/accounts";
+import {
+  concat,
+  encodeAbiParameters,
+  keccak256,
+  slice,
+  zeroAddress as zeroAddress5,
+  decodeFunctionData,
+  hexToBigInt as hexToBigInt2
+} from "viem";
+import {
+  toAccount,
+  privateKeyToAccount
+} from "viem/accounts";
+import { getChainId, readContract } from "viem/actions";
+import { getAction } from "viem/utils";
+import {
+  getUserOperationHash
+} from "viem/account-abstraction";
+import {
+  toCallPolicy as toCallPolicy2,
+  toGasPolicy,
+  toRateLimitPolicy,
+  toSignatureCallerPolicy,
+  toSudoPolicy,
+  toTimestampPolicy
+} from "@zerodev/permissions/policies";
+import { coerce, gt } from "semver";
+var ECDSA_SIGNER_CONTRACT = "0x6A6F069E2a08c2468e7724Ab3250CdBFBA14D4FF";
+var billingServiceUrl = "http://localhost:4000/billing/v1/";
+var depositServiceUrl2 = "http://localhost:4000/deposit/v1/";
+var transactionServiceUrl3 = "http://localhost:8000/transaction/v1/";
+var toSignerId = (signer) => {
+  return encodeAbiParameters(
+    [{ name: "signerData", type: "bytes" }],
+    [concat([signer.signerContractAddress, signer.getSignerData()])]
+  );
+};
+function toECDSASigner2(_0) {
+  return __async(this, arguments, function* (signer, signerContractAddress = ECDSA_SIGNER_CONTRACT) {
+    const viemSigner = yield toSigner({ signer });
+    const account = toAccount({
+      address: viemSigner.address,
+      signMessage(_02) {
+        return __async(this, arguments, function* ({ message }) {
+          return fixSignedData(yield viemSigner.signMessage({ message }));
+        });
+      },
+      signTransaction(_, __) {
+        return __async(this, null, function* () {
+          throw new Error("Smart account signer doesn't need to sign transactions");
+        });
+      },
+      signTypedData(typedData) {
+        return __async(this, null, function* () {
+          return fixSignedData(
+            yield viemSigner.signTypedData(__spreadValues({}, typedData))
+          );
+        });
       }
     });
-  }
-  estimateSinglePaymentGas(parameters) {
-    return __async(this, null, function* () {
-      try {
-        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-          throw new Error("Only self custody payments are supported.");
-        }
-        const {
-          estimatedGasCostInToken,
-          ActalinkFeesInToken,
-          feeInclusiveAmountInToken,
-          feeExclusiveAmountInToken,
-          estimatedTotalFeesInToken,
-          paymaster,
-          userOperation
-        } = yield this.account.estimateSinglePaymentGas(parameters);
+    return {
+      account,
+      signerContractAddress,
+      getSignerData: () => {
+        return viemSigner.address;
+      },
+      getDummySignature: () => constants.DUMMY_ECDSA_SIG
+    };
+  });
+}
+var toPolicyId = (policies) => {
+  return encodeAbiParameters(
+    [{ name: "policiesData", type: "bytes[]" }],
+    [
+      policies.map(
+        (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
+      )
+    ]
+  );
+};
+function toPermissionValidator2(_0, _1) {
+  return __async(this, arguments, function* (client, {
+    signer,
+    policies,
+    entryPoint,
+    kernelVersion: _,
+    flag = "0x0000" /* FOR_ALL_VALIDATION */
+  }) {
+    const chainId = client.chain ? client.chain.id : yield getChainId(client);
+    if (entryPoint.version !== "0.7") {
+      throw new Error("Only EntryPoint 0.7 is supported");
+    }
+    const getEnableData = (_kernelAccountAddress) => __async(null, null, function* () {
+      const enableData = encodeAbiParameters(
+        [{ name: "policyAndSignerData", type: "bytes[]" }],
+        [
+          [
+            ...policies.map(
+              (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
+            ),
+            concat([flag, signer.signerContractAddress, signer.getSignerData()])
+          ]
+        ]
+      );
+      return enableData;
+    });
+    const getPermissionId = () => {
+      const pIdData = encodeAbiParameters(
+        [{ name: "policyAndSignerData", type: "bytes[]" }],
+        [[toPolicyId(policies), flag, toSignerId(signer)]]
+      );
+      return slice(keccak256(pIdData), 0, 4);
+    };
+    return __spreadProps(__spreadValues({}, signer.account), {
+      supportedKernelVersions: ">=0.3.0",
+      validatorType: "PERMISSION",
+      address: zeroAddress5,
+      source: "PermissionValidator",
+      getEnableData,
+      getIdentifier: getPermissionId,
+      signMessage: (_02) => __async(null, [_02], function* ({ message }) {
+        return concat(["0xff", yield signer.account.signMessage({ message })]);
+      }),
+      signTypedData: (typedData) => __async(null, null, function* () {
+        return concat(["0xff", yield signer.account.signTypedData(typedData)]);
+      }),
+      signUserOperation: (userOperation) => __async(null, null, function* () {
+        const userOpHash = getUserOperationHash({
+          userOperation: __spreadProps(__spreadValues({}, userOperation), {
+            signature: "0x"
+          }),
+          entryPointAddress: entryPoint.address,
+          entryPointVersion: entryPoint.version,
+          chainId
+        });
+        const signature = yield signer.account.signMessage({
+          message: { raw: userOpHash }
+        });
+        return concat(["0xff", signature]);
+      }),
+      getNonceKey(_accountAddress, customNonceKey) {
+        return __async(this, null, function* () {
+          if (customNonceKey) {
+            return customNonceKey;
+          }
+          return BigInt(0);
+        });
+      },
+      getStubSignature(_userOperation) {
+        return __async(this, null, function* () {
+          return concat(["0xff", signer.getDummySignature()]);
+        });
+      },
+      getPluginSerializationParams: () => {
         return {
-          estimatedGasCostInToken,
-          ActalinkFeesInToken,
-          feeInclusiveAmountInToken,
-          feeExclusiveAmountInToken,
-          estimatedTotalFeesInToken,
-          paymaster,
-          userOperation
+          policies
         };
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(error.message);
+      },
+      isEnabled: (kernelAccountAddress, _selector) => __async(null, null, function* () {
+        try {
+          const permissionConfig = yield getAction(
+            client,
+            readContract,
+            "readContract"
+          )({
+            abi: KernelV3AccountAbi2,
+            address: kernelAccountAddress,
+            functionName: "permissionConfig",
+            args: [getPermissionId()]
+          });
+          return permissionConfig.signer === signer.signerContractAddress;
+        } catch (error) {
+          return false;
         }
-        throw new Error("Failed to estimate single payment gas.");
-      }
+      })
     });
+  });
+}
+function bytesToBase64(bytes) {
+  const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join("");
+  return btoa(binString);
+}
+function isPermissionValidatorPlugin(plugin) {
+  return (plugin == null ? void 0 : plugin.getPluginSerializationParams) !== void 0;
+}
+var serializePermissionAccountParams = (params) => {
+  const replacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+  const jsonString = JSON.stringify(params, replacer);
+  const uint8Array = new TextEncoder().encode(jsonString);
+  const base64String = bytesToBase64(uint8Array);
+  return base64String;
+};
+var isKernelVersionAfter = (kernelVersion, version) => {
+  const coercedKernelVersion = coerce(kernelVersion);
+  if (!coercedKernelVersion) return false;
+  return gt(coercedKernelVersion, version);
+};
+function base64ToBytes(base64) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+var deserializePermissionAccountParams = (params) => {
+  const uint8Array = base64ToBytes(params);
+  const jsonString = new TextDecoder().decode(uint8Array);
+  return JSON.parse(jsonString);
+};
+var deserializePermissionAccount = (client, entryPoint, kernelVersion, modularPermissionAccountParams, modularSigner) => __async(null, null, function* () {
+  var _a;
+  if (entryPoint.version !== "0.7") {
+    throw new Error("Only EntryPoint 0.7 is supported");
   }
-  createPayment(servicePaymentParams) {
-    return __async(this, null, function* () {
-      try {
-        if (this.paymentType === "single") {
-          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
-            depositSessionId: this.depositSessionId
-          }) : servicePaymentParams;
-          const id = yield this.createSinglePayment(paymentParams);
-          return id;
-        }
-        if (this.paymentType === "choose") {
-        }
-        if (this.paymentType === "recurring") {
-          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
-            depositSessionId: this.depositSessionId
-          }) : servicePaymentParams;
-          const id = yield this.createRecurringPayments(paymentParams);
-          return id;
-        }
-      } catch (error) {
-        this.status = "payment_failed";
-        if (error instanceof Error) {
-          throw new Error(error.message);
-        }
-        throw new Error("Failed to create payment.");
-      }
-    });
+  const params = deserializePermissionAccountParams(
+    modularPermissionAccountParams
+  );
+  let signer;
+  if (params.privateKey)
+    signer = yield toECDSASigner2(privateKeyToAccount(params.privateKey));
+  else if (modularSigner) signer = modularSigner;
+  else throw new Error("No signer or serialized sessionKey provided");
+  const modularPermissionPlugin = yield toPermissionValidator2(client, {
+    signer,
+    policies: yield Promise.all(
+      ((_a = params.permissionParams.policies) == null ? void 0 : _a.map(
+        (policy) => createPolicyFromParams(policy)
+      )) || []
+    ),
+    entryPoint,
+    kernelVersion
+  });
+  const { index, validatorInitData, useMetaFactory } = decodeParamsFromInitCode(
+    params.accountParams.initCode,
+    kernelVersion
+  );
+  const kernelPluginManager = yield toKernelPluginManager(client, __spreadValues({
+    regular: modularPermissionPlugin,
+    pluginEnableSignature: params.enableSignature,
+    validatorInitData,
+    action: params.action,
+    entryPoint,
+    kernelVersion
+  }, params.validityData));
+  return createKernelAccount2(client, {
+    entryPoint,
+    kernelVersion,
+    plugins: kernelPluginManager,
+    index,
+    address: params.accountParams.accountAddress,
+    useMetaFactory,
+    eip7702Auth: params.eip7702Auth
+  });
+});
+var createPolicyFromParams = (policy) => __async(null, null, function* () {
+  switch (policy.policyParams.type) {
+    case "call":
+      return yield toCallPolicy2(policy.policyParams);
+    case "gas":
+      return yield toGasPolicy(policy.policyParams);
+    case "rate-limit":
+      return yield toRateLimitPolicy(policy.policyParams);
+    case "signature-caller":
+      return yield toSignatureCallerPolicy(policy.policyParams);
+    case "sudo":
+      return yield toSudoPolicy(policy.policyParams);
+    case "timestamp":
+      return yield toTimestampPolicy(policy.policyParams);
+    default:
+      throw new Error("Unsupported policy type");
   }
-  createSinglePayment(servicePaymentParams) {
-    return __async(this, null, function* () {
-      try {
-        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-          throw new Error("Only self custody payments are supported.");
-        }
-        if (!this.depositSessionId || this.depositSessionId === "") {
-          throw new Error("Deposit session ID is required.");
-        }
-        if (this.depositSessionId !== "") {
-          const session = yield verifySessionAPICall(
-            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
-            this.depositSessionId
-          );
-          this.depositSessionId = session.sessionId;
-        }
-        const signerAddress = this.signerAddress;
-        const chainId = this.chainId;
-        const tokenSymbol = this.token;
-        const amount = this.amount;
-        const receiver = this.receiver;
-        const feeInclusive = this.feeInclusive;
-        const serviceType = this.serviceType;
-        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-        if (!token2) {
-          throw new Error("Token not supported.");
-        }
-        const rpcParameters = yield this.account.signSinglePaymentOperation({
-          signerAddress,
-          chainId,
-          token: tokenSymbol,
-          amount,
-          receiver,
-          feeInclusive,
-          allowMaxTokenApproval: this.allowMaxTokenApproval
-        });
-        const txn = yield executeSinglePaymentAPICall(
-          `${transactionServiceUrl}execute/single`,
-          rpcParameters,
-          {
-            senderAddress: signerAddress,
-            receiverAddress: receiver,
-            chainId,
-            tokenAddress: token2.address,
-            amount: toHex2(amount),
-            feeInclusive,
-            serviceType
-          },
-          servicePaymentParams
-        );
-        return txn.transaction.id;
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(error.message);
-        }
-        throw new Error("Failed to create payment.");
-      }
-    });
+});
+var decodeParamsFromInitCode = (initCode, kernelVersion) => {
+  let index;
+  let validatorInitData;
+  let deployWithFactoryFunctionData;
+  let useMetaFactory = true;
+  if (initCode === "0x") {
+    return {
+      index: void 0,
+      validatorInitData: void 0,
+      useMetaFactory: true
+    };
   }
-  // private async pollPayment(interval: number) {
-  //   const intervalId = setInterval(async () => {
-  //     const result = await fetch(
-  //       `${this.serviceUrl}/v1/${this.serviceType}/status?id=${this.depositSessionId}`,
-  //       {
-  //         method: "GET",
-  //         headers: {
-  //           "Content-Type": "application/json",
-  //         },
-  //       }
-  //     );
-  //     const res = await result.json();
-  //     const status = res.data.status;
-  //     if (status === "success" || status === "failed") {
-  //       this.status =
-  //         status === "success" ? "payment_completed" : "payment_failed";
-  //       clearInterval(intervalId);
-  //     }
-  //   }, interval);
-  //   return () => clearInterval(intervalId);
-  // }
-  createRecurringPayments(servicePaymentParams) {
-    return __async(this, null, function* () {
-      if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-        throw new Error("Only self custody payments are supported.");
-      }
-      if (!this.depositSessionId || this.depositSessionId === "") {
-        throw new Error("Deposit session ID is required.");
-      }
-      if (!this.walletClient) {
-        throw new Error("Signer is required for self custody payments.");
-      }
-      if (this.depositSessionId !== "") {
-        const session = yield verifySessionAPICall(
-          `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
-          this.depositSessionId
-        );
-        this.depositSessionId = session.sessionId;
-      }
-      const signerAddress = this.signerAddress;
-      const chainId = this.chainId;
-      const tokenSymbol = this.token;
-      const amount = this.amount;
-      const receiver = this.receiver;
-      const feeInclusive = this.feeInclusive;
-      const count = this.count;
-      const intervalUnit = this.intervalUnit;
-      const startDate = this.startDate;
-      const endDate = this.endDate;
-      const serviceType = this.serviceType;
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) {
-        throw new Error("Token not supported.");
-      }
-      if (!chainId || !count || !intervalUnit || !startDate || !endDate) {
-        throw new Error("Invalid parameters.");
-      }
-      const approval = yield this.account.signRecurringPayments({
-        signerAddress,
-        chainId,
-        token: tokenSymbol,
-        amount,
-        feeInclusive,
-        count,
-        intervalUnit,
-        startDate,
-        endDate,
-        receiver,
-        allowMaxTokenApproval: this.allowMaxTokenApproval
-      });
-      const txn = yield scheduleRecurringPaymentsAPICall(
-        `${transactionServiceUrl}schedule/recurring`,
-        {
-          amount,
-          chainId,
-          feeInclusive,
-          intervalCount: count,
-          intervalUnit,
-          senderAddress: signerAddress,
-          receiverAddress: receiver,
-          tokenAddress: token2.address,
-          startAt: startDate,
-          endAt: endDate,
-          approval,
-          serviceParams: servicePaymentParams,
-          serviceType
-        }
-      );
-      return txn.recurringTransaction.id;
+  try {
+    deployWithFactoryFunctionData = decodeFunctionData({
+      abi: KernelFactoryStakerAbi,
+      data: initCode
+    });
+  } catch (error) {
+    deployWithFactoryFunctionData = decodeFunctionData({
+      abi: KernelV3FactoryAbi,
+      data: initCode
     });
+    useMetaFactory = false;
   }
-  getPaymentSteps() {
-    return __async(this, null, function* () {
-      const signerAddress = this.signerAddress;
-      const chainId = this.chainId;
-      const tokenSymbol = this.token;
-      const amount = this.amount;
-      const receiver = this.receiver;
-      const feeInclusive = this.feeInclusive;
-      const count = this.count;
-      if (!signerAddress) return ["allowance", "confirm"];
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) return ["allowance", "confirm"];
-      const smartAccount = yield this.account.createAccount();
-      const { estimatedGasCostInToken, feeExclusiveAmountInToken } = yield this.account.estimateSinglePaymentGas({
-        chainId,
-        amount,
-        feeInclusive,
-        receiver,
-        signerAddress,
-        token: tokenSymbol
+  if (!deployWithFactoryFunctionData) throw new Error("Invalid initCode");
+  if (deployWithFactoryFunctionData.functionName === "deployWithFactory") {
+    index = BigInt(deployWithFactoryFunctionData.args[2]);
+    let initializeFunctionData;
+    if (kernelVersion === "0.3.0") {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3AccountAbi2,
+        data: deployWithFactoryFunctionData.args[1]
       });
-      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
-      let paymentAmount = (amountToTransfer + estimatedGasCostInToken * BigInt(2)) * BigInt(count != null ? count : 1);
-      const allowance = yield this.viemClient.checkTokenAllowance(
-        token2,
-        signerAddress,
-        smartAccount.address
-      );
-      if (paymentAmount <= allowance) return ["confirm"];
-      return ["allowance", "confirm"];
-    });
+    } else {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3_1AccountAbi,
+        data: deployWithFactoryFunctionData.args[1]
+      });
+    }
+    if (!initializeFunctionData) throw new Error("Invalid initCode");
+    if (initializeFunctionData.functionName === "initialize") {
+      validatorInitData = {
+        validatorAddress: initializeFunctionData.args[0],
+        identifier: initializeFunctionData.args[0],
+        enableData: initializeFunctionData.args[2],
+        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
+      };
+    }
+  } else if (deployWithFactoryFunctionData.functionName === "createAccount") {
+    index = BigInt(deployWithFactoryFunctionData.args[1]);
+    let initializeFunctionData;
+    if (kernelVersion === "0.3.0") {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3AccountAbi2,
+        data: deployWithFactoryFunctionData.args[0]
+      });
+    } else {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3_1AccountAbi,
+        data: deployWithFactoryFunctionData.args[0]
+      });
+    }
+    if (!initializeFunctionData) throw new Error("Invalid initCode");
+    if (initializeFunctionData.functionName === "initialize") {
+      validatorInitData = {
+        validatorAddress: initializeFunctionData.args[0],
+        identifier: initializeFunctionData.args[0],
+        enableData: initializeFunctionData.args[2],
+        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
+      };
+    }
+  }
+  if (index === void 0 || validatorInitData === void 0)
+    throw new Error("Invalid initCode");
+  return { index, validatorInitData, useMetaFactory };
+};
+var getPeriodInterval = (periodUnit) => {
+  switch (periodUnit) {
+    case "5mins":
+      return 5 * 60;
+    case "day":
+      return 24 * 60 * 60;
+    case "week":
+      return 7 * 24 * 60 * 60;
+    case "month":
+      return 28 * 24 * 60 * 60;
+    case "year":
+      return 365 * 24 * 60 * 60;
+    default:
+      throw new Error("Invalid period unit");
   }
 };
-
-// src/billing.ts
-import { toHex as toHex3 } from "viem";
-var transactionServiceUrl2 = "https://api.acta.link/transaction/v1/";
-var ActaBilling = class {
-  constructor(parameters) {
-    this.count = 0;
-    this.intervalUnit = void 0;
-    this.startDate = void 0;
-    this.endDate = void 0;
-    this.serviceSessionParams = void 0;
-    this.status = "not_started";
-    this.serviceType = "deposit";
-    this.allowMaxTokenApproval = false;
-    var _a;
-    this.connectorType = parameters.connectorType;
-    this.walletClient = parameters.walletClient;
-    this.signerAddress = parameters.signerAddress;
-    this.chainId = parameters.chainId;
-    this.token = parameters.token;
-    this.amount = parameters.amount;
-    this.receiver = parameters.receiver;
-    this.feeInclusive = parameters.feeInclusive;
-    this.paymentType = parameters.paymentType;
-    this.count = parameters.count;
-    this.intervalUnit = parameters.intervalUnit;
-    this.startDate = parameters.startDate;
-    this.endDate = parameters.endDate;
-    this.allowMaxTokenApproval = (_a = parameters.allowMaxTokenApproval) != null ? _a : false;
-    this.serviceType = parameters.serviceType;
-    this.viemClient = new ViemClient(this.chainId, this.walletClient);
-    this.account = new ActaAccount(
-      this.chainId,
-      this.viemClient.publicClient(),
-      this.walletClient
-    );
-  }
-  estimateSinglePaymentGas(parameters) {
-    return __async(this, null, function* () {
-      try {
-        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-          throw new Error("Only self custody payments are supported.");
-        }
-        const {
-          estimatedGasCostInToken,
-          ActalinkFeesInToken,
-          feeInclusiveAmountInToken,
-          feeExclusiveAmountInToken,
-          estimatedTotalFeesInToken,
-          paymaster,
-          userOperation
-        } = yield this.account.estimateSinglePaymentGas(parameters);
-        return {
-          estimatedGasCostInToken,
-          ActalinkFeesInToken,
-          feeInclusiveAmountInToken,
-          feeExclusiveAmountInToken,
-          estimatedTotalFeesInToken,
-          paymaster,
-          userOperation
-        };
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(error.message);
-        }
-        throw new Error("Failed to estimate single payment gas.");
+var createBillingCheckoutSession = (serviceSessionparams) => __async(null, null, function* () {
+  try {
+    const sessionData = yield createBillingSessionAPICall(
+      `${billingServiceUrl}paysession/create`,
+      {
+        paylinkId: serviceSessionparams.paylinkId
       }
-    });
+    );
+    if (sessionData) {
+      return sessionData.checkoutSessionId;
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(error.message);
+    }
+    throw new Error("Failed to create deposit session.");
   }
-  createSinglePayment(servicePaymentParams) {
-    return __async(this, null, function* () {
-      try {
-        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-          throw new Error("Only self custody payments are supported.");
-        }
-        if (!servicePaymentParams.checkoutSessionId || servicePaymentParams.checkoutSessionId === "") {
-          throw new Error("checkout session ID is required.");
-        }
-        const signerAddress = this.signerAddress;
-        const chainId = this.chainId;
-        const tokenSymbol = this.token;
-        const amount = this.amount;
-        const receiver = this.receiver;
-        const feeInclusive = this.feeInclusive;
-        const serviceType = this.serviceType;
-        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-        if (!token2) {
-          throw new Error("Token not supported.");
-        }
-        const rpcParameters = yield this.account.signSinglePaymentOperation({
-          signerAddress,
-          chainId,
-          token: tokenSymbol,
-          amount,
-          receiver,
-          feeInclusive,
-          allowMaxTokenApproval: this.allowMaxTokenApproval
-        });
-        const txn = yield executeSinglePaymentAPICall(
-          `${transactionServiceUrl2}execute/single`,
-          rpcParameters,
-          {
-            senderAddress: signerAddress,
-            receiverAddress: receiver,
-            chainId,
-            tokenAddress: token2.address,
-            amount: toHex3(amount),
-            feeInclusive,
-            serviceType
-          },
-          servicePaymentParams
-        );
-        return txn.transaction.id;
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(error.message);
-        }
-        throw new Error("Failed to create payment.");
-      }
-    });
+});
+var getBillingPaymentSessionDetails = (serviceSessionparams) => __async(null, null, function* () {
+  if (!serviceSessionparams.checkoutSessionId || serviceSessionparams.checkoutSessionId === "") {
+    throw new Error("checkout session ID is required.");
   }
-  createRecurringPayments(servicePaymentParams) {
-    return __async(this, null, function* () {
-      if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
-        throw new Error("Only self custody payments are supported.");
-      }
-      if (!servicePaymentParams.checkoutSessionId || servicePaymentParams.checkoutSessionId === "") {
-        throw new Error("checkout session ID is required.");
-      }
-      if (!this.walletClient) {
-        throw new Error("Signer is required for self custody payments.");
-      }
-      const signerAddress = this.signerAddress;
-      const chainId = this.chainId;
-      const tokenSymbol = this.token;
-      const amount = this.amount;
-      const receiver = this.receiver;
-      const feeInclusive = this.feeInclusive;
-      const count = this.count;
-      const intervalUnit = this.intervalUnit;
-      const startDate = this.startDate;
-      const endDate = this.endDate;
-      const serviceType = this.serviceType;
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) {
-        throw new Error("Token not supported.");
-      }
-      if (!chainId || !count || !intervalUnit || !startDate || !endDate) {
-        throw new Error("Invalid parameters.");
-      }
-      const approval = yield this.account.signRecurringPayments({
-        signerAddress,
-        chainId,
-        token: tokenSymbol,
-        amount,
-        feeInclusive,
-        count,
-        intervalUnit,
-        startDate,
-        endDate,
-        receiver,
-        allowMaxTokenApproval: this.allowMaxTokenApproval
-      });
-      const txn = yield scheduleRecurringPaymentsAPICall(
-        `${transactionServiceUrl2}schedule/recurring`,
-        {
-          amount,
-          chainId,
-          feeInclusive,
-          intervalCount: count,
-          intervalUnit,
-          senderAddress: signerAddress,
-          receiverAddress: receiver,
-          tokenAddress: token2.address,
-          startAt: startDate,
-          endAt: endDate,
-          approval,
-          serviceParams: servicePaymentParams,
-          serviceType
-        }
-      );
-      return txn.recurringTransaction.id;
+  const sessionData = yield fetchBillingSessionDetails(
+    `${billingServiceUrl}paysession?checkoutSessionId=${serviceSessionparams.checkoutSessionId}`
+  );
+  return sessionData;
+});
+var cancelRecurringTransaction = (_0) => __async(null, [_0], function* ({
+  serviceType,
+  paymentId,
+  chainId,
+  walletClient
+}) {
+  if (serviceType !== "billing" && serviceType !== "deposit")
+    throw new Error("service is not compatible");
+  const response = yield fetchRecurringTransactionWithId(
+    `${serviceType === "billing" ? billingServiceUrl : depositServiceUrl2}customer/payment/recurring/info?id=${paymentId}`
+  );
+  if (response) {
+    const viemClient = new ViemClient(chainId, walletClient);
+    const account = new ActaAccount(
+      chainId,
+      viemClient.publicClient(),
+      walletClient
+    );
+    console.log(`sender: ${response.senderAddress}`);
+    console.log(`receiver: ${response.receiverAddress}`);
+    console.log(`amountEx: ${hexToBigInt2(response.amountExclusive)}`);
+    console.log(`token: ${response.tokenAddress}`);
+    const rpcParameters = yield account.signRecurringTransactionCancellation({
+      signerAddress: response.senderAddress,
+      receiverAddress: response.receiverAddress,
+      amountExclusive: hexToBigInt2(response.amountExclusive),
+      token: response.tokenAddress
     });
-  }
-  getPaymentSteps() {
-    return __async(this, null, function* () {
-      const signerAddress = this.signerAddress;
-      const chainId = this.chainId;
-      const tokenSymbol = this.token;
-      const amount = this.amount;
-      const receiver = this.receiver;
-      const feeInclusive = this.feeInclusive;
-      const count = this.count;
-      if (!signerAddress) return ["allowance", "confirm"];
-      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
-      if (!token2) return ["allowance", "confirm"];
-      const smartAccount = yield this.account.createAccount();
-      const { estimatedGasCostInToken, feeExclusiveAmountInToken } = yield this.account.estimateSinglePaymentGas({
+    console.log(rpcParameters);
+    const txn = yield cancelRecurringPaymentAPICall(
+      `${transactionServiceUrl3}execute/cancel`,
+      rpcParameters,
+      {
         chainId,
-        amount,
-        feeInclusive,
-        receiver,
-        signerAddress,
-        token: tokenSymbol
-      });
-      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
-      let paymentAmount = (amountToTransfer + estimatedGasCostInToken * BigInt(2)) * BigInt(count != null ? count : 1);
-      const allowance = yield this.viemClient.checkTokenAllowance(
-        token2,
-        signerAddress,
-        smartAccount.address
-      );
-      if (paymentAmount <= allowance) return ["confirm"];
-      return ["allowance", "confirm"];
-    });
+        serviceType,
+        transactionId: response.transactionServiceId
+      },
+      {
+        servicePaymentId: response.id
+      }
+    );
+    txn;
   }
-};
+});
 export {
   ActaAccount,
   ActaBilling,
@@ -2139,6 +2319,8 @@ export {
   bscUSDT,
   bscWBNB,
   bytesToBase64,
+  cancelRecurringPaymentAPICall,
+  cancelRecurringTransaction,
   createBillingCheckoutSession,
   createBillingSessionAPICall,
   createPolicyFromParams,
@@ -2154,6 +2336,7 @@ export {
   ethereumWETH,
   executeSinglePaymentAPICall,
   fetchBillingSessionDetails,
+  fetchRecurringTransactionWithId,
   getBillingPaymentSessionDetails,
   getChainById,
   getChainExplorerByChainId,
@@ -2183,12 +2366,11 @@ export {
   polygonWPOL,
   scheduleRecurringPaymentsAPICall,
   sendRequest,
-  serializePermissionAccount,
   serializePermissionAccountParams,
   supportedChains,
   supportedTokensByChain,
-  toECDSASigner,
-  toPermissionValidator,
+  toECDSASigner2 as toECDSASigner,
+  toPermissionValidator2 as toPermissionValidator,
   toPolicyId,
   toSignerId,
   token,