@actalink/commonlib 0.0.10 → 0.0.12

package/dist/index.js

@@ -807,6 +807,83 @@ var ActaAccount = class {
       };
     });
   }
+  estimateSingleBatchPaymentGas(parameters) {
+    return __async(this, null, function* () {
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        receivers,
+        feeInclusive,
+        walletClient,
+        totalAmount
+      } = parameters;
+      if (totalAmount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (receivers.length === 0) {
+        throw new Error("Receivers not found for batch payment");
+      }
+      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.");
+      }
+      console.log(`fromAddress: ${fromAddress}`);
+      const quotes = yield pimlicoClient.getTokenQuotes({
+        tokens: [token2.address],
+        chain: getChainById(chainId)
+      });
+      const { postOpGas, exchangeRate, paymaster } = quotes[0];
+      console.log("preparing");
+      console.log(token2.address);
+      const receiversData = receivers.map((r) => {
+        return {
+          to: getAddress2(token2.address),
+          abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+          functionName: "transferFrom",
+          args: [fromAddress, r.address, BigInt(0)]
+        };
+      });
+      console.log(receiversData);
+      const userOperation = yield accountClient.prepareUserOperation({
+        calls: [
+          ...receiversData,
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              fromAddress,
+              "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+              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 = totalAmount * BigInt(20) / BigInt(1e4);
+      const estimatedTotalFeesInToken = estimatedGasCostInToken + ActalinkFeesInToken;
+      const feeInclusiveAmountInToken = totalAmount - estimatedTotalFeesInToken;
+      const feeExclusiveAmountInToken = totalAmount + estimatedTotalFeesInToken;
+      return {
+        estimatedGasCostInToken,
+        ActalinkFeesInToken,
+        estimatedTotalFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        paymaster,
+        userOperation
+      };
+    });
+  }
   signSinglePaymentOperation(singlePaymentParams) {
     return __async(this, null, function* () {
       try {
@@ -895,6 +972,102 @@ var ActaAccount = class {
       }
     });
   }
+  signSingleBatchOperation(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,
+          receivers,
+          feeInclusive,
+          allowMaxTokenApproval,
+          totalAmount,
+          walletClient
+        } = singlePaymentParams;
+        if (totalAmount <= BigInt(0)) {
+          throw new Error("Amount must be greater than 0.");
+        }
+        if (receivers.length === 0) {
+          throw new Error("Receivers not found for batch payment");
+        }
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!token2) {
+          throw new Error("Token not found.");
+        }
+        const viemClient = new ViemClient(this.chainId, this.signer);
+        console.log("validating gas");
+        console.log(receivers);
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster
+        } = yield this.estimateSingleBatchPaymentGas({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          receivers,
+          feeInclusive,
+          totalAmount,
+          walletClient
+        });
+        const account = yield this.createAccount();
+        const { accountClient } = yield this.createAccountHelpers();
+        const fromAddress = signerAddress;
+        const smartAccountAddress = account.address;
+        const amountToTransfer = feeInclusive ? totalAmount : feeExclusiveAmountInToken;
+        const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : totalAmount;
+        console.log("checking approval");
+        yield viemClient.checkAndApproveToken(
+          token2,
+          smartAccountAddress,
+          amountToTransfer,
+          allowMaxTokenApproval != null ? allowMaxTokenApproval : false
+        );
+        const receiversData = receivers.map((r) => {
+          return {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [fromAddress, r.address, r.amount]
+          };
+        });
+        const userOperation = yield accountClient.prepareUserOperation({
+          calls: [
+            ...receiversData,
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [
+                fromAddress,
+                "0xC4910E5ec82Da0A41aF9C6360b7A1f531e1e37B0",
+                estimatedGasCostInToken
+              ]
+            }
+          ]
+        });
+        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.");
+      }
+    });
+  }
   signRecurringPayments(recurringPaymentParams) {
     return __async(this, null, function* () {
       if (!this.signer) {
@@ -1255,6 +1428,24 @@ function executeSinglePaymentAPICall(url, userOperation, paymentParams, serviceP
     return response.data;
   });
 }
+function executeSingleBatchPaymentAPICall(url, APIKey, userOperation, paymentParams, serviceParams) {
+  return __async(this, null, function* () {
+    const params = {
+      userOperation,
+      paymentParams,
+      serviceParams
+    };
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: params,
+      headers: {
+        "x-api-key": APIKey
+      }
+    });
+    return response.data;
+  });
+}
 function fetchRecurringTransactionWithId(url) {
   return __async(this, null, function* () {
     const response = yield sendRequest({ url, method: "get" /* Get */ });
@@ -1276,6 +1467,31 @@ function cancelRecurringPaymentAPICall(url, userOperation, paymentParams, servic
     return response.data;
   });
 }
+function createBatchSessionAPICall(url, APIKey, params) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: params,
+      headers: {
+        "x-api-key": APIKey
+      }
+    });
+    return response.data;
+  });
+}
+function fetchBatchInstructionDetails(url, APIKey) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "get" /* Get */,
+      headers: {
+        "x-api-key": APIKey
+      }
+    });
+    return response.data;
+  });
+}
 
 // src/deposit.ts
 var transactionServiceUrl = "https://api.acta.link/transaction/v1/";
@@ -1840,6 +2056,213 @@ var ActaBilling = class {
   }
 };
 
+// src/batch.ts
+import {
+  getAddress as getAddress3,
+  parseUnits,
+  toHex as toHex4,
+  zeroAddress as zeroAddress5
+} from "viem";
+var batchServiceUrl = "http://localhost:4000/batch/api/v1/";
+var ActaBatch = class {
+  constructor(parameters) {
+    this.APIkey = parameters.APIKey;
+  }
+  createSession(params) {
+    return __async(this, null, function* () {
+      try {
+        const { instructionId, name, signerAddress, token: token2, chainId } = params;
+        if (!signerAddress || signerAddress === zeroAddress5) {
+          throw new Error("Signer address is required.");
+        }
+        if (!name || name === "") {
+          throw new Error("Name of Batch payment is required");
+        }
+        if (!token2) {
+          throw new Error("Token symbol is required");
+        }
+        if (!instructionId || instructionId === "") {
+          throw new Error("Instruction id is required");
+        }
+        const session = yield createBatchSessionAPICall(
+          `${batchServiceUrl}create/session`,
+          this.APIkey,
+          {
+            name,
+            chainId,
+            instructionId,
+            signerAddress,
+            token: token2
+          }
+        );
+        console.log(session);
+        const sessionId = session.id;
+        return sessionId;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create session.");
+      }
+    });
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      try {
+        const {
+          chainId,
+          feeInclusive,
+          signerAddress,
+          token: token2,
+          walletClient,
+          instructionId
+        } = parameters;
+        const instuctionData = yield fetchBatchInstructionDetails(
+          `${batchServiceUrl}instruction/${instructionId}`,
+          this.APIkey
+        );
+        if (instuctionData.receivers.length === 0 || instuctionData.receivers.length === void 0) {
+          throw new Error("Instruction not found");
+        }
+        const tokenData = getTokenByChainIdAndSymbol(chainId, token2);
+        if (!tokenData) {
+          throw new Error("Token not supported");
+        }
+        const totalAmount = instuctionData.totalAmount;
+        const totalAmountParsed = BigInt(
+          parseUnits(totalAmount, tokenData.decimals)
+        );
+        const receivers = instuctionData.receivers.map(
+          (i) => {
+            const receiver = getAddress3(i.address);
+            const tokenAmount = BigInt(parseUnits(i.amount, tokenData.decimals));
+            return {
+              address: receiver,
+              amount: tokenAmount
+            };
+          }
+        );
+        const viemClient = new ViemClient(chainId, walletClient);
+        const account = new ActaAccount(
+          chainId,
+          viemClient.publicClient(),
+          walletClient
+        );
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        } = yield account.estimateSingleBatchPaymentGas({
+          chainId,
+          feeInclusive,
+          signerAddress,
+          token: token2,
+          walletClient,
+          receivers,
+          totalAmount: totalAmountParsed
+        });
+        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.");
+      }
+    });
+  }
+  createSingleBatchPayment(params, serviceParams) {
+    return __async(this, null, function* () {
+      try {
+        const {
+          chainId,
+          feeInclusive,
+          signerAddress,
+          token: tokenSymbol,
+          walletClient,
+          allowMaxTokenApproval,
+          instructionId
+        } = params;
+        const instuctionData = yield fetchBatchInstructionDetails(
+          `${batchServiceUrl}instruction/${instructionId}`,
+          this.APIkey
+        );
+        if (instuctionData.receivers.length === 0 || instuctionData.receivers.length === void 0) {
+          throw new Error("Instruction not found");
+        }
+        console.log(instuctionData);
+        const tokenData = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!tokenData) {
+          throw new Error("Token not supported");
+        }
+        const totalAmount = instuctionData.totalAmount;
+        const totalAmountParsed = BigInt(
+          parseUnits(totalAmount, tokenData.decimals)
+        );
+        const receivers = instuctionData.receivers.map(
+          (i) => {
+            const receiver = getAddress3(i.address);
+            const tokenAmount = BigInt(parseUnits(i.amount, tokenData.decimals));
+            return {
+              address: receiver,
+              amount: tokenAmount
+            };
+          }
+        );
+        const viemClient = new ViemClient(chainId, walletClient);
+        const account = new ActaAccount(
+          chainId,
+          viemClient.publicClient(),
+          walletClient
+        );
+        console.log("signing");
+        const rpcParameters = yield account.signSingleBatchOperation({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          feeInclusive,
+          receivers,
+          totalAmount: totalAmountParsed,
+          walletClient,
+          allowMaxTokenApproval
+        });
+        const txn = yield executeSingleBatchPaymentAPICall(
+          `${batchServiceUrl}execute/single/batch`,
+          this.APIkey,
+          rpcParameters,
+          {
+            senderAddress: signerAddress,
+            chainId,
+            tokenAddress: tokenData.address,
+            amount: toHex4(totalAmountParsed),
+            feeInclusive,
+            serviceType: "batch"
+          },
+          serviceParams
+        );
+        console.log(txn);
+        return txn.transaction.id;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create payment.");
+      }
+    });
+  }
+};
+
 // src/utils.ts
 import {
   constants,
@@ -1859,7 +2282,7 @@ import {
   encodeAbiParameters,
   keccak256,
   slice,
-  zeroAddress as zeroAddress5,
+  zeroAddress as zeroAddress6,
   decodeFunctionData,
   hexToBigInt as hexToBigInt2
 } from "viem";
@@ -1884,7 +2307,7 @@ import { coerce, gt } from "semver";
 var ECDSA_SIGNER_CONTRACT = "0x6A6F069E2a08c2468e7724Ab3250CdBFBA14D4FF";
 var billingServiceUrl = "https://api.acta.link/billing/v1/";
 var depositServiceUrl2 = "https://api.acta.link/deposit/v1/";
-var transactionServiceUrl3 = "http://localhost:8000/transaction/v1/";
+var transactionServiceUrl3 = "https://api.acta.link/transaction/v1/";
 var toSignerId = (signer) => {
   return encodeAbiParameters(
     [{ name: "signerData", type: "bytes" }],
@@ -1970,7 +2393,7 @@ function toPermissionValidator2(_0, _1) {
     return __spreadProps(__spreadValues({}, signer.account), {
       supportedKernelVersions: ">=0.3.0",
       validatorType: "PERMISSION",
-      address: zeroAddress5,
+      address: zeroAddress6,
       source: "PermissionValidator",
       getEnableData,
       getIdentifier: getPermissionId,
@@ -2221,15 +2644,21 @@ var getPeriodInterval = (periodUnit) => {
   }
 };
 var createBillingCheckoutSession = (serviceSessionparams) => __async(null, null, function* () {
+  var _a, _b, _c, _d;
   try {
     const sessionData = yield createBillingSessionAPICall(
       `${billingServiceUrl}paysession/create`,
       {
-        paylinkId: serviceSessionparams.paylinkId
+        paylinkId: serviceSessionparams.paylinkId,
+        mode: serviceSessionparams.mode,
+        successUrl: (_a = serviceSessionparams.successUrl) != null ? _a : void 0,
+        cancelUrl: (_b = serviceSessionparams.cancelUrl) != null ? _b : void 0,
+        failureUrl: (_c = serviceSessionparams.failureUrl) != null ? _c : void 0,
+        metadata: (_d = serviceSessionparams.metadata) != null ? _d : void 0
       }
     );
     if (sessionData) {
-      return sessionData.checkoutSessionId;
+      return sessionData;
     }
   } catch (error) {
     if (error instanceof Error) {
@@ -2293,6 +2722,7 @@ var cancelRecurringTransaction = (_0) => __async(null, [_0], function* ({
 });
 export {
   ActaAccount,
+  ActaBatch,
   ActaBilling,
   ActaDeposit,
   ConnectorType,
@@ -2321,6 +2751,7 @@ export {
   bytesToBase64,
   cancelRecurringPaymentAPICall,
   cancelRecurringTransaction,
+  createBatchSessionAPICall,
   createBillingCheckoutSession,
   createBillingSessionAPICall,
   createPolicyFromParams,
@@ -2334,7 +2765,9 @@ export {
   ethereumUSDC,
   ethereumUSDT,
   ethereumWETH,
+  executeSingleBatchPaymentAPICall,
   executeSinglePaymentAPICall,
+  fetchBatchInstructionDetails,
   fetchBillingSessionDetails,
   fetchRecurringTransactionWithId,
   getBillingPaymentSessionDetails,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actalink/commonlib",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "author": "Actalink",
   "license": "MIT license",
   "publishConfig": {