@verified-network/verified-sdk 1.3.8 → 1.4.0

package/dist/contract/index.js

@@ -1,8 +1,18 @@
 // SPDX-License-Identifier: BUSL-1.1
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VerifiedContract = exports.DATATYPES = void 0;
+const dotenv_1 = require("dotenv");
 const ethers_1 = require("ethers");
+const web3_1 = __importDefault(require("web3"));
+const account_1 = require("@biconomy/account");
+const modules_1 = require("@biconomy/modules");
+const bundler_1 = require("@biconomy/bundler");
+const paymaster_1 = require("@biconomy/paymaster");
+dotenv_1.config();
 var STATUS;
 (function (STATUS) {
     STATUS[STATUS["SUCCESS"] = 0] = "SUCCESS";
@@ -132,7 +142,7 @@ class VerifiedContract {
      */
     tempOutput(data) {
         const response = { hash: '', result: [] };
-        data.forEach((element) => {
+        data.forEach(async (element) => {
             if (element.hash !== undefined || element.transactionHash)
                 return response.hash = element.hash || element.transactionHash;
             if (element._isBigNumber)
@@ -142,7 +152,7 @@ class VerifiedContract {
             //if (utils.isBytesLike(element)) return response.result.push(this.sanitiseOutput(DATATYPES.BYTE32, element))
             if (ethers_1.utils.isBytesLike(element))
                 return response.result.push(element);
-            if (typeof element === 'boolean' || (this.validateInput(DATATYPES.ADDRESS, element)))
+            if (typeof element === 'boolean' || (await this.validateInput(DATATYPES.ADDRESS, element)))
                 return response.result.push(element);
         });
         return response;
@@ -154,7 +164,47 @@ class VerifiedContract {
         else
             return [data];
     }
-    async callContract(functionName, ...args) {
+    /** Checks if a contract support gasless transaction */
+    supportsGasless(chainId) {
+        let isSupported = false;
+        const contractPaymasterUrl = process.env[`${chainId}_PAYMASTER_API_KEY`];
+        if (contractPaymasterUrl && contractPaymasterUrl.length > 0)
+            isSupported = true;
+        return isSupported;
+    }
+    /** Creates Biconomy smart account */
+    async createSmartAccount(chainId) {
+        //create bundler instance
+        const bundler = new bundler_1.Bundler({
+            bundlerUrl: `${process.env.BUNDLER_URL_FIRST_SECTION}/${chainId}/${process.env.BUNDLER_URL_SECTION_SECTION}`,
+            chainId: chainId,
+            entryPointAddress: account_1.DEFAULT_ENTRYPOINT_ADDRESS,
+        });
+        // console.log("bd: ", bundler);
+        //create paymaster instance
+        const paymaster = new paymaster_1.BiconomyPaymaster({
+            paymasterUrl: `${process.env.GENERAL_PAYMASTER_URL}/${chainId}/${process.env[`${chainId}_PAYMASTER_API_KEY`]}`,
+        });
+        // console.log("pm: ", paymaster);
+        const module = await modules_1.ECDSAOwnershipValidationModule.create({
+            signer: this.signer,
+            moduleAddress: modules_1.DEFAULT_ECDSA_OWNERSHIP_MODULE,
+        });
+        //create biconomy smart account
+        let biconomyAccount = await account_1.BiconomySmartAccountV2.create({
+            chainId: chainId,
+            bundler: bundler,
+            paymaster: paymaster,
+            entryPointAddress: account_1.DEFAULT_ENTRYPOINT_ADDRESS,
+            defaultValidationModule: module,
+            activeValidationModule: module,
+        });
+        // console.log("address", await biconomyAccount.getAccountAddress());
+        //return smart account
+        return biconomyAccount;
+    }
+    /** Constructs and call function with ethers.js */
+    async callFunctionWithEthers(functionName, ...args) {
         let res = {};
         try {
             let options = [];
@@ -177,7 +227,7 @@ class VerifiedContract {
             //console.log('_resp', _resp)
             res.response = this.tempOutput(this.convertToArray(ethers_1.utils.deepCopy(_resp)));
             res.status = STATUS.SUCCESS;
-            res.message = '';
+            res.message = "";
             return res;
         }
         catch (error) {
@@ -189,6 +239,154 @@ class VerifiedContract {
             return res;
         }
     }
+    /** Constructs and call function as userop for biconomy gassless(sponsored/erc20 mode) */
+    async callFunctionAsUserOp(smartAccount, userOp) {
+        //send userops transaction and construct transaction response
+        let res = {};
+        try {
+            const userOpResponse = await smartAccount.sendUserOp(userOp);
+            const transactionDetails = await userOpResponse.wait();
+            if (transactionDetails.success === "true") {
+                res.response = {
+                    hash: transactionDetails.receipt.transactionHash,
+                    result: [],
+                }; //TODO: update response
+                res.status = STATUS.SUCCESS;
+                res.message = "";
+                return res;
+            }
+            else {
+                const logs = transactionDetails.receipt.logs;
+                let reason = "";
+                const provider = this.contract.provider;
+                logs.map((log) => {
+                    if (log.topics.includes(process.env.BICONOMY_REVERT_TOPIC)) {
+                        const web3 = new web3_1.default(provider);
+                        reason = web3.utils.hexToAscii(log.data);
+                    }
+                });
+                throw Error(`execution reverted: ${reason}`);
+            }
+        }
+        catch (err) {
+            console.log(err);
+            res.status = STATUS.ERROR;
+            res.reason = err.reason;
+            res.message = err.message;
+            res.code = err.code;
+            return res;
+        }
+    }
+    async callContract(functionName, ...args) {
+        const chainId = await this.signer.getChainId();
+        if (this.supportsGasless(chainId)) {
+            console.log("gassless supported will use userop");
+            //call contract through userop for gasless transaction
+            let options = [];
+            const totalArguments = args.length;
+            //reduce args to exclude options
+            if (totalArguments > 1)
+                options = args.splice(-1);
+            //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) => {
+                if (typeof _arg === "string" &&
+                    _arg.toLowerCase() === signerAddress.toLowerCase()) {
+                    _arg = account;
+                }
+                return _arg;
+            });
+            //construct calldata for function
+            let fn = this.contract.populateTransaction[functionName];
+            let _res = await fn(...newArgs);
+            const tx1 = {
+                to: this.contract.address,
+                data: _res.data,
+            };
+            //build userop transaction
+            let partialUserOp = await smartAccount.buildUserOp([tx1]);
+            //query paymaster for sponsored mode to get neccesary params and update userop
+            const biconomyPaymaster = smartAccount.paymaster;
+            try {
+                const paymasterAndDataResponse = await biconomyPaymaster.getPaymasterAndData(partialUserOp, {
+                    mode: paymaster_1.PaymasterMode.SPONSORED,
+                });
+                // console.log("pmR: ", paymasterAndDataResponse);
+                if (paymasterAndDataResponse) {
+                    partialUserOp.paymasterAndData =
+                        paymasterAndDataResponse.paymasterAndData;
+                    if (paymasterAndDataResponse.callGasLimit &&
+                        paymasterAndDataResponse.verificationGasLimit &&
+                        paymasterAndDataResponse.preVerificationGas) {
+                        partialUserOp.callGasLimit = paymasterAndDataResponse.callGasLimit;
+                        partialUserOp.verificationGasLimit =
+                            paymasterAndDataResponse.verificationGasLimit;
+                        partialUserOp.preVerificationGas =
+                            paymasterAndDataResponse.preVerificationGas;
+                    }
+                }
+                return await this.callFunctionAsUserOp(smartAccount, partialUserOp);
+            }
+            catch (err) {
+                console.log("sponsored failed will try erc20");
+                //if userop can't be sponsored use ERC20 mode
+                try {
+                    let finalUserOp = partialUserOp;
+                    //get fee quote for network cash token
+                    const feeQuotesResponse = await biconomyPaymaster.getPaymasterFeeQuotesOrData(partialUserOp, {
+                        mode: paymaster_1.PaymasterMode.ERC20,
+                        tokenList: [process.env[`${chainId}_CASH_TOKEN_ADDRESS`]],
+                    });
+                    // console.log("fq: ", feeQuotesResponse);
+                    const feeQuotes = feeQuotesResponse.feeQuotes;
+                    const spender = feeQuotesResponse.tokenPaymasterAddress || "";
+                    const tokenFeeQuotes = feeQuotes[0];
+                    finalUserOp = await smartAccount.buildTokenPaymasterUserOp(partialUserOp, {
+                        feeQuote: tokenFeeQuotes,
+                        spender: spender,
+                        maxApproval: false,
+                    });
+                    let paymasterServiceData = {
+                        mode: paymaster_1.PaymasterMode.ERC20,
+                        feeTokenAddress: tokenFeeQuotes.tokenAddress,
+                        calculateGasLimits: true,
+                    };
+                    const paymasterAndDataWithLimits = await biconomyPaymaster.getPaymasterAndData(finalUserOp, paymasterServiceData);
+                    finalUserOp.paymasterAndData =
+                        paymasterAndDataWithLimits.paymasterAndData;
+                    if (paymasterAndDataWithLimits.callGasLimit &&
+                        paymasterAndDataWithLimits.verificationGasLimit &&
+                        paymasterAndDataWithLimits.preVerificationGas) {
+                        finalUserOp.callGasLimit = paymasterAndDataWithLimits.callGasLimit;
+                        finalUserOp.verificationGasLimit =
+                            paymasterAndDataWithLimits.verificationGasLimit;
+                        finalUserOp.preVerificationGas =
+                            paymasterAndDataWithLimits.preVerificationGas;
+                    }
+                    const _paymasterAndDataWithLimits = await biconomyPaymaster.getPaymasterAndData(finalUserOp, paymasterServiceData);
+                    finalUserOp.paymasterAndData =
+                        _paymasterAndDataWithLimits.paymasterAndData;
+                    return await this.callFunctionAsUserOp(smartAccount, finalUserOp);
+                }
+                catch (_err) {
+                    //if erc20 mode didn't work use ethers.js
+                    console.log("both sponsored and erc20 failed will use ethers: ");
+                    return await this.callFunctionWithEthers(functionName, ...args);
+                }
+            }
+        }
+        else {
+            //call contract through normal ether.js
+            console.log("gassless not supported will use ethers");
+            return await this.callFunctionWithEthers(functionName, ...args);
+        }
+    }
     getEvent(eventName, callback) {
         let res = {};
         this.contract.once(eventName, (...data) => {

package/dist/contract/security/index.js

@@ -7,6 +7,25 @@ const Security_json_1 = require("../../abi/securities/Security.json");
 var FUNCTIONS;
 (function (FUNCTIONS) {
     FUNCTIONS["WHITELIST"] = "whiteList";
+    FUNCTIONS["TRANSFER"] = "transfer";
+    FUNCTIONS["APPROVE"] = "approve";
+    FUNCTIONS["TRANSFERFROM"] = "transferFrom";
+    FUNCTIONS["INCREASEALLOWANCE"] = "increaseAllowance";
+    FUNCTIONS["DECREASEALLOWANCE"] = "decreaseAllowance";
+    FUNCTIONS["FREEZE"] = "freeze";
+    FUNCTIONS["UNFREEZE"] = "unfreeze";
+    FUNCTIONS["FROZEN"] = "frozen";
+    FUNCTIONS["BURN"] = "burn";
+    FUNCTIONS["BURNALL"] = "burnAll";
+    FUNCTIONS["SCHEDULE"] = "scheduleSnapshot";
+    FUNCTIONS["RESCHEDULE"] = "rescheduleSnapshot";
+    FUNCTIONS["UNSCHEDULE"] = "unscheduleSnapshot";
+    FUNCTIONS["CREATERESOLUTION"] = "createResolution";
+    FUNCTIONS["COUNTVOTES"] = "countVotes";
+    FUNCTIONS["PAYOUTPRORATA"] = "payoutProrata";
+    FUNCTIONS["PAYOUT"] = "payout";
+    FUNCTIONS["PAUSE"] = "pause";
+    FUNCTIONS["UNPAUSE"] = "unpause";
 })(FUNCTIONS || (FUNCTIONS = {}));
 class Security extends index_1.VerifiedContract {
     constructor(signer, tokenAddress) {
@@ -19,5 +38,96 @@ class Security extends index_1.VerifiedContract {
         await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
         return this.callContract(FUNCTIONS.WHITELIST, _spender, _amount, options);
     }
+    async transfer(_recipient, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _recipient);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.TRANSFER, _recipient, _amount, options);
+    }
+    async approve(_spender, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _spender);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.APPROVE, _spender, _amount, options);
+    }
+    async transferFrom(_spender, _recipient, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _spender);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _recipient);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.TRANSFERFROM, _spender, _recipient, _amount, options);
+    }
+    async increaseAllowance(_spender, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _spender);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.INCREASEALLOWANCE, _spender, _amount, options);
+    }
+    async decreaseAllowance(_spender, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _spender);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.DECREASEALLOWANCE, _spender, _amount, options);
+    }
+    async freeze(_holder, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _holder);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.FREEZE, _holder, _amount, options);
+    }
+    async unfreeze(_holder, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _holder);
+        return this.callContract(FUNCTIONS.UNFREEZE, _holder, options);
+    }
+    async frozen(_account, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _holder);
+        return this.callContract(FUNCTIONS.FROZEN, _account, options);
+    }
+    async burn(_holder, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _holder);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.BURN, _holder, _amount, options);
+    }
+    async burnAll(options) {
+        return this.callContract(FUNCTIONS.BURNALL, options);
+    }
+    async schedule(_time, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        return this.callContract(FUNCTIONS.SCHEDULE, _time, options);
+    }
+    async reschedule(_oldtime, _newtime, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _oldtime);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _newtime);
+        return this.callContract(FUNCTIONS.RESCHEDULE, _oldtime, _newtime, options);
+    }
+    async unschedule(_time, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        return this.callContract(FUNCTIONS.UNSCHEDULE, _time, options);
+    }
+    async createResolution(_time, _votes, _ipfslink, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        await this.validateInput(index_1.DATATYPES.BOOLEAN, _votes);
+        await this.validateInput(index_1.DATATYPES.STRING, _ipfslink);
+        return this.callContract(FUNCTIONS.CREATERESOLUTION, _time, _votes, _ipfslink, options);
+    }
+    async countVotes(_time, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        return this.callContract(FUNCTIONS.COUNTVOTES, _time, options);
+    }
+    async payoutProrata(_time, _wallet, _token, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _wallet);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _token);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.PAYOUTPRORATA, _time, _wallet, _token, _amount, options);
+    }
+    async payout(_time, _holder, _wallet, _token, _amount, options) {
+        await this.validateInput(index_1.DATATYPES.NUMBER, _time);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _holder);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _wallet);
+        await this.validateInput(index_1.DATATYPES.ADDRESS, _token);
+        await this.validateInput(index_1.DATATYPES.NUMBER, _amount);
+        return this.callContract(FUNCTIONS.PAYOUT, _time, _holder, _wallet, _token, _amount, options);
+    }
+    async pause(options) {
+        return this.callContract(FUNCTIONS.PAUSE, options);
+    }
+    async unpause(options) {
+        return this.callContract(FUNCTIONS.UNPAUSE, options);
+    }
 }
 exports.default = Security;

package/dist/contractAddress/index.js

@@ -69,6 +69,40 @@ const contractAddress = {
             'VBINR': ''
         },
     },
+    80001: {
+        'Client': '0x8009B03BbaBD09B9C1EADCaBC7D27197AC251F44',
+        'Factory': '0xaE16E00380450617E7D96Bdee3c242a8a83CF474',
+        'Cash': '0xE6aF6F4d0DD2c4d6F46cdF02be016d7352AF8594',
+        'Bond': '0x035ad7060e366e7d619d3394d667c4F9Fa8fbFFc',
+        'Token': '0x937d8b7A5b36E3573f4B909D742A1afc46998914',
+        'Oracle': '0x3d85758f26866D0D0cd7f3a8f4740cCfE341CBf3',
+        'Rates': '0xFA674a58063bAfD52ce5981DB137B01c2504B312',
+        'Security': '0x2D76FE6DdC229a482eDeb6E86d12c733A05Af55b',
+        'SecuritiesFactory': '0xf1f349C2CBDA5BCAfD7F95b20C812b4A17c9333D',
+        'Vitta': '0x2D5d7F6a1065C1D47c333cacb0ea02f4e25c268C',
+        'Liquidity': '0x9322e3002403C6f13d567d85FF72eC69733a57ab',
+        'Distribution': '0x009B5BAd3C3b8E58f71321e149b22F2Ae080089a',
+        'PrimaryIssuePoolFactory': '',
+        'BalancerPrimaryIssueManager': '',
+        'SecondaryIssuePoolFactory': '',
+        'BalancerSecondaryIssueManager': '',
+        'MarginTradingPoolFactory': '',
+        'BalancerMarginIssueManager': '',
+        'Custody': '0x27006b68b3594EF5Ae04C5457c24F0c7CF1E5553',
+        'Compound': '',
+        'CASH': {
+            'VCUSD': '0x2643ea32A3c231327556739C2a88C1eA943A90A9',
+            'VCEUR': '0x8D7365d51D6e2fF6BffEa00FDacdd96f86d147A0',
+            'VCCHF': '0x1b2f81171300f3DCF70F2A3BC90fc307588212fC',
+            'VCINR': '0x515bC2e51B0824759B3A64fD3659CCC5c8E35D96'
+        },
+        'BOND': {
+            'VBUSD': '0x55E7F13020F85bA8855c0639fD384e2CF319E30A',
+            'VBEUR': '0x00A4eF03Dd625F5778e2a17407952444B3A97008',
+            'VCCHF': '0x0f2570339af7896f78a47730386d51d8CBDD8D0F',
+            'VBINR': '0xFe83AD465cD61FE8f82241b23199043f41079109'
+        },
+    },
     137: {
         'Client': '0x2C5718206b37b8744784ce44f374DE13dd7BC2d1',
         'Factory': '',

package/dist/tests/securityFactoryGasless.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../utils/index");
+const index_2 = require("../wallet/index");
+const index_3 = require("../index");
+const ethers_1 = require("ethers");
+const testSecurityFactoryIssueProduct = async (securityFactoryAddress) => {
+    const INFURA_API_KEY = "95c1322d7c0e44de9ea77cc9eea18534";
+    const SECURITY_HOLDER_MNEMONICS = "correct galaxy various swap chair assault blue improve ivory pear infant oak";
+    const sender = index_2.VerifiedWallet.importWallet(SECURITY_HOLDER_MNEMONICS);
+    const signer = sender.setProvider(index_1.Provider.infuraProvider(80001, INFURA_API_KEY));
+    const securityFactoryContract = new index_3.SecuritiesFactory(signer, securityFactoryAddress);
+    const zeroAddress = "0x0000000000000000000000000000000000000000";
+    const BTCShortBytes = "0x425443";
+    const currency = "0x07865c6E87B9F70255377e024ace6630C1Eaa37F"; //usdc
+    const defaultBytes = "0x4346440000000000000000000000000000000000000000000000000000000000";
+    const indiaBytes = "0x496e646961000000000000000000000000000000000000000000000000000000";
+    const restrictions = [];
+    const abiCoder = ethers_1.ethers.utils.defaultAbiCoder;
+    const encodedArray = abiCoder.encode(["bytes32[]"], [restrictions]);
+    await securityFactoryContract
+        .issueSecurity(zeroAddress, defaultBytes, BTCShortBytes, BTCShortBytes, currency, sender.address, sender.address, encodedArray, indiaBytes, "false")
+        .then(async (res) => {
+        console.log("Security Issued Succesfully with hash: ", res.response.hash);
+        securityFactoryContract.notifySecuritiesAdded(async (evnt) => {
+            const security = evnt.response.result[0];
+            console.log("added security : ", security, "succesfully");
+            if (security) {
+                await securityFactoryContract
+                    .addBalance(security, zeroAddress, sender.address, "1000000000000000000000000")
+                    .then(async (_res) => {
+                    console.log("Security Minted succesfully with hash: ", _res.response.hash);
+                })
+                    .catch((_err) => {
+                    console.error("Mint security failed with error: ", _err);
+                });
+            }
+        });
+    })
+        .catch((err) => {
+        console.error("issueSecurity failed with error: ", err);
+    });
+};
+testSecurityFactoryIssueProduct("0xf1f349C2CBDA5BCAfD7F95b20C812b4A17c9333D");

package/dist/tests/securityGasless.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../utils/index");
+const index_2 = require("../wallet/index");
+const index_3 = require("../index");
+const testSecurityTransfer = async (securityAddress, amount, receiverAddress) => {
+    const INFURA_API_KEY = "95c1322d7c0e44de9ea77cc9eea18534";
+    const SECURITY_HOLDER_MNEMONICS = "correct galaxy various swap chair assault blue improve ivory pear infant oak";
+    const sender = index_2.VerifiedWallet.importWallet(SECURITY_HOLDER_MNEMONICS);
+    const signer = sender.setProvider(index_1.Provider.infuraProvider(80001, INFURA_API_KEY));
+    const securityContract = new index_3.Security(signer, securityAddress);
+    await securityContract
+        .transfer(receiverAddress, amount)
+        .then((res) => {
+        console.log("Transfer succesful with hash: ", res.response.hash);
+    })
+        .catch((err) => {
+        console.log("Transfer failed with error: ", err);
+    });
+};
+// testSecurityTransfer(
+//   "0xd7252bfa14C0Dca5A72d90a28Bb513E0f989Ee1e",
+//   1000000000000000000n,
+//   "0x286a759DACfd0C533B88E42b9e7571040008D778"
+// );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verified-network/verified-sdk",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "description": "An SDK to develop applications on the Verified Network",
   "repository": {
     "type": "git",
@@ -25,18 +25,27 @@
     "build": "tsc",
     "dev": "tsc && npm link",
     "publish": "tsc && npm publish",
-    "test": "mocha"
+    "test": "mocha 'src/test/**/*.ts' --recursive --timeout 300000 -r ts-node/register"
   },
   "bin": {
     "greet": "./bin/index.bin.js"
   },
   "dependencies": {
+    "@biconomy/account": "^3.1.1",
+    "@biconomy/bundler": "^3.1.1",
+    "@biconomy/common": "^3.1.1",
+    "@biconomy/core-types": "^3.1.1",
+    "@biconomy/modules": "^3.1.1",
+    "@biconomy/paymaster": "^3.1.1",
     "ethereumjs-tx": "^2.1.2",
-    "ethers": "^5.0.31"
+    "ethers": "^5.7.2",
+    "web3": "1.10.2"
   },
   "devDependencies": {
+    "@types/mocha": "^10.0.6",
     "dotenv": "^10.0.0",
-    "mocha": "^9.0.1",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.1",
     "typescript": "^4.3.4"
   }
 }

package/tsconfig.json

@@ -47,7 +47,10 @@
     // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
     // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
     // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    "typeRoots": [
+      "./node_modules/@types",
+      "./node_modules/@0x/typescript-typings/types"
+    ],                             /* List of folders to include type definitions from. */
     // "types": [],                                 /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
@@ -63,7 +66,7 @@
     /* Experimental Options */
     // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
-
+    
     /* Advanced Options */
     "skipLibCheck": true,                           /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true,        /* Disallow inconsistently-cased references to the same file. */