@verified-network/verified-sdk 2.0.0 → 2.0.2

package/dist/contract/index.js

@@ -5,6 +5,9 @@ exports.VerifiedContract = exports.DATATYPES = void 0;
 const ethers_1 = require("ethers");
 const account_1 = require("@biconomy/account");
 const constants_1 = require("../utils/constants");
+const abstractjs_1 = require("@biconomy/abstractjs");
+const chains_1 = require("viem/chains");
+const viem_1 = require("viem");
 var STATUS;
 (function (STATUS) {
     STATUS[STATUS["SUCCESS"] = 0] = "SUCCESS";
@@ -386,13 +389,85 @@ class VerifiedContract {
                 }
             }
             else {
-                console.error("gasless transaction failed with error: ", err);
+                console.error("gasless transaction failed with error: ", (err === null || err === void 0 ? void 0 : err.message) || err);
                 console.log("will use ethers....");
                 return await this.callFunctionWithEthers(functionName, ...args);
             }
         }
     }
+    /** Constructs and call function using MEE client that allows gas payment in ERC20 tokens */
+    async callFunctionWithMEEClient(nexusAccount, chainId, tx, paymentToken) {
+        var _a, _b, _c;
+        let res = {};
+        let txHash = "";
+        try {
+            const meeClient = await (0, abstractjs_1.createMeeClient)({
+                account: nexusAccount,
+            });
+            const transactionInstruction = await nexusAccount.build({
+                type: "default",
+                data: {
+                    chainId,
+                    calls: [tx],
+                },
+            });
+            // Execute the transaction using passed paymentToken
+            const { hash } = await meeClient.execute({
+                feeToken: {
+                    chainId,
+                    address: paymentToken,
+                },
+                instructions: [transactionInstruction],
+            });
+            txHash = hash;
+            console.log(`MEE transaction hash: ${hash}`);
+            // Wait for transaction to complete
+            const receipt = await meeClient.waitForSupertransactionReceipt({ hash });
+            if (((_a = receipt === null || receipt === void 0 ? void 0 : receipt.receipts) === null || _a === void 0 ? void 0 : _a.length) > 1) {
+                //at least 2 receipts
+                const txReceipt = receipt === null || receipt === void 0 ? void 0 : receipt.receipts[((_b = receipt === null || receipt === void 0 ? void 0 : receipt.receipts) === null || _b === void 0 ? void 0 : _b.length) - 1];
+                if ((txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.status) === "success") {
+                    res.status = STATUS.SUCCESS;
+                    res.response = {
+                        hash: txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionHash,
+                        result: txReceipt,
+                    }; //TODO: update result on response
+                    res.message = "";
+                }
+                else {
+                    res.status = STATUS.ERROR;
+                    res.response = {
+                        hash: txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionHash,
+                        result: txReceipt,
+                    }; //TODO: update result on response
+                    res.message = "";
+                }
+                return res;
+            }
+            else {
+                console.error("Mee client transaction failed with error: ", "Receipts lesser than one.");
+                res.status = STATUS.ERROR;
+                res.response = {
+                    hash: (_c = receipt === null || receipt === void 0 ? void 0 : receipt.receipts[0]) === null || _c === void 0 ? void 0 : _c.transactionHash,
+                    result: receipt === null || receipt === void 0 ? void 0 : receipt.receipts[0],
+                }; //TODO: update result on response
+                res.message = "";
+                return res;
+            }
+        }
+        catch (err) {
+            console.error("Erc20 payment transaction failed with error: ", (err === null || err === void 0 ? void 0 : err.message) || err);
+            res.status = STATUS.ERROR;
+            res.response = {
+                hash: txHash,
+                result: {},
+            }; //TODO: update result on response
+            res.message = "";
+            return res;
+        }
+    }
     async callContract(functionName, ...args) {
+        var _a, _b, _c, _d;
         // Check if the function is a read function
         if (this.isReadFunction(functionName)) {
             console.log("read function will use ethers");
@@ -400,30 +475,22 @@ class VerifiedContract {
         }
         const chainId = await this.signer.getChainId();
         if (this.supportsGasless(chainId)) {
-            console.log("gassless supported will use userop");
+            console.log("gassless supported will use userop or mee client");
             //call contract through userop for gasless transaction
             let options = [];
             const totalArguments = args.length;
+            const optionsRaw = args.splice(-1);
             //reduce args to exclude options
             if (totalArguments > 1)
-                options = args.splice(-1);
+                options = optionsRaw;
             //console.log('options before', options);
             if (options == 0)
                 options[0] = {};
             //create smart account for signer
             const smartAccount = await this.createSmartAccount(chainId);
             const account = await smartAccount.getAccountAddress();
-            const signerAddress = await this.signer.getAddress();
-            //sanitize arguments to use smartaccount address
-            /*const newArgs = args.map((_arg: any) => {
-              if (
-                typeof _arg === "string" &&
-                _arg.toLowerCase() === signerAddress.toLowerCase()
-              ) {
-                _arg = account;
-              }
-              return _arg;
-            });*/
+            // console.log("smart account address: ", account);
+            // const signerAddress = await this.signer.getAddress();
             //construct calldata for function
             let fn = this.contract.populateTransaction[functionName];
             let _res = await fn(...args);
@@ -431,8 +498,25 @@ class VerifiedContract {
                 to: this.contract.address,
                 data: _res.data,
             };
-            const paymentToken = constants_1.PaymasterConstants[`${chainId}`]["PAYMENT_TOKEN"] || "";
-            return await this.callFunctionAsUserOp(smartAccount, tx1, functionName, paymentToken, ...args);
+            if ((_a = optionsRaw[0]) === null || _a === void 0 ? void 0 : _a.paymentToken) {
+                console.log("Using Mee client with paymentToken of: ", (_b = optionsRaw[0]) === null || _b === void 0 ? void 0 : _b.paymentToken);
+                const _signer = this.signer;
+                const nexusAccount = await (0, abstractjs_1.toMultichainNexusAccount)({
+                    chains: [chains_1.base, chains_1.mainnet, chains_1.sepolia, chains_1.gnosis, chains_1.baseSepolia, chains_1.polygon],
+                    transports: [(0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)()],
+                    signer: _signer,
+                });
+                const meeAddress = nexusAccount.addressOn(chainId);
+                // console.log("nexus account address: ", meeAddress);
+                return await this.callFunctionWithMEEClient(nexusAccount, chainId, tx1, (_c = optionsRaw[0]) === null || _c === void 0 ? void 0 : _c.paymentToken);
+            }
+            else {
+                console.log("Using Userop since no payment token...");
+                const paymentToken = ((_d = options[0]) === null || _d === void 0 ? void 0 : _d.paymentToken) ||
+                    constants_1.PaymasterConstants[`${chainId}`]["PAYMENT_TOKEN"] ||
+                    "";
+                return await this.callFunctionAsUserOp(smartAccount, tx1, functionName, paymentToken, ...args);
+            }
         }
         else {
             //call contract through normal ether.js
@@ -440,6 +524,69 @@ class VerifiedContract {
             return await this.callFunctionWithEthers(functionName, ...args);
         }
     }
+    async getQuote(paymentTokenAddress, functionName, args) {
+        var _a, _b;
+        const chainId = await this.signer.getChainId();
+        if (this.supportsGasless(chainId)) {
+            const _signer = this.signer;
+            const nexusAccount = await (0, abstractjs_1.toMultichainNexusAccount)({
+                chains: [chains_1.base, chains_1.mainnet, chains_1.sepolia, chains_1.gnosis, chains_1.baseSepolia, chains_1.polygon],
+                transports: [(0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)(), (0, viem_1.http)()],
+                signer: _signer,
+            });
+            if (paymentTokenAddress) {
+                //construct calldata for function
+                try {
+                    let fn = this.contract.populateTransaction[functionName];
+                    let _res = await fn(...args);
+                    const tx1 = {
+                        to: this.contract.address,
+                        data: _res.data,
+                    };
+                    const meeClient = await (0, abstractjs_1.createMeeClient)({
+                        account: nexusAccount,
+                    });
+                    const transactionInstruction = await nexusAccount.build({
+                        type: "default",
+                        data: {
+                            chainId,
+                            calls: [tx1],
+                        },
+                    });
+                    const tkAddress = paymentTokenAddress;
+                    const quote = await meeClient.getQuote({
+                        instructions: [transactionInstruction],
+                        feeToken: { address: tkAddress, chainId },
+                    });
+                    return {
+                        tokenAddress: paymentTokenAddress,
+                        amount: quote === null || quote === void 0 ? void 0 : quote.paymentInfo.tokenAmount,
+                        amountInWei: quote === null || quote === void 0 ? void 0 : quote.paymentInfo.tokenWeiAmount,
+                        amouuntValue: quote === null || quote === void 0 ? void 0 : quote.paymentInfo.tokenValue,
+                        chainId,
+                        functionName,
+                    };
+                }
+                catch (err) {
+                    if ((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes("fn is not a function")) {
+                        throw new Error(`Function ${functionName} not found in contract's ABI`);
+                    }
+                    else if ((_b = err === null || err === void 0 ? void 0 : err.message) === null || _b === void 0 ? void 0 : _b.includes("code=INVALID_ARGUMENT")) {
+                        throw new TypeError(`Invalid arguments type`);
+                    }
+                    throw new Error((err === null || err === void 0 ? void 0 : err.message) || "getQuote failed.");
+                }
+            }
+        }
+        return {
+            tokenAddress: "",
+            amount: "0",
+            amountInWei: "0",
+            amouuntValue: "0",
+            chainId,
+            functionName,
+        };
+    }
     getEvent(eventName, callback) {
         let res = {};
         this.contract.once(eventName, (...data) => {

package/dist/contract/liquidity/index.d.ts

@@ -1,117 +1,92 @@
-import { VerifiedContract } from '../index';
+import { VerifiedContract, Options } from "../index";
 import { VerifiedWallet } from "../../wallet";
 export default class LiquidityContract extends VerifiedContract {
     contractAddress: string;
     constructor(signer: VerifiedWallet, contractNetworkAddress: string);
-    /**
-        Creates supply of the Verified Liquidity token after initial issue with constructor defined parameters
-        @param  _supply total supply of VITTA
-        @param  _cap    investment limit for each investor
-        @param  _limit  time limit for issue close
-     */
-    createSupply(_cap: string, _limit: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Specifies list of supported tokens that can be invested in the Verified Liquidity token
-        @param  _tokens array of supported token addresses
-     */
-    supportTokens(_tokens: string, _name: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Checks if a specified token is supported for investing in the Verified Liquidity token
-        @param  _token  token that is supported for investment
-     */
-    checkSupportForToken(_token: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Removes support for token for investing in the Verified Liquidity token
-        @param  _token  token that is supported for investment
-     */
-    removeToken(_token: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    _getMeeQuote(paymentTokenAddress: string, functionName: string, args: any[]): Promise<{
+        tokenAddress: string;
+        amount: string;
+        amountInWei: string;
+        amouuntValue: string;
+        chainId: number;
+        functionName: string;
+    }>;
+    /**
+          Creates supply of the Verified Liquidity token after initial issue with constructor defined parameters
+          @param  _supply total supply of VITTA
+          @param  _cap    investment limit for each investor
+          @param  _limit  time limit for issue close
+       */
+    createSupply(_cap: string, _limit: string, options?: Options): any;
+    /**
+          Specifies list of supported tokens that can be invested in the Verified Liquidity token
+          @param  _tokens array of supported token addresses
+       */
+    supportTokens(_tokens: string, _name: string, options?: Options): any;
+    /**
+          Checks if a specified token is supported for investing in the Verified Liquidity token
+          @param  _token  token that is supported for investment
+       */
+    checkSupportForToken(_token: string, options?: Options): any;
+    /**
+          Removes support for token for investing in the Verified Liquidity token
+          @param  _token  token that is supported for investment
+       */
+    removeToken(_token: string, options?: Options): any;
     /**
      * Returns list of supported liquidity tokens (eg, VITTA, USDC, DAI)
      * @returns array of struct of tokens
      */
     getSupportedTokens(): any;
     /**
-        Registers a liquidity platform (eg, DEX) where Verified Liquidity tokens can be used to underwrite investments
-        @param  _liquidityPlatform  address of the market making platform
-     */
-    registerPlatform(_platform: string, _name: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Used by external apps (eg, exchange, wallet) to buy Verified Liquidity token
-        @param  _token  address of token used by investor to buy the VITTA
-        @param  _amount amount of token that is transferred from investor to this VITTA issuing contract's account for the investor
-     */
-    buy(_token: string, _amount: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+          Registers a liquidity platform (eg, DEX) where Verified Liquidity tokens can be used to underwrite investments
+          @param  _liquidityPlatform  address of the market making platform
+       */
+    registerPlatform(_platform: string, _name: string, options?: Options): any;
     /**
-        Fetches investors in VITTA
-     */
+          Used by external apps (eg, exchange, wallet) to buy Verified Liquidity token
+          @param  _token  address of token used by investor to buy the VITTA
+          @param  _amount amount of token that is transferred from investor to this VITTA issuing contract's account for the investor
+       */
+    buy(_token: string, _amount: string, options?: Options): any;
+    /**
+          Fetches investors in VITTA
+       */
     getInvestors(): any;
     /**
-        Fetches registered platforms
-     */
+          Fetches registered platforms
+       */
     getPlatforms(): any;
     /**
-        Fetches investment detail for specific investor in VITTA
-        @param  _investor   address of investor
-        @param  _token      address of token invested by investor
-     */
-    getInvestment(_investor: string, _token: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Used by Issuers (eg, asset managers) to issue VITTA to investors or refund paid in tokens to investors if investment cap is breached
-        @param  _investor       address of investor
-        @param  _token          address of token invested in VITTA
-        @param  _tokenAmount    amount of token invested in VITTA
-        @param  _LPToIssue      amount of VITTA to issue to investor
-     */
-    issue(_investor: string, _token: string, _tokenAmount: string, _LPToIssue: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Used by VITTA holder to stake it for providing liquidity for underwriting investments
-        @param  _toStake    amount of VITTA to stake
-     */
-    stake(_toStake: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Used by VITTA holder to withdraw staked liquidity for underwriting investments
-        @param  _fromStake    amount of VITTA staked
-     */
-    withdraw(_fromStake: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-        Pay out of income to VITTA Liquidity providers
-        @param  _distribution   amount of VITTA to mint and distribute pro rata to liquidity providers
-        @param  _platform       address of liquidity platform
-     */
-    payOut(_distribution: string, _platform: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+          Fetches investment detail for specific investor in VITTA
+          @param  _investor   address of investor
+          @param  _token      address of token invested by investor
+       */
+    getInvestment(_investor: string, _token: string, options?: Options): any;
+    /**
+          Used by Issuers (eg, asset managers) to issue VITTA to investors or refund paid in tokens to investors if investment cap is breached
+          @param  _investor       address of investor
+          @param  _token          address of token invested in VITTA
+          @param  _tokenAmount    amount of token invested in VITTA
+          @param  _LPToIssue      amount of VITTA to issue to investor
+       */
+    issue(_investor: string, _token: string, _tokenAmount: string, _LPToIssue: string, options?: Options): any;
+    /**
+          Used by VITTA holder to stake it for providing liquidity for underwriting investments
+          @param  _toStake    amount of VITTA to stake
+       */
+    stake(_toStake: string, options?: Options): any;
+    /**
+          Used by VITTA holder to withdraw staked liquidity for underwriting investments
+          @param  _fromStake    amount of VITTA staked
+       */
+    withdraw(_fromStake: string, options?: Options): any;
+    /**
+          Pay out of income to VITTA Liquidity providers
+          @param  _distribution   amount of VITTA to mint and distribute pro rata to liquidity providers
+          @param  _platform       address of liquidity platform
+       */
+    payOut(_distribution: string, _platform: string, options?: Options): any;
     /**
      * Adds asset manager to manage liquidity
      * @param _platform address of market making platform (eg Balancer)
@@ -119,10 +94,7 @@ export default class LiquidityContract extends VerifiedContract {
      * @param options
      * @returns         none
      */
-    addManager(_platform: string, _manager: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    addManager(_platform: string, _manager: string, options?: Options): any;
     /**
      * Removes asset manager managing liquidity
      * @param _platform address of market making platform (eg Balancer)
@@ -130,45 +102,33 @@ export default class LiquidityContract extends VerifiedContract {
      * @param options
      * @returns         none
      */
-    removeManager(_platform: string, _manager: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    removeManager(_platform: string, _manager: string, options?: Options): any;
     /**
      * Fetches asset managers
      * @param _platform address of market making platform
      * @param options
      * @returns         array of asset manager addresses
      */
-    getManagers(_platform: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-     * Gets return on investment performance of market making platform
-     * @param _platform address of market making platform
-     * @param options
-     * @returns         uint256 unstakedLiquidity,
-                        uint256 balancePlatformLiquidity,
-                        uint256 platformLiquidityProvided,
-                        uint256 platformCommissionsEarned
-     */
-    getPlatformPerformance(_platform: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
-    /**
-     * Gets return on investment performance for asset manager
-     * @param _platform address of market making platform (eg Balancer)
-     * @param _manager  address of asset manager
-     * @param options
-     * @returns         uint256 managerLiquidityProvided,
-                        uint256 managerCommissionsEarned
-     */
-    getManagerPerformance(_platform: string, _token: string, _manager: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    getManagers(_platform: string, options?: Options): any;
+    /**
+       * Gets return on investment performance of market making platform
+       * @param _platform address of market making platform
+       * @param options
+       * @returns         uint256 unstakedLiquidity,
+                          uint256 balancePlatformLiquidity,
+                          uint256 platformLiquidityProvided,
+                          uint256 platformCommissionsEarned
+       */
+    getPlatformPerformance(_platform: string, options?: Options): any;
+    /**
+       * Gets return on investment performance for asset manager
+       * @param _platform address of market making platform (eg Balancer)
+       * @param _manager  address of asset manager
+       * @param options
+       * @returns         uint256 managerLiquidityProvided,
+                          uint256 managerCommissionsEarned
+       */
+    getManagerPerformance(_platform: string, _token: string, _manager: string, options?: Options): any;
     /**
      * Provides liquidity to asset managers on platform
      * @param _platform     address of market making platform
@@ -177,19 +137,13 @@ export default class LiquidityContract extends VerifiedContract {
      * @param options
      * @returns             none
      */
-    provideLiquidity(_platform: string, _manager: string, _liquidity: string, _token: string, _tokenAmount: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    provideLiquidity(_platform: string, _manager: string, _liquidity: string, _token: string, _tokenAmount: string, options?: Options): any;
     /**
      * Fetches balance of investor
      * @param _investor address of investor
      * @param options
      * @returns         balance of investor
      */
-    balanceOf(_investor: string, options?: {
-        gasPrice: number;
-        gasLimit: number;
-    }): any;
+    balanceOf(_investor: string, options?: Options): any;
     notifyIssue(callback: any): object;
 }