@nevermined-io/core-kit 0.1.4 → 0.1.5

package/dist/nevermined/api/PaymentsApi.js

@@ -0,0 +1,179 @@
+import { PlanTransactionPaymentType } from '@nvm-monorepo/commons';
+import { isAddress, parseAbi, zeroAddress } from 'viem';
+import { NotEnoughBalance } from '../../errors/NeverminedErrors.js';
+import { Instantiable } from '../../Instantiable.abstract.js';
+const TOKEN_BALANCE_ABI = parseAbi(['function balanceOf(address) view returns (uint256)']);
+const GET_FEE_RATES_ABI = parseAbi([
+    'function getFeeRates() view returns (uint256, uint256, uint256)',
+]);
+export class PaymentsApi extends Instantiable {
+    /**
+     * Creates a new PaymentsApi
+     * @param config - Configuration of the Nevermined instance
+     * @returns {@link PaymentsApi}
+     */
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+    }
+    async getERC20Balance(userAddress, tokenAddress) {
+        try {
+            return this.client.public.readContract({
+                address: tokenAddress,
+                abi: TOKEN_BALANCE_ABI,
+                functionName: 'balanceOf',
+                args: [userAddress],
+            });
+        }
+        catch (error) {
+            this.logger.debug(`Error fetching ERC20 balance for ${userAddress} in ${tokenAddress}: ${error}`);
+        }
+        return 0n;
+    }
+    async getPlanFees(planId) {
+        try {
+            const plan = await this.nevermined.contracts.assetRegistry.getPlan(planId);
+            let feeControllerAddress;
+            if (plan.price.feeController &&
+                isAddress(plan.price.feeController) &&
+                plan.price.feeController !== zeroAddress) {
+                feeControllerAddress = plan.price.feeController;
+            }
+            else {
+                feeControllerAddress = await this.nevermined.contracts.nvmConfig.getDefaultFeeController();
+            }
+            const result = await this.client.public.readContract({
+                address: feeControllerAddress,
+                abi: GET_FEE_RATES_ABI,
+                functionName: 'getFeeRates',
+                args: [],
+            });
+            const feeReceiver = await this.nevermined.contracts.nvmConfig.getFeeReceiver();
+            let amountToReward = 0n;
+            plan.price.receivers.map((r, i) => {
+                if (r.toLowerCase() !== feeReceiver.toLowerCase()) {
+                    amountToReward += plan.price.amounts[i];
+                }
+            });
+            const totalAmount = plan.price.amounts.reduce((a, b) => a + b, 0n);
+            return {
+                cryptoFeeRate: result[0],
+                fiatFeeRate: result[1],
+                feeDenominator: result[2],
+                ownerAmount: amountToReward,
+                totalAmount,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error fetching plan fee for planId ${planId}: ${String(error)}`);
+            throw error;
+        }
+    }
+    async orderFiatPayment(planId, planReceiver, from, numberOfPurchases = 1n) {
+        const plan = await this.nevermined.contracts.assetRegistry.getPlan(planId);
+        const totalAmount = plan.price.amounts.reduce((a, b) => a + b, 0n);
+        this.logger.info(`Ordering fiat payment for planId ${planId} to ${planReceiver} from account ${from.address} `);
+        const txHash = await this.nevermined.contracts.fiatPaymentTemplate.order(planId, planReceiver, from, numberOfPurchases);
+        const txReceipt = await this.nevermined.contracts.assetRegistry.getTransactionReceipt(txHash);
+        return {
+            txHash: txReceipt.transactionHash,
+            planId,
+            planReceiver: from.address,
+            totalAmount,
+            numCredits: plan.credits.amount,
+            paymentMethod: PlanTransactionPaymentType.Fiat,
+            currency: 'USD',
+        };
+    }
+    async orderCryptoPlan(planId, plan, from, planReceiver, numberOfPurchases = 1n) {
+        if (plan.price.templateAddress === this.nevermined.contracts.payAsYouGoTemplate.address) {
+            this.logger.debug(`Setting up Pay-As-You-Go order...`);
+            return this._orderCryptoPlan(planId, plan, from, 'payAsYouGo');
+        }
+        else {
+            this.logger.debug(`Setting up Fixed Payment order...`);
+            return this._orderCryptoPlan(planId, plan, from, 'fixed', planReceiver, numberOfPurchases);
+        }
+    }
+    async _orderCryptoPlan(planId, plan, from, planType, planReceiver, numberOfPurchases = 1n) {
+        try {
+            const tokenAddress = plan.price.tokenAddress;
+            const totalAmount = plan.price.amounts.reduce((a, b) => a + b, 0n) * numberOfPurchases;
+            this.logger.debug(`Ordering ${tokenAddress} ${totalAmount}`);
+            let txHash;
+            if (tokenAddress && tokenAddress !== zeroAddress) {
+                this.logger.debug(`Processing ERC20 payment...`);
+                // ERC20 token payment
+                if (totalAmount > 0n) {
+                    const erc20Balance = await this.getERC20Balance(from.address, tokenAddress);
+                    this.logger.debug(`ERC20 balance for ${from.address} in ${tokenAddress}: balance = ${erc20Balance} - total amount = ${totalAmount}`);
+                    if (erc20Balance < totalAmount) {
+                        throw new NotEnoughBalance(`Insufficient balance (${erc20Balance} < ${totalAmount}) for ERC20 ${tokenAddress}`);
+                    }
+                    if (planType === 'payAsYouGo') {
+                        txHash = await this.nevermined.contracts.payAsYouGoTemplate.orderWithApprovals(planId, totalAmount, tokenAddress, from);
+                    }
+                    else {
+                        txHash = await this.nevermined.contracts.fixedPaymentTemplate.orderWithApprovals(planId, totalAmount, tokenAddress, from, planReceiver || from.address, numberOfPurchases);
+                    }
+                    this.logger.debug(`Token approved + Agreement Created: ${txHash}`);
+                }
+                else {
+                    if (planType === 'payAsYouGo') {
+                        txHash = await this.nevermined.contracts.payAsYouGoTemplate.order(planId, from);
+                    }
+                    else {
+                        txHash = await this.nevermined.contracts.fixedPaymentTemplate.order(planId, from, planReceiver || from.address);
+                    }
+                }
+                if (!txHash) {
+                    this.logger.error('Error in PaymentsApi order method: txHash not defined');
+                    throw new Error('txHash not defined');
+                }
+                const txReceipt = await this.nevermined.contracts.assetRegistry.getTransactionReceipt(txHash);
+                return {
+                    txHash: txReceipt.transactionHash,
+                    planId,
+                    planReceiver: from.address,
+                    totalAmount,
+                    numCredits: plan.credits.amount * numberOfPurchases,
+                    paymentMethod: PlanTransactionPaymentType.Crypto,
+                    currency: 'USDC',
+                    tokenAddress,
+                };
+            }
+            else {
+                // Native token payment
+                const nativeTokenBalance = await this.client.public.getBalance({ address: from.address });
+                if (nativeTokenBalance < totalAmount) {
+                    throw new NotEnoughBalance(`Insufficient balance (${nativeTokenBalance} < ${totalAmount}) for native token payment`);
+                }
+                if (planType === 'payAsYouGo') {
+                    txHash = await this.nevermined.contracts.payAsYouGoTemplate.order(planId, from, {
+                        value: totalAmount,
+                    });
+                }
+                else {
+                    txHash = await this.nevermined.contracts.fixedPaymentTemplate.order(planId, from, planReceiver || from.address, numberOfPurchases, {
+                        value: totalAmount,
+                    });
+                }
+                const txReceipt = await this.nevermined.contracts.assetRegistry.getTransactionReceipt(txHash);
+                return {
+                    txHash: txReceipt.transactionHash,
+                    planId,
+                    planReceiver: from.address,
+                    totalAmount,
+                    numCredits: plan.credits.amount * numberOfPurchases,
+                    paymentMethod: PlanTransactionPaymentType.Crypto,
+                    currency: 'Native',
+                    tokenAddress: zeroAddress,
+                };
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in PaymentsApi order method: ${String(error)}`);
+            throw error;
+        }
+    }
+}

package/dist/nevermined/api/ServicesApi.d.ts

@@ -0,0 +1,23 @@
+import { Instantiable, InstantiableConfig } from '../../Instantiable.abstract.js';
+import { Api } from '../../services/Api.js';
+import { Profiles } from '../../services/Profiles.js';
+/**
+ * Utils internal submodule of Nevermined.
+ */
+export declare class ServicesApi extends Instantiable {
+    /**
+     * Nevermined Node Service
+     */
+    api: Api;
+    /**
+     * Profiles instance
+     */
+    profiles: Profiles;
+    /**
+     * Creates a new ServicesApi
+     * @param config - Configuration of the Nevermined instance
+     * @returns {@link ServicesApi}
+     */
+    constructor(config: InstantiableConfig);
+}
+//# sourceMappingURL=ServicesApi.d.ts.map

package/dist/nevermined/api/ServicesApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServicesApi.d.ts","sourceRoot":"","sources":["../../../src/nevermined/api/ServicesApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACjF,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAErD;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C;;OAEG;IACI,GAAG,EAAE,GAAG,CAAA;IAEf;;OAEG;IACI,QAAQ,EAAE,QAAQ,CAAA;IAEzB;;;;OAIG;gBACS,MAAM,EAAE,kBAAkB;CAOvC"}

package/dist/nevermined/api/ServicesApi.js

@@ -0,0 +1,27 @@
+import { Instantiable } from '../../Instantiable.abstract.js';
+import { Api } from '../../services/Api.js';
+import { Profiles } from '../../services/Profiles.js';
+/**
+ * Utils internal submodule of Nevermined.
+ */
+export class ServicesApi extends Instantiable {
+    /**
+     * Nevermined Node Service
+     */
+    api;
+    /**
+     * Profiles instance
+     */
+    profiles;
+    /**
+     * Creates a new ServicesApi
+     * @param config - Configuration of the Nevermined instance
+     * @returns {@link ServicesApi}
+     */
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+        this.api = new Api(config);
+        this.profiles = new Profiles(config);
+    }
+}

package/dist/nevermined/api/UtilsApi.d.ts

@@ -0,0 +1,28 @@
+import { Instantiable, InstantiableConfig } from '../../Instantiable.abstract.js';
+import { JwtUtils } from '../utils/JwtUtils.js';
+import { SignatureUtils } from '../utils/SignatureUtils.js';
+import { WebServiceConnector } from '../utils/WebServiceConnector.js';
+/**
+ * Nevermined Utils API
+ */
+export declare class UtilsApi extends Instantiable {
+    /**
+     * Fetch utils.
+     */
+    fetch: WebServiceConnector;
+    /**
+     * Jwt utils.
+     */
+    jwt: JwtUtils;
+    /**
+     * Signature utils.
+     */
+    signature: SignatureUtils;
+    /**
+     * Creates a new AssetsApi
+     * @param config - Configuration of the Nevermined instance
+     * @returns {@link UtilsApi}
+     */
+    constructor(config: InstantiableConfig);
+}
+//# sourceMappingURL=UtilsApi.d.ts.map

package/dist/nevermined/api/UtilsApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UtilsApi.d.ts","sourceRoot":"","sources":["../../../src/nevermined/api/UtilsApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAA;AAErE;;GAEG;AACH,qBAAa,QAAS,SAAQ,YAAY;IACxC;;OAEG;IACI,KAAK,EAAE,mBAAmB,CAAA;IAEjC;;OAEG;IACI,GAAG,EAAE,QAAQ,CAAA;IAEpB;;OAEG;IACI,SAAS,EAAE,cAAc,CAAA;IAEhC;;;;OAIG;gBACS,MAAM,EAAE,kBAAkB;CAQvC"}

package/dist/nevermined/api/UtilsApi.js

@@ -0,0 +1,33 @@
+import { Instantiable } from '../../Instantiable.abstract.js';
+import { JwtUtils } from '../utils/JwtUtils.js';
+import { SignatureUtils } from '../utils/SignatureUtils.js';
+import { WebServiceConnector } from '../utils/WebServiceConnector.js';
+/**
+ * Nevermined Utils API
+ */
+export class UtilsApi extends Instantiable {
+    /**
+     * Fetch utils.
+     */
+    fetch;
+    /**
+     * Jwt utils.
+     */
+    jwt;
+    /**
+     * Signature utils.
+     */
+    signature;
+    /**
+     * Creates a new AssetsApi
+     * @param config - Configuration of the Nevermined instance
+     * @returns {@link UtilsApi}
+     */
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+        this.fetch = new WebServiceConnector(config);
+        this.jwt = new JwtUtils(config);
+        this.signature = new SignatureUtils(config);
+    }
+}

package/dist/nevermined/index.d.ts

@@ -0,0 +1,3 @@
+export { Nevermined } from './Nevermined.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/nevermined/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nevermined/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,cAAc,kBAAkB,CAAA"}

package/dist/nevermined/index.js

@@ -0,0 +1,2 @@
+export { Nevermined } from './Nevermined.js';
+export * from './utils/index.js';

package/dist/nevermined/utils/AgentUtils.d.ts

@@ -0,0 +1,8 @@
+import { ApiEndpoint } from '@nvm-monorepo/commons';
+export declare function isEndpointRequestedIncluded(requestEndpoint: string, requestedHTTPVerb: string, agentEndpoints: ApiEndpoint[], agentOpenEndpoints?: string[]): {
+    matches: boolean;
+    urlMatching?: URL;
+    verbMatching?: string;
+};
+export declare function areUrlsEqualIgnoringQuery(url1: URL, url2: URL): boolean;
+//# sourceMappingURL=AgentUtils.d.ts.map

package/dist/nevermined/utils/AgentUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentUtils.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/AgentUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGnD,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,MAAM,EACvB,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,WAAW,EAAE,EAC7B,kBAAkB,GAAE,MAAM,EAAO,GAChC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,GAAG,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAkDhE;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAOvE"}

package/dist/nevermined/utils/AgentUtils.js

@@ -0,0 +1,56 @@
+import { match } from 'path-to-regexp';
+export function isEndpointRequestedIncluded(requestEndpoint, requestedHTTPVerb, agentEndpoints, agentOpenEndpoints = []) {
+    try {
+        let matches = false;
+        requestedHTTPVerb = requestedHTTPVerb.toLowerCase();
+        let urlMatching, verbMatching;
+        const requestedUrl = new URL(requestEndpoint);
+        // Is the endpoint an open endpoint?
+        for (const openEndpoint of agentOpenEndpoints) {
+            try {
+                const agentUrl = new URL(openEndpoint);
+                if (areUrlsEqualIgnoringQuery(agentUrl, requestedUrl)) {
+                    urlMatching = new URL(openEndpoint);
+                    matches = true;
+                    break;
+                }
+            }
+            catch (error) {
+                // Skip invalid URLs and continue with next endpoint
+                continue;
+            }
+        }
+        if (matches)
+            return { matches: true, urlMatching };
+        // check if the endpoint/verb is part of the list
+        for (const ep of agentEndpoints) {
+            try {
+                const [verb, url] = Object.entries(ep)[0];
+                const _url = new URL(url);
+                const fn = match(_url.pathname, { decode: decodeURIComponent });
+                if (fn(requestedUrl.pathname) &&
+                    (verb.toLowerCase() === requestedHTTPVerb || verb === '*')) {
+                    matches = true;
+                    urlMatching = _url;
+                    verbMatching = verb;
+                    break;
+                }
+            }
+            catch (error) {
+                // Skip invalid patterns and continue with next endpoint
+                continue;
+            }
+        }
+        return { matches, urlMatching, verbMatching };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (error) {
+        return { matches: false };
+    }
+}
+export function areUrlsEqualIgnoringQuery(url1, url2) {
+    return (url1.protocol === url2.protocol &&
+        url1.hostname === url2.hostname &&
+        url1.port === url2.port &&
+        url1.pathname === url2.pathname);
+}

package/dist/nevermined/utils/BlockchainViemUtils.d.ts

@@ -0,0 +1,280 @@
+import { KernelAccountClient } from '@zerodev/sdk';
+import { Address, type Abi, type AbiEvent, type AbiFunction, type Account, type PublicClient, type TransactionReceipt } from 'viem';
+import { SmartAccount } from 'viem/account-abstraction';
+import { Instantiable, InstantiableConfig, Web3Clients } from '../../Instantiable.abstract.js';
+import { Signer } from '@zerodev/sdk/types';
+/**
+ * Utility class with methods that allow the interaction with the blockchain.
+ * This class uses Viem library to interact with the blockchain.
+ */
+export declare class BlockchainViemUtils extends Instantiable {
+    constructor(config: InstantiableConfig);
+}
+/**
+ * Given a transaction hash, it returns the transaction receipt.
+ * If this function is called before the transaction is mined, it will iterate a few times in order to wait for the transaction to be mined.
+ * @param txHash - the transaction hash
+ * @param iteration - the iteration number
+ * @returns the transaction receipt
+ */
+export declare function getTransactionReceipt({ txHash, iteration, publicClient, }: {
+    txHash: `0x${string}`;
+    iteration?: number;
+    publicClient: PublicClient;
+}): Promise<TransactionReceipt>;
+/**
+ * Given an already deployed contract address and the ABI, it returns the contract instance.
+ *
+ * @param contractAddress - the contract address
+ * @param abi - the contract artifact
+ * @param client - the client to interact with the blockchain
+ * @returns a contract instance
+ */
+export declare function getContractInstance(contractAddress: string, abi: Abi, client: Web3Clients): Promise<{
+    read: {
+        [x: string]: (...parameters: [options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<Abi, string, readonly unknown[]>, "address" | "abi" | "args" | "functionName">> | undefined] | [args: readonly unknown[], options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<Abi, string, readonly unknown[]>, "address" | "abi" | "args" | "functionName">> | undefined]) => Promise<import("viem").ReadContractReturnType>;
+    };
+    estimateGas: {
+        [x: string]: (...parameters: [options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "args" | "functionName">>] | [args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "args" | "functionName">>]) => Promise<import("viem").EstimateContractGasReturnType>;
+    } & {
+        [x: string]: (...parameters: [options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "args" | "functionName">>] | [args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "args" | "functionName">>]) => Promise<import("viem").EstimateContractGasReturnType>;
+    };
+    simulate: {
+        [x: string]: <chainOverride extends import("viem").Chain | undefined = undefined, accountOverride extends Account | Address | undefined = undefined>(...parameters: [options?: Omit<import("viem").SimulateContractParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined, chainOverride, accountOverride>, "address" | "abi" | "args" | "functionName"> | undefined] | [args: readonly unknown[], options?: Omit<import("viem").SimulateContractParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined, chainOverride, accountOverride>, "address" | "abi" | "args" | "functionName"> | undefined]) => Promise<import("viem").SimulateContractReturnType>;
+    };
+    createEventFilter: {
+        [x: string]: <strict extends boolean | undefined = undefined>(...parameters: [options?: ({
+            fromBlock?: bigint | import("viem").BlockTag | undefined;
+            toBlock?: bigint | import("viem").BlockTag | undefined;
+        } & {
+            strict?: strict | undefined;
+        }) | undefined] | [args: readonly unknown[] | {
+            [x: string]: unknown;
+            address?: undefined;
+            abi?: undefined;
+            eventName?: undefined;
+            fromBlock?: undefined;
+            strict?: undefined;
+            toBlock?: undefined;
+            args?: undefined;
+        }, options?: ({
+            fromBlock?: bigint | import("viem").BlockTag | undefined;
+            toBlock?: bigint | import("viem").BlockTag | undefined;
+        } & {
+            strict?: strict | undefined;
+        }) | undefined]) => Promise<import("viem").CreateContractEventFilterReturnType>;
+    };
+    getEvents: {
+        [x: string]: (...parameters: [options?: {
+            blockHash?: `0x${string}` | undefined;
+            strict?: boolean | undefined;
+            fromBlock?: bigint | import("viem").BlockTag | undefined;
+            toBlock?: bigint | import("viem").BlockTag | undefined;
+        } | undefined] | [args?: readonly unknown[] | {
+            [x: string]: unknown;
+            address?: undefined;
+            abi?: undefined;
+            args?: undefined;
+            eventName?: undefined;
+            fromBlock?: undefined;
+            onError?: undefined;
+            onLogs?: undefined;
+            strict?: undefined;
+            poll?: undefined;
+            batch?: undefined;
+            pollingInterval?: undefined;
+        } | undefined, options?: {
+            blockHash?: `0x${string}` | undefined;
+            strict?: boolean | undefined;
+            fromBlock?: bigint | import("viem").BlockTag | undefined;
+            toBlock?: bigint | import("viem").BlockTag | undefined;
+        } | undefined]) => Promise<import("viem").GetContractEventsReturnType<Abi, string>>;
+    };
+    watchEvent: {
+        [x: string]: (...parameters: [options?: {
+            batch?: boolean | undefined | undefined;
+            pollingInterval?: number | undefined | undefined;
+            strict?: boolean | undefined;
+            onError?: ((error: Error) => void) | undefined | undefined;
+            fromBlock?: bigint | undefined;
+            onLogs: import("viem").WatchContractEventOnLogsFn<Abi, string, undefined>;
+            poll?: true | undefined | undefined;
+        } | undefined] | [args: readonly unknown[] | {
+            [x: string]: unknown;
+            address?: undefined;
+            abi?: undefined;
+            args?: undefined;
+            eventName?: undefined;
+            fromBlock?: undefined;
+            onError?: undefined;
+            onLogs?: undefined;
+            strict?: undefined;
+            poll?: undefined;
+            batch?: undefined;
+            pollingInterval?: undefined;
+        }, options?: {
+            batch?: boolean | undefined | undefined;
+            pollingInterval?: number | undefined | undefined;
+            strict?: boolean | undefined;
+            onError?: ((error: Error) => void) | undefined | undefined;
+            fromBlock?: bigint | undefined;
+            onLogs: import("viem").WatchContractEventOnLogsFn<Abi, string, undefined>;
+            poll?: true | undefined | undefined;
+        } | undefined]) => import("viem").WatchContractEventReturnType;
+    };
+    write: {
+        [x: string]: <chainOverride extends import("viem").Chain | undefined, options extends import("viem").UnionOmit<import("viem").WriteContractParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined, Account | undefined, chainOverride>, "address" | "abi" | "args" | "functionName"> extends infer T ? { [K in keyof T]: T[K]; } : never, Rest extends unknown[] = [options: options]>(...parameters: Rest | [args: readonly unknown[], ...parameters: Rest]) => Promise<import("viem").WriteContractReturnType>;
+    };
+    address: `0x${string}`;
+    abi: Abi;
+}>;
+/**
+ * It searchs an ABI function in the ABI.
+ * @param abi the ABI of the contract
+ * @param funcName the function name
+ * @param args the args of the function
+ * @returns the function found
+ */
+export declare function searchAbiFunction(abi: Abi, funcName: string, args?: any[]): AbiFunction;
+/**
+ * It searchs an ABI event in the ABI.
+ * @param abi the ABI of the contract
+ * @param funcName the event name
+ * @returns the event found
+ */
+export declare function searchAbiEvent(abi: Abi, eventName: string): AbiEvent;
+/**
+ * It searchs an ABI function in the ABI.
+ * @param abi the ABI of the contract
+ * @param funcName the function name
+ * @param args the args of the function
+ * @returns the function found
+ */
+export declare function getSignatureOfFunction(abi: Abi, funcName: string, args?: any[]): AbiFunction;
+/**
+ * It searchs an ABI function in the ABI and return the inputs.
+ * @param abi the ABI of the contract
+ * @param funcName the function name
+ * @param args the args of the function
+ * @returns the function found
+ */
+export declare function getInputsOfFunction(abi: Abi, funcName: string, args?: any[]): readonly import("viem").AbiParameter[];
+/**
+ * It searchs an ABI function in the ABI and return the inputs formatted.
+ * @param abi the ABI of the contract
+ * @param funcName the function name
+ * @param args the args of the function
+ * @returns the function found
+ */
+export declare function getInputsOfFunctionFormatted(abi: Abi, funcName: string, args?: any[]): {
+    name: string | undefined;
+    value: any;
+}[];
+/**
+ * Given an address it returns that address in checksum format.
+ * @param address the address
+ * @returns the same address in checksum format
+ */
+export declare function getChecksumAddress(address: string): string;
+/**
+ * It checks if the address is a valid address.
+ * @param address the address to check
+ * @returns true of the address is valid
+ */
+export declare function isValidAddress(address: string): boolean;
+/**
+ * Encodes a UTF-8 string into a byte array.
+
+ * @param message the string to encode
+ * @returns the encoded byte array
+ */
+export declare function getBytes(message: string): Uint8Array;
+/**
+ * It pads a value with zeros.
+ * @param value the value to pad
+ * @param length the expected longitutde of the value
+ * @returns the padded value
+ */
+export declare function zeroPadValue(value: `0x${string}` | Uint8Array, length: number): string;
+/**
+ * Encodes a UTF-8 string into a hex string
+ * @param message the string to encode
+ * @returns the hex string
+ */
+export declare function encodeBytes32String(message: string): `0x${string}`;
+/**
+ * Given a seedphrase, it returns an account.
+ * @param seedphrase - the seedphrase to be used to generate the account
+ * @param addressIndex - the address index
+ * @returns an account
+ */
+export declare function makeWallet(seedphrase: string, addressIndex?: number): Account;
+/**
+ * Given a seedphrase generates multiple accounts
+ * @param seedphrase - the seedphrase to be used to generate the account
+ * @param numAccounts - the number of accounts to create
+ * @returns the array of accounts
+ */
+export declare function makeWallets(seedphrase: string, numAccounts?: number): Account[];
+/**
+ * It generates a random account.
+ * @returns a new account
+ */
+export declare function makeRandomWallet(): Account;
+/**
+ * It generates a list of random accounts
+ * @param numAccounts - the number of accounts to create
+ * @returns the array of accounts
+ */
+export declare function makeRandomWallets(numAccounts?: number): Account[];
+/**
+ * It hashes a string using keccak256.
+ * @param seed the string to hash
+ * @returns the hash
+ */
+export declare function keccak256(seed: string): string;
+/**
+ * It encodes and hashes a list of primitive values into an ABI-encoded hex value.
+ * @param types the types of the values
+ * @param values the values to encode
+ * @returns the hash
+ */
+export declare function keccak256WithEncode(types: any[], values: any[]): string;
+/**
+ * It encodes and hashes a list of primitive values into an ABI-encoded hex value.
+ * @param types the types of the values
+ * @param values the values to encode
+ * @returns the hash
+ */
+export declare function keccak256Packed(types: any[], values: any[]): string;
+/**
+ * It creates a ZeroDev Kernel client.
+ * @param signer the signer account
+ * @param chainId the chain id
+ * @param zeroDevProjectId the zero dev project id, you can get it from the ZeroDev dashboard
+ * @returns the kernel client
+ */
+export declare function createKernelClient(kernelAccount: SmartAccount, chainId: number, zeroDevProjectId: string, publicClient: any): Promise<KernelAccountClient>;
+export declare function createKernelSmartAccount(signer: Signer, publicClient: PublicClient): Promise<SmartAccount>;
+export declare function getApproval(signer: Signer, publicClient: any, policies: any[]): Promise<string>;
+export declare function useSessionKey(approval: string, signer: Signer, publicClient: any): Promise<import("@zerodev/sdk").CreateKernelAccountReturnType<"0.7">>;
+export declare function createSessionKey(signer: Signer, publicClient: any, policies: any[]): Promise<string>;
+export declare function getSessionKey(serializedSessionKey: string, publicClient: any): Promise<import("@zerodev/sdk").CreateKernelAccountReturnType<"0.7">>;
+/**
+ * Creates a delegated session key for an existing kernel account.
+ * The resulting serialized session key can be deserialized into a SmartAccount
+ * that shares the same address as the kernel account but enforces the given policies.
+ *
+ * @param kernelAccount The existing SmartAccount (kernel) to delegate from
+ * @param publicClient Viem PublicClient instance
+ * @param policies Array of policies to enforce for this session key
+ * @returns Serialized session key string
+ */
+export declare function createDelegatedSessionKeyFromKernel(kernelAccount: SmartAccount, publicClient: PublicClient, policies: any[]): Promise<string>;
+export declare const WalletUtils: {
+    makeWallet: typeof makeWallet;
+    makeWallets: typeof makeWallets;
+    makeRandomWallet: typeof makeRandomWallet;
+    makeRandomWallets: typeof makeRandomWallets;
+};
+//# sourceMappingURL=BlockchainViemUtils.d.ts.map