@nevermined-io/core-kit 0.1.3 → 0.1.5

package/dist/contracts/ContractBase.js

@@ -0,0 +1,519 @@
+import { createKernelAccountClient, createZeroDevPaymasterClient, getUserOperationGasPrice, } from '@zerodev/sdk';
+import { BaseError, ContractFunctionRevertedError, encodeFunctionData, getContract, http, parseAbi, parseEventLogs, } from 'viem';
+import { ContractsError, ContractSimulationError } from '../errors/index.js';
+import { Instantiable } from '../Instantiable.abstract.js';
+import { getInputsOfFunctionFormatted, getTransactionReceipt } from '../nevermined/index.js';
+import { getChain } from '../utils/Network.js';
+export class ContractBase extends Instantiable {
+    contractName;
+    contract;
+    address;
+    constructor(contractName, address) {
+        super();
+        this.contractName = contractName;
+        this.address = address;
+    }
+    async init(config, contractConfig) {
+        this.setInstanceConfig(config);
+        this.address = contractConfig.address;
+        this.contract = getContract({
+            address: contractConfig.address,
+            abi: contractConfig.abi,
+            client: { public: this.publicClient, wallet: this.walletClient },
+        });
+    }
+    async call(functionName, args, from) {
+        try {
+            return (await this.client.public.readContract({
+                address: this.address,
+                abi: this.contract.abi,
+                functionName: parseAbi([functionName]),
+                args,
+                ...(from && { account: from }),
+            }));
+            //return await this.contract[functionSignature](...args, { from })
+        }
+        catch (err) {
+            throw new ContractsError(`Calling method "${functionName}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
+        }
+    }
+    async getTransactionReceipt(txHash) {
+        // Get the transaction receipt depending on the type of txHash
+        if ('transactionHash' in txHash) {
+            // txHash is TransactionReceipt
+            return txHash;
+        }
+        else if ('userOpHash' in txHash) {
+            // txHash is UserOperationReceipt, fetch the actual receipt using the utility function with retry logic
+            const hash = txHash.receipt.transactionHash;
+            return await getTransactionReceipt({
+                txHash: hash,
+                publicClient: this.client.public,
+            });
+        }
+        else {
+            throw new Error('Unknown transaction type');
+        }
+    }
+    getTransactionLogs(txReceipt, eventName) {
+        return parseEventLogs({
+            abi: this.contract.abi,
+            logs: txReceipt.logs,
+            eventName,
+            strict: false,
+        });
+    }
+    async multicall(calls, from, params = {}) {
+        if (from.type === 'local') {
+            this.logger.debug(`Blockchain Multicall using Local account`);
+            return await this.localAccountMulticall(calls, from, params, params.progress);
+        }
+        else if (from.type === 'json-rpc') {
+            this.logger.debug(`Blockchain Multicall using JSON-RPC account`);
+            return await this.localAccountMulticall(calls, from, params, params.progress);
+        }
+        else if (from.type === 'smart') {
+            this.logger.debug(`Blockchain Multicall using ZeroDev account`);
+            return await this.internalMulticallSmartAccount(calls, from, params, params.progress);
+        }
+        else {
+            throw new ContractsError(`Account not supported`);
+        }
+    }
+    async simulateMulticall(calls, from, params = {}) {
+        if (from.type === 'local') {
+            this.logger.debug(`Simulating calls using Local account`);
+            return await this.localAccountSimulateMulticall(calls, from, params);
+        }
+        else if (from.type === 'json-rpc') {
+            this.logger.debug(`Simulating calls using JSON-RPC account`);
+            return await this.localAccountSimulateMulticall(calls, from, params);
+        }
+        else if (from.type === 'smart') {
+            this.logger.debug(`Simulating calls using Smart Account account`);
+            return await this.internalSimulateMulticallSmartAccount(calls, from, params);
+        }
+        else {
+            throw new ContractsError(`Account not supported`);
+        }
+    }
+    async simulate(functionName, from, args, params = {}) {
+        if (from.type === 'local') {
+            this.logger.debug(`Simulating calls using Local account`);
+            return await this.localAccountSimulate(functionName, from, args, params);
+        }
+        else if (from.type === 'json-rpc') {
+            this.logger.debug(`Simulating calls using JSON-RPC account`);
+            return await this.localAccountSimulate(functionName, from, args, params);
+        }
+        else if (from.type === 'smart') {
+            this.logger.debug(`Simulating calls using Smart Account account`);
+            return await this.internalSimulateSmartAccount(functionName, from, args, params);
+        }
+        else {
+            throw new ContractsError(`Account not supported`);
+        }
+    }
+    async send(functionName, from, args, params = {}) {
+        if (from.type === 'local') {
+            this.logger.debug(`Blockchain Send using Local account with functionName: ${functionName} and following args: ${args}`);
+            return await this.localAccountSend(functionName, from, args, params, params.progress);
+        }
+        else if (from.type === 'json-rpc') {
+            this.logger.debug(`Blockchain Send using JSON-RPC account to ${functionName}`);
+            return await this.localAccountSend(functionName, from, args, params, params.progress);
+        }
+        else if (from.type === 'smart') {
+            this.logger.debug(`Blockchain Send using ZeroDev account`);
+            return await this.internalSendSmartAccount(functionName, from, args, params, params.progress);
+        }
+        else {
+            throw new ContractsError(`Account not supported`);
+        }
+    }
+    async internalMulticallSmartAccount(calls, from, txparams, progress) {
+        if (progress) {
+            progress({
+                stage: 'multicall-sending',
+                args: [],
+                method: '',
+                from: from,
+                contractAddress: this.address,
+            });
+        }
+        const ZERODEV_RPC = `https://rpc.zerodev.app/api/v3/${this.config.zeroDevProjectId}/chain/${this.config.chainId}`;
+        const zerodevPaymaster = createZeroDevPaymasterClient({
+            chain: getChain(this.config.chainId),
+            transport: http(ZERODEV_RPC),
+        });
+        const kernelClient = createKernelAccountClient({
+            account: from,
+            chain: getChain(this.config.chainId),
+            bundlerTransport: http(ZERODEV_RPC),
+            client: this.client.public,
+            paymaster: {
+                getPaymasterData: (userOperation) => {
+                    return zerodevPaymaster.sponsorUserOperation({
+                        userOperation,
+                    });
+                },
+            },
+        });
+        const encodedCalls = [];
+        calls.map((call) => {
+            encodedCalls.push({
+                to: call.contractAddress || this.address,
+                value: txparams.value || 0n,
+                data: encodeFunctionData({
+                    abi: call.abi,
+                    functionName: call.functionName,
+                    args: call.args,
+                }),
+            });
+        });
+        try {
+            const userOpHash = await kernelClient.sendUserOperation({
+                callData: await kernelClient.account.encodeCalls(encodedCalls),
+            });
+            if (progress) {
+                progress({
+                    stage: 'multicall-sent',
+                    args: [],
+                    method: '',
+                    from: from,
+                    contractAddress: this.address,
+                });
+            }
+            // Wait for the transaction to be mined
+            this.logger.debug(`Waiting for transaction to be mined... ${userOpHash}`);
+            const txReceipt = await kernelClient.waitForUserOperationReceipt({ hash: userOpHash });
+            this.logger.debug(`Transaction mined - UserOperationHash: ${userOpHash}`);
+            this.logger.debug(`Transaction receipt - TransactionHash: ${txReceipt.receipt.transactionHash}`);
+            return txReceipt.receipt;
+        }
+        catch (err) {
+            if (err instanceof BaseError) {
+                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                this.logger.error(`revertError: ${String(revertError)}`);
+            }
+            throw new ContractsError(`Multicall failed: ${err}`);
+        }
+    }
+    async internalSendSmartAccount(name, from, args, txparams, progress) {
+        const functionInputs = getInputsOfFunctionFormatted(this.contract.abi, name, args);
+        const { gasLimit, value } = txparams;
+        if (progress) {
+            progress({
+                stage: 'sending',
+                args: functionInputs,
+                method: name,
+                from: from,
+                value,
+                contractName: this.contractName,
+                contractAddress: this.address,
+                gasLimit,
+            });
+        }
+        const ZERODEV_RPC = `https://rpc.zerodev.app/api/v3/${this.config.zeroDevProjectId}/chain/${this.config.chainId}`;
+        try {
+            await this.client.public.simulateContract({
+                address: this.address,
+                abi: this.contract.abi,
+                functionName: name,
+                args,
+                account: from,
+                ...(txparams.value && { value: txparams.value }),
+            });
+        }
+        catch (err) {
+            if (err instanceof BaseError) {
+                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                this.logger.error(`revertError: ${String(revertError)}`);
+            }
+            throw new ContractsError(`Calling method "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
+        }
+        const zerodevPaymaster = createZeroDevPaymasterClient({
+            chain: getChain(this.config.chainId),
+            transport: http(ZERODEV_RPC),
+        });
+        const kernelClient = createKernelAccountClient({
+            account: from,
+            // Replace with your chain
+            chain: getChain(this.config.chainId),
+            // Find the RPC in your ZeroDev dashboard
+            bundlerTransport: http(ZERODEV_RPC),
+            // Required - the public client
+            client: this.client.public,
+            // Optional -- only if you want to use a paymaster
+            paymaster: {
+                getPaymasterData: (userOperation) => {
+                    return zerodevPaymaster.sponsorUserOperation({
+                        userOperation,
+                    });
+                },
+            },
+        });
+        const data = encodeFunctionData({ abi: this.contract.abi, functionName: name, args });
+        let userOpHash;
+        try {
+            userOpHash = await kernelClient.sendUserOperation({
+                callData: await kernelClient.account.encodeCalls([
+                    {
+                        to: this.address,
+                        value: txparams.value || 0n,
+                        data,
+                    },
+                ]),
+            });
+        }
+        catch (err) {
+            if (err instanceof BaseError) {
+                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                this.logger.error(`revertError: ${String(revertError)}`);
+            }
+            throw new ContractsError(`Calling method "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
+        }
+        if (progress) {
+            progress({
+                stage: 'sent',
+                args: functionInputs,
+                userOpHash,
+                method: name,
+                from: from,
+                value,
+                contractName: this.contractName,
+                contractAddress: this.address,
+                gasLimit,
+            });
+        }
+        const txReceipt = await kernelClient.waitForUserOperationReceipt({ hash: userOpHash });
+        if (progress) {
+            progress({
+                stage: 'receipt',
+                args: functionInputs,
+                txReceipt,
+                method: name,
+                from: from,
+                value,
+                contractName: this.contractName,
+                contractAddress: this.address,
+                gasLimit,
+            });
+        }
+        return txReceipt;
+    }
+    async internalSimulateSmartAccount(name, from, args, txparams) {
+        try {
+            await this.client.public.simulateContract({
+                address: this.address,
+                abi: this.contract.abi,
+                functionName: name,
+                args,
+                account: from.address,
+                ...(txparams.value && { value: txparams.value }),
+            });
+            return true;
+        }
+        catch (err) {
+            throw new ContractSimulationError(`Error Simulating contract call "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
+        }
+    }
+    async localAccountSimulate(name, from, args, txparams) {
+        try {
+            await this.client.public.simulateContract({
+                address: this.address,
+                abi: this.contract.abi,
+                functionName: name,
+                args,
+                account: from,
+                ...(txparams.value && { value: txparams.value }),
+            });
+        }
+        catch (err) {
+            throw new ContractSimulationError(`Error Simulating contract call "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
+        }
+        return true;
+    }
+    async localAccountSend(name, from, args, txparams, progress, _contractAbi, _contractAddress, _contractName) {
+        const abi = _contractAbi || this.contract.abi;
+        const contractAddress = _contractAddress || this.address;
+        const contractName = _contractName || this.contractName;
+        const functionInputs = getInputsOfFunctionFormatted(abi, name, args);
+        // Uncomment to debug contract calls
+        // if (name === 'order') {
+        //   const functionSignature = getSignatureOfFunction(this.contract.abi, name, args)
+        //   this.logger.info(`Making contract call ....: ${name} - ${from}`)
+        //   this.logger.info(`With args: `, JSON.stringify(args, jsonReplacer))
+        //   this.logger.info(`And signature: ${JSON.stringify(functionSignature, jsonReplacer)}`)
+        //   this.logger.info('And amount: ', txparams.value)
+        // }
+        //  abi.filter(({name, inputs}) => name === 'closeSignals' && inputs.length === 1)
+        // const abiFilter = this.contract.abi.filter((abi) => abi.name === name && abi.inputs.length === args.length)
+        // const abiFilter = this.contract.abi.filter((abi) => abi.name === name && abi.type === 'function')
+        // console.debug('abi', this.contract.abi.filter((abi) => abi.name === name))
+        // console.debug('abiFilter', abiFilter)
+        // if (!abiFilter)
+        //   throw new ContractsError(
+        //     `No ABI found for method "${name}" with ${args.length} arguments on contract "${this.contractName}"`,
+        //   )
+        const { gasLimit, value } = txparams;
+        // make the call
+        if (progress) {
+            progress({
+                stage: 'sending',
+                args: functionInputs,
+                method: name,
+                from,
+                value,
+                contractName,
+                contractAddress,
+                gasLimit,
+            });
+        }
+        let txHash;
+        try {
+            const { request } = await this.client.public.simulateContract({
+                address: contractAddress,
+                abi,
+                functionName: name,
+                args,
+                account: from,
+                ...(txparams.value && { value: txparams.value }),
+            });
+            txHash = await this.client.wallet.writeContract({
+                ...request,
+                account: from,
+            });
+        }
+        catch (err) {
+            if (err instanceof BaseError) {
+                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                this.logger.error(`revertError: ${String(revertError)}`);
+            }
+            throw new ContractsError(`Calling method "${name}" on contract "${contractName}" failed. Args: ${args} - ${err}`);
+        }
+        if (progress) {
+            progress({
+                stage: 'sent',
+                args: functionInputs,
+                txHash,
+                method: name,
+                from,
+                value,
+                contractName,
+                contractAddress,
+                gasLimit,
+            });
+        }
+        const txReceipt = getTransactionReceipt({ txHash, publicClient: this.client.public });
+        if (progress) {
+            progress({
+                stage: 'receipt',
+                args: functionInputs,
+                txReceipt,
+                method: name,
+                from,
+                value,
+                contractName,
+                contractAddress,
+                gasLimit,
+            });
+        }
+        return txReceipt;
+    }
+    async localAccountMulticall(calls, from, txparams, progress) {
+        const receipts = [];
+        for (const call of calls) {
+            receipts.push(await this.localAccountSend(call.functionName, from, call.args, txparams, progress, call.abi, call.contractAddress, call.contractName));
+        }
+        if (receipts.length > 0)
+            return receipts.pop();
+        else
+            throw new ContractsError(`No receipts found for multicall`);
+    }
+    async localAccountSimulateMulticall(calls, from, txparams) {
+        try {
+            const { results } = await this.client.public.simulateCalls({
+                calls,
+                account: from,
+            });
+            this.logger.debug(`Simulated multicall - ${results}`);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof BaseError) {
+                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                this.logger.error(`revertError: ${String(revertError)}`);
+            }
+            throw new ContractsError(`Error simulating multicall - ${err}`);
+        }
+    }
+    async internalSimulateMulticallSmartAccount(calls, from, txparams) {
+        try {
+            const zerodevPaymaster = createZeroDevPaymasterClient({
+                chain: getChain(this.config.chainId),
+                transport: http(this.getZeroDevRPC()),
+            });
+            const kernelClient = createKernelAccountClient({
+                account: from,
+                chain: getChain(this.config.chainId),
+                bundlerTransport: http(this.getZeroDevRPC()),
+                client: this.client.public,
+                paymaster: {
+                    getPaymasterData: (userOperation) => {
+                        return zerodevPaymaster.sponsorUserOperation({
+                            userOperation,
+                        });
+                    },
+                },
+                userOperation: {
+                    estimateFeesPerGas: async ({ bundlerClient }) => {
+                        return getUserOperationGasPrice(bundlerClient);
+                    },
+                },
+            });
+            const encodedCalls = [];
+            for (const call of calls) {
+                encodedCalls.push({
+                    to: call.to,
+                    value: call.value || 0n,
+                    data: encodeFunctionData({
+                        abi: call.abi,
+                        functionName: call.functionName,
+                        args: call.args,
+                    }),
+                });
+            }
+            // DONT DELETE THE COMMENTED LINES - ARE NECESSARY FOR F***ING ZERODEV DEBUGGING
+            // this.logger.info(`Encoded multicall - ${JSON.stringify(encodedCalls, jsonReplacer)}`)
+            // const code = await this.client.public.getCode({ address: from.address })
+            // const isDeployed = code !== undefined && code !== '0x'
+            // this.logger.info(`++++++ Smart account ${from.address} deployment status: ${isDeployed ? 'DEPLOYED' : 'NOT DEPLOYED'}`)
+            // // Log account details
+            // this.logger.info(`Account type: ${from.type}`)
+            // this.logger.info(`Account address: ${from.address}`)
+            // // Log the calls being made
+            // this.logger.info(`Number of calls: ${encodedCalls.length}`)
+            // encodedCalls.forEach((call, index) => {
+            //   this.logger.info(`Call ${index}: to=${call.to}, value=${call.value}, data=${call.data.slice(0, 10)}...`)
+            // })
+            await kernelClient.prepareUserOperation({
+                callData: await kernelClient.account.encodeCalls(encodedCalls),
+            });
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`Error details: ${JSON.stringify(err, null, 2)}`);
+            if (err instanceof BaseError) {
+                const revertError = err.walk((e) => e instanceof ContractFunctionRevertedError);
+                if (revertError) {
+                    this.logger.error(`Revert error: ${String(revertError)}`);
+                }
+            }
+            throw new ContractSimulationError(`Error Simulating Multicalls - ${err}`);
+        }
+    }
+    getZeroDevRPC() {
+        return `https://rpc.zerodev.app/api/v3/${this.config.zeroDevProjectId}/chain/${this.config.chainId}`;
+    }
+}

package/dist/contracts/ContractsApi.d.ts

@@ -0,0 +1,69 @@
+import { Instantiable, InstantiableConfig } from '../Instantiable.abstract.js';
+import { AccessManager } from './AccessManager.js';
+import { AssetRegistry } from './AssetRegistry.js';
+import { FiatPaymentTemplate } from './FiatPaymentTemplate.js';
+import { FixedPaymentTemplate } from './FixedPaymentTemplate.js';
+import { PayAsYouGoTemplate } from './PayAsYouGoTemplate.js';
+import { NFT1155Credits } from './NFT1155Credits.js';
+import { NFT1155ExpirableCredits } from './NFT1155ExpirableCredits.js';
+import { NeverminedConfig } from './NVMConfig.js';
+import { ProtocolStandardFees } from './ProtocolStandardFees.js';
+export declare class ContractsApi extends Instantiable {
+    /**
+     * Return ContractsApi instance
+     * @param config
+     * @returns {@link ContractsApi}
+     */
+    static getInstance(config: InstantiableConfig): Promise<ContractsApi>;
+    init(): Promise<void>;
+    /**
+     * Access Manager smart contract instance.
+     */
+    accessManager: AccessManager;
+    /**
+     * Nevermined Config smart contract instance.
+     */
+    nvmConfig: NeverminedConfig;
+    /**
+     * Asset registry smart contract instance.
+     */
+    assetRegistry: AssetRegistry;
+    /**
+     * NFT1155Credits smart contract instance.
+     * Manages non-expirable credits using the ERC-1155 standard.
+     * Allows minting, burning and balance checking of credits.
+     */
+    nft1155Credits: NFT1155Credits;
+    /**
+     * NFT1155ExpirableCredits smart contract instance.
+     * Manages expirable credits using the ERC-1155 standard.
+     * Similar to NFT1155Credits but with an additional expiration mechanism.
+     * Credits minted through this contract will expire after a specified duration.
+     */
+    nft1155ExpirableCredits: NFT1155ExpirableCredits;
+    /**
+     * FixedPaymentTemplate smart contract instance.
+     * Handles fixed payment agreements between parties.
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    fixedPaymentTemplate: FixedPaymentTemplate;
+    /**
+     * FiatPaymentTemplate smart contract instance.
+     * Handles fiat payment agreements between parties (i.e Stripe).
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    fiatPaymentTemplate: FiatPaymentTemplate;
+    /**
+     * PayAsYouGoTemplate smart contract instance.
+     * Handles pay as you go agreements between parties.
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    payAsYouGoTemplate: PayAsYouGoTemplate;
+    /**
+     * ProtocolStandardFees smart contract instance.
+     * It provides methods to calculate fees based on total amounts, price configurations, and credits configurations.
+     * This is the default fee controller for the protocol.
+     */
+    protocolStandardFees: ProtocolStandardFees;
+}
+//# sourceMappingURL=ContractsApi.d.ts.map

package/dist/contracts/ContractsApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractsApi.d.ts","sourceRoot":"","sources":["../../src/contracts/ContractsApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEhE,qBAAa,YAAa,SAAQ,YAAY;IAC5C;;;;OAIG;WAC0B,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC;IAM9E,IAAI;IA6BjB;;OAEG;IACI,aAAa,EAAG,aAAa,CAAA;IACpC;;OAEG;IACI,SAAS,EAAG,gBAAgB,CAAA;IAEnC;;OAEG;IACI,aAAa,EAAG,aAAa,CAAA;IAEpC;;;;OAIG;IACI,cAAc,EAAG,cAAc,CAAA;IAEtC;;;;;OAKG;IACI,uBAAuB,EAAG,uBAAuB,CAAA;IAExD;;;;OAIG;IACI,oBAAoB,EAAG,oBAAoB,CAAA;IAElD;;;;OAIG;IACI,mBAAmB,EAAG,mBAAmB,CAAA;IAEhD;;;;OAIG;IACI,kBAAkB,EAAG,kBAAkB,CAAA;IAE9C;;;;OAIG;IACI,oBAAoB,EAAG,oBAAoB,CAAA;CACnD"}

package/dist/contracts/ContractsApi.js

@@ -0,0 +1,73 @@
+import { Instantiable } from '../Instantiable.abstract.js';
+export class ContractsApi extends Instantiable {
+    /**
+     * Return ContractsApi instance
+     * @param config
+     * @returns {@link ContractsApi}
+     */
+    static async getInstance(config) {
+        const contractsApi = new ContractsApi();
+        contractsApi.setInstanceConfig(config);
+        return contractsApi;
+    }
+    async init() {
+        this.accessManager = await (await import('./AccessManager.js')).AccessManager.getInstance(this.instanceConfig);
+        this.nvmConfig = await (await import('./NVMConfig.js')).NeverminedConfig.getInstance(this.instanceConfig);
+        this.assetRegistry = await (await import('./AssetRegistry.js')).AssetRegistry.getInstance(this.instanceConfig);
+        this.nft1155Credits = await (await import('./NFT1155Credits.js')).NFT1155Credits.getInstance(this.instanceConfig);
+        this.nft1155ExpirableCredits = await (await import('./NFT1155ExpirableCredits.js')).NFT1155ExpirableCredits.getInstance(this.instanceConfig);
+        this.fixedPaymentTemplate = await (await import('./FixedPaymentTemplate.js')).FixedPaymentTemplate.getInstance(this.instanceConfig);
+        this.fiatPaymentTemplate = await (await import('./FiatPaymentTemplate.js')).FiatPaymentTemplate.getInstance(this.instanceConfig);
+        this.payAsYouGoTemplate = await (await import('./PayAsYouGoTemplate.js')).PayAsYouGoTemplate.getInstance(this.instanceConfig);
+        this.protocolStandardFees = await (await import('./ProtocolStandardFees.js')).ProtocolStandardFees.getInstance(this.instanceConfig);
+    }
+    /**
+     * Access Manager smart contract instance.
+     */
+    accessManager;
+    /**
+     * Nevermined Config smart contract instance.
+     */
+    nvmConfig;
+    /**
+     * Asset registry smart contract instance.
+     */
+    assetRegistry;
+    /**
+     * NFT1155Credits smart contract instance.
+     * Manages non-expirable credits using the ERC-1155 standard.
+     * Allows minting, burning and balance checking of credits.
+     */
+    nft1155Credits;
+    /**
+     * NFT1155ExpirableCredits smart contract instance.
+     * Manages expirable credits using the ERC-1155 standard.
+     * Similar to NFT1155Credits but with an additional expiration mechanism.
+     * Credits minted through this contract will expire after a specified duration.
+     */
+    nft1155ExpirableCredits;
+    /**
+     * FixedPaymentTemplate smart contract instance.
+     * Handles fixed payment agreements between parties.
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    fixedPaymentTemplate;
+    /**
+     * FiatPaymentTemplate smart contract instance.
+     * Handles fiat payment agreements between parties (i.e Stripe).
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    fiatPaymentTemplate;
+    /**
+     * PayAsYouGoTemplate smart contract instance.
+     * Handles pay as you go agreements between parties.
+     * Used for creating and managing payment agreements with predefined terms.
+     */
+    payAsYouGoTemplate;
+    /**
+     * ProtocolStandardFees smart contract instance.
+     * It provides methods to calculate fees based on total amounts, price configurations, and credits configurations.
+     * This is the default fee controller for the protocol.
+     */
+    protocolStandardFees;
+}

package/dist/contracts/CryptoTemplateBase.d.ts

@@ -0,0 +1,11 @@
+import { Abi, Account, Address } from 'viem';
+import { SmartAccount } from 'viem/account-abstraction';
+import { TxParameters } from '../models/Transactions.js';
+import { ContractBase } from './ContractBase.js';
+export declare class CryptoTemplateBase extends ContractBase {
+    protected TOKEN_APPROVE_ABI: Abi;
+    protected ERC20_TRANSFER_ABI: Abi;
+    transferERC20(from: Account | SmartAccount, to: Address, amount: bigint, erc20Address: Address, txParams?: TxParameters): Promise<import("viem").TransactionReceipt>;
+    approveERC20(amount: bigint, erc20Address: Address, owner: Account | SmartAccount, txParams?: TxParameters): Promise<import("viem").TransactionReceipt>;
+}
+//# sourceMappingURL=CryptoTemplateBase.d.ts.map

package/dist/contracts/CryptoTemplateBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoTemplateBase.d.ts","sourceRoot":"","sources":["../../src/contracts/CryptoTemplateBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAY,MAAM,MAAM,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAA;AAEhE,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,SAAS,CAAC,iBAAiB,EAErB,GAAG,CAAA;IAET,SAAS,CAAC,kBAAkB,EAEtB,GAAG,CAAA;IAEI,aAAa,CACxB,IAAI,EAAE,OAAO,GAAG,YAAY,EAC5B,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,OAAO,EACrB,QAAQ,CAAC,EAAE,YAAY;IAqBZ,YAAY,CACvB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,OAAO,EACrB,KAAK,EAAE,OAAO,GAAG,YAAY,EAC7B,QAAQ,CAAC,EAAE,YAAY;CAqB1B"}