@nevermined-io/core-kit 0.0.2-rc19

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

@@ -0,0 +1,276 @@
+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?: {
+            strict?: boolean | undefined;
+            blockHash?: `0x${string}` | 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?: {
+            strict?: boolean | undefined;
+            blockHash?: `0x${string}` | 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]: import("viem").UnionOmit<import("viem").WriteContractParameters<Abi, string, readonly unknown[], import("viem").Chain | undefined, Account | undefined, chainOverride>, "address" | "abi" | "args" | "functionName">[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;
+}[];
+/**
+ * It converts a DID to a Token ID.
+ * This is useful because in the Solidity Smart contracts the tokenId is a uint256.
+ * @param did the unique identifier of the asset
+ * @returns the token id in a bigint format
+ */
+export declare function didToTokenId(did: string): bigint;
+/**
+ * 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">>;
+export declare const WalletUtils: {
+    makeWallet: typeof makeWallet;
+    makeWallets: typeof makeWallets;
+    makeRandomWallet: typeof makeRandomWallet;
+    makeRandomWallets: typeof makeRandomWallets;
+};
+//# sourceMappingURL=BlockchainViemUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlockchainViemUtils.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/BlockchainViemUtils.ts"],"names":[],"mappings":"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"}

package/dist/nevermined/utils/BlockchainViemUtils.js

@@ -0,0 +1,376 @@
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
+import { deserializePermissionAccount, serializePermissionAccount, toPermissionValidator, } from '@zerodev/permissions';
+import { toECDSASigner } from '@zerodev/permissions/signers';
+import { addressToEmptyAccount, createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient, getUserOperationGasPrice, } from '@zerodev/sdk';
+import { KERNEL_V3_1, getEntryPoint } from '@zerodev/sdk/constants';
+import { TransactionReceiptNotFoundError, encodeAbiParameters, getAbiItem, getAddress, getContract, hexToBigInt, http, isAddress, pad, stringToBytes, stringToHex, toBytes, keccak256 as viemKeccak256, } from 'viem';
+import { english, generateMnemonic, generatePrivateKey, mnemonicToAccount, privateKeyToAccount, } from 'viem/accounts';
+import { Instantiable } from '../../Instantiable.abstract.js';
+import { ContractsError } from '../../errors/NeverminedErrors.js';
+import { didZeroX } from '../../utils/ConversionTypeHelpers.js';
+import { getChain } from '../../utils/Network.js';
+import { _sleep } from '../../utils/helpers.js';
+const ENTRY_POINT_VERSION = '0.7';
+/**
+ * Utility class with methods that allow the interaction with the blockchain.
+ * This class uses Viem library to interact with the blockchain.
+ */
+export class BlockchainViemUtils extends Instantiable {
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+    }
+}
+//////////////////////////
+///// UTILITIES //////////
+//////////////////////////
+///// CONTRACTS
+/**
+ * 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 async function getTransactionReceipt({ txHash, iteration = 1, publicClient, }) {
+    if (iteration < 10) {
+        try {
+            return await publicClient.getTransactionReceipt({ hash: txHash });
+        }
+        catch (error) {
+            if (error instanceof TransactionReceiptNotFoundError) {
+                // this.logger.log(
+                //   `Unable to get transaction receipt from hash ${txHash} on iteration ${iteration}. Sleeping and retrying.`,
+                // )
+                await _sleep(150);
+                return getTransactionReceipt({ txHash, iteration: iteration++, publicClient });
+            }
+            else {
+                const errorMessage = `Unknown error getting transaction receipt with hash: ${txHash}. Error: ${error}`;
+                // this.logger.error(errorMessage)
+                throw new ContractsError(errorMessage);
+            }
+        }
+    }
+    else {
+        const errorMessage = `Unable to get transaction receipt with hash: ${txHash} after ${iteration} iterations.`;
+        // this.logger.error(errorMessage)
+        throw new ContractsError(errorMessage);
+    }
+}
+/**
+ * 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 async function getContractInstance(contractAddress, abi, client) {
+    return getContract({
+        abi,
+        address: contractAddress,
+        client: { wallet: client.wallet, public: client.public },
+    });
+}
+///// ABIs
+/**
+ * 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 function searchAbiFunction(abi, funcName, args = []) {
+    const func = getAbiItem({ abi, name: funcName, args });
+    if (!func || func.type !== 'function') {
+        throw new ContractsError(`Function "${funcName}" is not part of contract`);
+    }
+    return func;
+}
+/**
+ * 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 function searchAbiEvent(abi, eventName) {
+    const event = getAbiItem({
+        abi,
+        name: eventName,
+    });
+    if (!event || event.type !== 'event') {
+        throw new ContractsError(`Event "${event}" is not part of contract`);
+    }
+    return event;
+}
+/**
+ * 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 function getSignatureOfFunction(abi, funcName, args = []) {
+    return searchAbiFunction(abi, funcName, args);
+}
+/**
+ * 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 function getInputsOfFunction(abi, funcName, args = []) {
+    return searchAbiFunction(abi, funcName, args).inputs;
+}
+/**
+ * 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 function getInputsOfFunctionFormatted(abi, funcName, args = []) {
+    return searchAbiFunction(abi, funcName, args).inputs.map((input, i) => {
+        return {
+            name: input.name,
+            value: args[i],
+        };
+    });
+}
+//////// UTILS
+/**
+ * It converts a DID to a Token ID.
+ * This is useful because in the Solidity Smart contracts the tokenId is a uint256.
+ * @param did the unique identifier of the asset
+ * @returns the token id in a bigint format
+ */
+export function didToTokenId(did) {
+    return hexToBigInt(didZeroX(did), { size: 32 });
+}
+/**
+ * Given an address it returns that address in checksum format.
+ * @param address the address
+ * @returns the same address in checksum format
+ */
+export function getChecksumAddress(address) {
+    return getAddress(address);
+}
+/**
+ * It checks if the address is a valid address.
+ * @param address the address to check
+ * @returns true of the address is valid
+ */
+export function isValidAddress(address) {
+    return isAddress(address);
+}
+/**
+ * Encodes a UTF-8 string into a byte array.
+
+ * @param message the string to encode
+ * @returns the encoded byte array
+ */
+export function getBytes(message) {
+    return stringToBytes(message);
+}
+/**
+ * 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 function zeroPadValue(value, length) {
+    return pad(value, { size: length });
+}
+/**
+ * Encodes a UTF-8 string into a hex string
+ * @param message the string to encode
+ * @returns the hex string
+ */
+export function encodeBytes32String(message) {
+    return stringToHex(message, { size: 32 });
+}
+////// ACCOUNTS
+/**
+ * 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 function makeWallet(seedphrase, addressIndex = 0) {
+    return mnemonicToAccount(seedphrase, { addressIndex });
+}
+/**
+ * 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 function makeWallets(seedphrase, numAccounts = 10) {
+    const accounts = [];
+    for (let i = 0; i < numAccounts; i++) {
+        accounts.push(makeWallet(seedphrase, i));
+    }
+    return accounts;
+}
+/**
+ * It generates a random account.
+ * @returns a new account
+ */
+export function makeRandomWallet() {
+    const mnemonic = generateMnemonic(english);
+    return makeWallet(mnemonic);
+}
+/**
+ * It generates a list of random accounts
+ * @param numAccounts - the number of accounts to create
+ * @returns the array of accounts
+ */
+export function makeRandomWallets(numAccounts = 10) {
+    const mnemonic = generateMnemonic(english);
+    return makeWallets(mnemonic, numAccounts);
+}
+/////// HASHES
+/**
+ * It hashes a string using keccak256.
+ * @param seed the string to hash
+ * @returns the hash
+ */
+export function keccak256(seed) {
+    return viemKeccak256(toBytes(seed));
+}
+/**
+ * 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 function keccak256WithEncode(types, values) {
+    const encoded = encodeAbiParameters(types, values);
+    return keccak256(encoded);
+}
+/**
+ * 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 function keccak256Packed(types, values) {
+    return keccak256WithEncode(types, values);
+}
+/////// ZERO DEV
+/**
+ * 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 async function createKernelClient(kernelAccount, chainId, zeroDevProjectId, publicClient) {
+    const ZERODEV_RPC = `https://rpc.zerodev.app/api/v3/${zeroDevProjectId}/chain/${chainId}`;
+    return createKernelAccountClient({
+        account: kernelAccount,
+        chain: getChain(chainId),
+        bundlerTransport: http(ZERODEV_RPC),
+        client: publicClient,
+        paymaster: {
+            getPaymasterData: (userOperation) => {
+                const zerodevPaymaster = createZeroDevPaymasterClient({
+                    chain: getChain(chainId),
+                    transport: http(ZERODEV_RPC),
+                });
+                return zerodevPaymaster.sponsorUserOperation({
+                    userOperation,
+                });
+            },
+        },
+        userOperation: {
+            estimateFeesPerGas: async ({ bundlerClient }) => {
+                return getUserOperationGasPrice(bundlerClient);
+            },
+        },
+    });
+}
+export async function createKernelSmartAccount(signer, publicClient) {
+    const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+        signer: signer,
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        kernelVersion: KERNEL_V3_1,
+    });
+    return await createKernelAccount(publicClient, {
+        plugins: {
+            sudo: ecdsaValidator,
+        },
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        kernelVersion: KERNEL_V3_1,
+    });
+}
+export async function getApproval(signer, publicClient, policies) {
+    const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        signer,
+        kernelVersion: KERNEL_V3_1,
+    });
+    const emptyAccount = addressToEmptyAccount(signer.address);
+    const emptySessionKeySigner = await toECDSASigner({ signer: emptyAccount });
+    const permissionPlugin = await toPermissionValidator(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        signer: emptySessionKeySigner,
+        policies: policies,
+        kernelVersion: KERNEL_V3_1,
+    });
+    const sessionKeyAccount = await createKernelAccount(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin,
+        },
+        kernelVersion: KERNEL_V3_1,
+    });
+    return await serializePermissionAccount(sessionKeyAccount);
+}
+export async function useSessionKey(approval, signer, publicClient) {
+    const sessionKeySigner = await toECDSASigner({
+        signer,
+    });
+    const sessionKeyAccount = await deserializePermissionAccount(publicClient, getEntryPoint(ENTRY_POINT_VERSION), KERNEL_V3_1, approval, sessionKeySigner);
+    return sessionKeyAccount;
+}
+export async function createSessionKey(signer, publicClient, policies) {
+    const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        signer,
+        kernelVersion: KERNEL_V3_1,
+    });
+    const sessionPrivateKey = generatePrivateKey();
+    const masterAccount = privateKeyToAccount(sessionPrivateKey);
+    const sessionKeySigner = await toECDSASigner({
+        signer: masterAccount,
+    });
+    const permissionPlugin = await toPermissionValidator(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        signer: sessionKeySigner,
+        policies: policies,
+        kernelVersion: KERNEL_V3_1,
+    });
+    const sessionKeyAccount = await createKernelAccount(publicClient, {
+        entryPoint: getEntryPoint(ENTRY_POINT_VERSION),
+        plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin,
+        },
+        kernelVersion: KERNEL_V3_1,
+    });
+    return serializePermissionAccount(sessionKeyAccount, sessionPrivateKey);
+}
+export async function getSessionKey(serializedSessionKey, publicClient) {
+    const sessionKeyAccount = await deserializePermissionAccount(publicClient, getEntryPoint(ENTRY_POINT_VERSION), KERNEL_V3_1, serializedSessionKey);
+    return sessionKeyAccount;
+}
+export const WalletUtils = {
+    makeWallet,
+    makeWallets,
+    makeRandomWallet,
+    makeRandomWallets,
+};

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

@@ -0,0 +1,27 @@
+import type { Eip712Data } from '@nvm-monorepo/commons';
+import { type JWSHeaderParameters, SignJWT } from 'jose';
+import { type Account } from 'viem';
+import { SmartAccount } from 'viem/account-abstraction';
+import { Instantiable, InstantiableConfig } from '../../Instantiable.abstract.js';
+import { SignatureUtils } from './SignatureUtils.js';
+export declare class EthSignJWT extends SignJWT {
+    protectedHeader: JWSHeaderParameters | undefined;
+    setProtectedHeader(protectedHeader: JWSHeaderParameters): this;
+    ethSign(signatureUtils: SignatureUtils, account: Account | SmartAccount, eip712Data?: Eip712Data): Promise<string>;
+    static signText(text: string | Uint8Array, account: Account): Promise<string | undefined>;
+    private base64url;
+    private concat;
+}
+export declare class JwtUtils extends Instantiable {
+    static CLIENT_ASSERTION_TYPE: string;
+    tokenCache: Map<string, string>;
+    signatureUtils: SignatureUtils;
+    constructor(config: InstantiableConfig);
+    generateCacheKey(...args: string[]): string;
+    accountToJwk(account: Account | SmartAccount): Promise<any>;
+    generateClientAssertion(account: Account | SmartAccount, message?: string): Promise<string>;
+    isTokenValid(token: string): boolean;
+    static createCompressedJwt(token: string): string;
+    static decompressJwt(compressedJwt: string): string;
+}
+//# sourceMappingURL=JwtUtils.d.ts.map