dequanto 0.0.1

package/dist/src/contracts/ContractBase.js

@@ -0,0 +1,139 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractBase = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const memd_1 = __importDefault(require("memd"));
+const ContractReader_1 = require("./ContractReader");
+const ContractWriter_1 = require("./ContractWriter");
+const _contract_1 = require("@dequanto/utils/$contract");
+const ethers_1 = require("ethers");
+const ContractStream_1 = require("./ContractStream");
+const TxTopicInMemoryProvider_1 = require("@dequanto/txs/receipt/TxTopicInMemoryProvider");
+const _class_1 = require("@dequanto/utils/$class");
+class ContractBase {
+    constructor(address, client, explorer) {
+        this.address = address;
+        this.client = client;
+        this.explorer = explorer;
+    }
+    async getStorageAt(position) {
+        let reader = await this.getContractReader();
+        return reader.getStorageAt(this.address, position);
+    }
+    parseInputData(buffer, value) {
+        const inter = new ethers_1.utils.Interface(this.abi);
+        const decodedInput = inter.parseTransaction({
+            data: buffer,
+            value: value,
+        });
+        console.log("decodedInput", decodedInput);
+        return {
+            name: decodedInput.name,
+            args: _contract_1.$contract.normalizeArgs(Array.from(decodedInput.args))
+        };
+    }
+    $config(builderConfig, writerConfig) {
+        let $contract = _class_1.$class.curry(this, {
+            builderConfig: builderConfig,
+            writerConfig: writerConfig,
+        });
+        return $contract;
+    }
+    forBlock(mix) {
+        if (typeof mix === 'undefined' || typeof mix === 'number') {
+            return this.forBlockNumber(mix);
+        }
+        return this.forBlockAt(mix);
+    }
+    forBlockNumber(blockNumber) {
+        let $contract = _class_1.$class.curry(this, {
+            blockNumber: blockNumber,
+            blockDate: null
+        });
+        return $contract;
+    }
+    forBlockAt(date) {
+        let $contract = _class_1.$class.curry(this, {
+            blockNumber: null,
+            blockDate: date
+        });
+        return $contract;
+    }
+    async $read(abi, ...params) {
+        let reader = await this.getContractReader();
+        return reader.readAsync(this.address, abi, ...params);
+    }
+    $on(event, cb) {
+        let stream = this.getContractStream();
+        return stream.on(event, cb);
+    }
+    async $write(abi, eoa, ...params) {
+        let writer = await this.getContractWriter();
+        return writer.writeAsync(eoa, abi, params, {
+            builderConfig: this.builderConfig,
+            writerConfig: this.writerConfig,
+        });
+    }
+    $getAbiItem(type, name) {
+        return this.abi.find(x => x.type === type && x.name === name);
+    }
+    $extractLogs(tx, abiItem) {
+        let logs = _contract_1.$contract.extractLogsForAbi(tx, abiItem);
+        return logs.map(log => {
+            let params = log.arguments.reduce((aggr, arg) => {
+                aggr[arg.name] = arg.value;
+                return aggr;
+            }, {});
+            return {
+                contract: log.contract,
+                arguments: log.arguments,
+                ...params
+            };
+        });
+    }
+    async getContractReader() {
+        let reader = await this.getContractReaderInner();
+        if (this.blockDate != null) {
+            reader.forBlockAt(this.blockDate);
+        }
+        if (this.blockNumber != null) {
+            reader.forBlock(this.blockNumber);
+        }
+        return reader;
+    }
+    async getContractReaderInner() {
+        let reader = a_di_1.default.resolve(ContractReader_1.ContractReader, this.client);
+        return reader;
+    }
+    async getContractWriter() {
+        if (this.abi != null) {
+            let logParser = a_di_1.default.resolve(TxTopicInMemoryProvider_1.TxTopicInMemoryProvider);
+            logParser.register(this.abi);
+        }
+        let writer = a_di_1.default.resolve(ContractWriter_1.ContractWriter, this.address, this.client);
+        return writer;
+    }
+    getContractStream() {
+        let stream = a_di_1.default.resolve(ContractStream_1.ContractStream, this.address, this.abi, this.client);
+        return stream;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], ContractBase.prototype, "getContractReaderInner", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], ContractBase.prototype, "getContractWriter", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], ContractBase.prototype, "getContractStream", null);
+exports.ContractBase = ContractBase;

package/dist/src/contracts/ContractFactory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractFactory = exports.ContractWrapped = void 0;
+const ContractBase_1 = require("./ContractBase");
+class ContractWrapped extends ContractBase_1.ContractBase {
+}
+exports.ContractWrapped = ContractWrapped;
+var ContractFactory;
+(function (ContractFactory) {
+    async function get(client, explorer, contractAddr) {
+        let { abi } = await explorer.getContractAbi(contractAddr);
+        let contract = new ContractWrapped(contractAddr, client, explorer);
+        contract.abi = JSON.parse(abi);
+        return contract;
+    }
+    ContractFactory.get = get;
+})(ContractFactory = exports.ContractFactory || (exports.ContractFactory = {}));

package/dist/src/contracts/ContractProvider.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractProvider = void 0;
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+const a_di_1 = __importDefault(require("a-di"));
+class ContractProvider {
+    constructor(api = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
+        this.api = api;
+    }
+    async getByName(name) {
+        let info = this.api.localDb.find(x => x.name === name);
+        let { abi } = await this.api.getContractAbi(info.address);
+        return {
+            ...info,
+            abi
+        };
+    }
+    async getByAddress(address) {
+        let info = await this.getInfo(address);
+        if (info == null) {
+            throw new Error(`Contract info not found for ${address}`);
+        }
+        let abi = await this.getAbi(info.address);
+        return {
+            ...info,
+            abi
+        };
+    }
+    async getAbi(address) {
+        let { abi } = await this.api.getContractAbi(address);
+        return abi;
+    }
+    async getInfo(q) {
+        return this.api.getContractMeta(q);
+    }
+}
+exports.ContractProvider = ContractProvider;

package/dist/src/contracts/ContractReader.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractReader = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const _abiParser_1 = require("../utils/$abiParser");
+const AbiDeserializer_1 = require("./utils/AbiDeserializer");
+const BlockDateResolver_1 = require("@dequanto/blocks/BlockDateResolver");
+class ContractReader {
+    constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.client = client;
+    }
+    forBlock(blockNumber) {
+        this.blockNumberTask = blockNumber == null
+            ? null
+            : Promise.resolve(blockNumber);
+        return this;
+    }
+    forBlockAt(date) {
+        if (date != null) {
+            let resolver = new BlockDateResolver_1.BlockDateResolver(this.client);
+            this.blockNumberTask = resolver.getBlockNumberFor(date);
+        }
+        else {
+            this.blockNumberTask = null;
+        }
+        return this;
+    }
+    async getStorageAt(address, position) {
+        let blockNumber = void 0;
+        if (this.blockNumberTask != null) {
+            blockNumber = await this.blockNumberTask;
+        }
+        return this.client.getStorageAt(address, position, blockNumber);
+    }
+    async readAsync(address, methodAbi, ...params) {
+        let blockNumber = void 0;
+        if (this.blockNumberTask != null) {
+            blockNumber = await this.blockNumberTask;
+        }
+        let abi;
+        if (typeof methodAbi === 'string') {
+            abi = _abiParser_1.$abiParser.parseMethod(methodAbi);
+        }
+        else {
+            abi = methodAbi;
+        }
+        let method = abi.name;
+        let abiArr = [abi];
+        try {
+            let result = await this.client.readContract({
+                address,
+                abi: abiArr,
+                method: method,
+                arguments: params,
+                blockNumber: blockNumber,
+            });
+            if (result == null) {
+                throw new Error(`Function call returned undefined`);
+            }
+            return AbiDeserializer_1.AbiDeserializer.process(result, abi.outputs);
+        }
+        catch (error) {
+            let args = params.map((x, i) => `[${i}] ${x}`).join('\n');
+            throw new Error(`Contract: ${address} ${methodAbi} with \n${args}\nfailed with ${error.message}`);
+        }
+    }
+    static async read(client, address, methodAbi) {
+        let reader = new ContractReader(client);
+        return reader.readAsync(address, methodAbi);
+    }
+}
+exports.ContractReader = ContractReader;

package/dist/src/contracts/ContractStream.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractStream = void 0;
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const a_di_1 = __importDefault(require("a-di"));
+class ContractStream {
+    constructor(address, abi, client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.address = address;
+        this.abi = abi;
+        this.client = client;
+    }
+    on(event, cb) {
+        let stream = this.client.getEventStream(this.address, this.abi, event);
+        return stream.onData(cb);
+    }
+}
+exports.ContractStream = ContractStream;

package/dist/src/contracts/ContractWriter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractWriter = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const TxWriter_1 = require("@dequanto/txs/TxWriter");
+const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
+const _abiParser_1 = require("../utils/$abiParser");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _class_1 = require("@dequanto/utils/$class");
+class ContractWriter {
+    constructor(address, client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.address = address;
+        this.client = client;
+    }
+    $config(builderConfig, writerConfig) {
+        return _class_1.$class.curry(this, {
+            builderConfig: builderConfig ?? this.builderConfig,
+            writerConfig: writerConfig ?? this.writerConfig,
+        });
+    }
+    async writeAsync(eoa, interfaceAbi, params, configs) {
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, eoa, {
+            to: this.address
+        });
+        let abi = typeof interfaceAbi === 'string'
+            ? _abiParser_1.$abiParser.parseMethod(interfaceAbi)
+            : interfaceAbi;
+        let builderConfig = {
+            ...(this.builderConfig ?? {}),
+            ...(configs?.builderConfig ?? {}),
+        };
+        txBuilder.setConfig(builderConfig);
+        txBuilder.setValue(eoa.value);
+        txBuilder.setInputDataWithABI(abi, ...params);
+        await Promise.all([
+            txBuilder.setGas({
+                price: builderConfig.gasPrice,
+                priceRatio: builderConfig.gasPriceRatio,
+                gasLimit: builderConfig.gasLimit,
+                gasLimitRatio: builderConfig.gasLimitRatio,
+                gasEstimation: builderConfig.gasEstimation,
+                from: builderConfig.from ?? eoa.address,
+                type: builderConfig.type ?? null,
+            }),
+            txBuilder.setNonce({
+                nonce: builderConfig.nonce,
+                noncePending: builderConfig.noncePending,
+            }),
+        ]);
+        console.log(txBuilder.data, eoa, this.address);
+        let writer = TxWriter_1.TxWriter.write(this.client, txBuilder, eoa, configs?.writerConfig ?? this.writerConfig);
+        writer.on('log', message => {
+            _logger_1.$logger.log(`TxContract ${abi.name}; ${message}`);
+        });
+        return writer;
+    }
+}
+exports.ContractWriter = ContractWriter;

package/dist/src/contracts/EthContract.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthContract = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const ContractReader_1 = require("./ContractReader");
+const Contract_1 = require("./Contract");
+const ContractProvider_1 = require("./ContractProvider");
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+class EthContract extends Contract_1.Contract {
+    constructor() {
+        super(...arguments);
+        this.client = this.opts.client ?? a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client);
+        this.explorer = this.opts.explorer ?? a_di_1.default.resolve(Etherscan_1.Etherscan);
+        this.runner = a_di_1.default.resolve(ContractReader_1.ContractReader, this.client);
+        this.provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, this.explorer);
+    }
+    static async create(mix, opts) {
+        let explorer = a_di_1.default.resolve(Etherscan_1.Etherscan);
+        let contract = Contract_1.Contract.create(mix, {
+            Ctor: EthContract,
+            explorer,
+            ...(opts ?? {})
+        });
+        return contract;
+    }
+}
+exports.EthContract = EthContract;

package/dist/src/contracts/TxContract.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxContract = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+const ethers_1 = require("ethers");
+const ContractProvider_1 = require("./ContractProvider");
+class TxContract {
+    constructor(loader = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
+        this.loader = loader;
+        this.provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, this.loader);
+    }
+    async parseTrasaction(tx) {
+        const abi = await this.provider.getAbi(tx.to);
+        const inter = new ethers_1.utils.Interface(abi);
+        const decodedInput = inter.parseTransaction({
+            data: tx.input,
+            value: tx.value,
+        });
+        return decodedInput;
+    }
+    async parseTrasactions(arr) {
+        let mapped = await (0, alot_1.default)(arr).mapAsync(async (tx) => {
+            let details = await this.parseTrasaction(tx);
+            return {
+                ...tx,
+                details: details
+            };
+        }).toArrayAsync();
+        return mapped;
+    }
+}
+exports.TxContract = TxContract;

package/dist/src/contracts/common/ERC20.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * dequanto
+ * name: ERC20Base
+ * platform: polygon
+ * source.abi: ./contracts/abi/erc20.abi.json
+ * output: ./contracts/gen/base/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20 = void 0;
+const ERC20Base_1 = require("@dequanto-contracts/gen/base/ERC20Base");
+class ERC20 extends ERC20Base_1.ERC20Base {
+}
+exports.ERC20 = ERC20;

package/dist/src/contracts/common/ERC20Polygon.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * dequanto
+ * name: ERC20PolygonBase
+ * platform: polygon
+ * source.abi: 0x2791bca1f2de4661ed88a30c99a7a9449aa84174
+ * output: ./contracts/gen/polygon/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20Polygon = void 0;
+const ERC20PolygonBase_1 = require("@dequanto-contracts/gen/polygon/ERC20PolygonBase");
+class ERC20Polygon extends ERC20PolygonBase_1.ERC20PolygonBase {
+}
+exports.ERC20Polygon = ERC20Polygon;

package/dist/src/contracts/common/PoolPair.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolPair = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const ContractBase_1 = require("@dequanto/contracts/ContractBase");
+class PoolPair extends ContractBase_1.ContractBase {
+    constructor(address, client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client), explorer = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
+        super(address, client, explorer);
+        this.address = address;
+        this.client = client;
+        this.explorer = explorer;
+        this.abi = null;
+    }
+    async getReserves() {
+        return await this.$read('getReserves() returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)');
+    }
+}
+exports.PoolPair = PoolPair;

package/dist/src/contracts/utils/AbiDeserializer.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbiDeserializer = void 0;
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const _abiParser_1 = require("../../utils/$abiParser");
+var AbiDeserializer;
+(function (AbiDeserializer) {
+    function process(result, types) {
+        let type = _abiParser_1.$abiParser.getReturnTypeFromTypes(types);
+        if (type === 'array') {
+            return toArray(result, types);
+        }
+        if (type === 'object') {
+            return toObject(result, types);
+        }
+        return toType(result, types[0]);
+    }
+    AbiDeserializer.process = process;
+    function toType(val, type) {
+        if (type == null) {
+            return val;
+        }
+        if (typeof val === 'string') {
+            let tsType = _abiType_1.$abiType.getTsType(type.type);
+            switch (tsType) {
+                case 'bigint':
+                    return BigInt(val);
+                case 'number':
+                    return Number(val);
+            }
+        }
+        if (type.type === 'tuple[]') {
+            if (Array.isArray(val) === false) {
+                throw new Error(`${type.name} tuple[] expects array to deserialize. Got ${val}`);
+            }
+            return val.map(item => {
+                return process(item, type.components);
+            });
+        }
+        return val;
+    }
+    function toArray(value, types) {
+        value = normalizeArray(value);
+        if (Array.isArray(value) === false) {
+            throw new Error(`Array expected of types: ${types.map(x => x.type)}; Got ${value}`);
+        }
+        let out = [];
+        for (let i = 0; i < types.length; i++) {
+            out[i] = toType(value[i], types[i]);
+        }
+        return out;
+    }
+    function toObject(value, types) {
+        let properties = Object.create(null);
+        types.forEach(type => {
+            properties[type.name] = type;
+        });
+        let out = Object.create(null);
+        for (let key in value) {
+            if (/^\d+$/.test(key)) {
+                continue;
+            }
+            let info = properties[key];
+            out[key] = toType(value[key], info);
+        }
+        return out;
+    }
+    // { 0: a, 1: b, 2: c } to array
+    function normalizeArray(val) {
+        if (Array.isArray(val)) {
+            return val;
+        }
+        let out = [];
+        let length = 0;
+        let keys = 0;
+        for (let key in val) {
+            if (/^\d+$/.test(key)) {
+                length++;
+                out[Number(key)] = val[key];
+                continue;
+            }
+            keys++;
+        }
+        if (length === 0 && keys > 0) {
+            return val;
+        }
+        return out;
+    }
+})(AbiDeserializer = exports.AbiDeserializer || (exports.AbiDeserializer = {}));

package/dist/src/contracts/utils/ConvertUtils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertUtils = void 0;
+var ConvertUtils;
+(function (ConvertUtils) {
+    function toWei(amount, dec = 18) {
+        let decimals = BigInt(dec);
+        return BigInt(amount) * 10n ** decimals;
+    }
+    ConvertUtils.toWei = toWei;
+    function toEther(amount, dec = 18) {
+        const round = 100000n;
+        let decimals = BigInt(dec);
+        let val = BigInt(amount) * round / 10n ** decimals;
+        if (val < Number.MAX_SAFE_INTEGER) {
+            return Number(val) / Number(round);
+        }
+        return val / round;
+    }
+    ConvertUtils.toEther = toEther;
+})(ConvertUtils = exports.ConvertUtils || (exports.ConvertUtils = {}));

package/dist/src/contracts/utils/InputDataUtils.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputDataUtils = void 0;
+const ethers_1 = require("ethers");
+const _abiParser_1 = require("../../utils/$abiParser");
+var InputDataUtils;
+(function (InputDataUtils) {
+    function split(inputData) {
+        let str = inputData.substring(2);
+        let methodName = str.substring(0, 8);
+        let params = str.substring(8);
+        let args = [];
+        while (params.length > 0) {
+            args.push(params.substring(0, 64));
+            params = params.substring(64);
+        }
+        return {
+            method: methodName,
+            args
+        };
+    }
+    InputDataUtils.split = split;
+    function decode(inputs, bytes) {
+        let types = inputs.map(x => x.type);
+        let args = ethers_1.utils.defaultAbiCoder.decode(types, bytes);
+        let arr = Array.from(args);
+        return normalizeArgs(arr);
+    }
+    InputDataUtils.decode = decode;
+    function decodeParamsWithABI(abi, bytes) {
+        if (typeof abi === 'string') {
+            abi = _abiParser_1.$abiParser.parseMethod(abi);
+        }
+        let inputs = abi.inputs;
+        let types = inputs.map(x => x.type);
+        let args = ethers_1.utils.defaultAbiCoder.decode(types, bytes);
+        let arr = Array.from(args);
+        return normalizeArgs(arr);
+    }
+    InputDataUtils.decodeParamsWithABI = decodeParamsWithABI;
+    function decodeWithABI(IFunctionABI, ...params) {
+        let iface = new ethers_1.ethers.utils.Interface([IFunctionABI]);
+        let methodName;
+        if (typeof IFunctionABI === 'string') {
+            methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;
+        }
+        else {
+            methodName = IFunctionABI.name;
+        }
+        if (methodName == null) {
+            throw new Error(`Invalid method in ${IFunctionABI}. Expects "function foo(...)"`);
+        }
+        return iface.encodeFunctionData(methodName, params);
+    }
+    InputDataUtils.decodeWithABI = decodeWithABI;
+    /**
+     * function work(uint256 id, address worker, uint256 principalAmount, uint256 loan, uint256 maxReturn, bytes calldata data)
+     */
+    function encodeWithABI(IFunctionABI, ...params) {
+        let iface = new ethers_1.ethers.utils.Interface([IFunctionABI]);
+        let methodName;
+        if (typeof IFunctionABI === 'string') {
+            methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;
+        }
+        else {
+            methodName = IFunctionABI.name;
+        }
+        if (methodName == null) {
+            throw new Error(`Invalid method in ${IFunctionABI}. Expects "function foo(...)"`);
+        }
+        return iface.encodeFunctionData(methodName, params);
+    }
+    InputDataUtils.encodeWithABI = encodeWithABI;
+    function encodeWithTypes(client, types, paramaters) {
+        return client.encodeParameters(types, paramaters);
+    }
+    InputDataUtils.encodeWithTypes = encodeWithTypes;
+    function normalizeArgs(args) {
+        return args.map(val => {
+            if (val?._isBigNumber) {
+                return BigInt(val.toString());
+            }
+            return val;
+        });
+    }
+    InputDataUtils.normalizeArgs = normalizeArgs;
+})(InputDataUtils = exports.InputDataUtils || (exports.InputDataUtils = {}));