@nevermined-io/core-kit 0.0.2-rc19

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

@@ -0,0 +1 @@
+{"version":3,"file":"JwtUtils.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/JwtUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,EAAE,KAAK,mBAAmB,EAAE,OAAO,EAAwB,MAAM,MAAM,CAAA;AAC9E,OAAO,EAAE,KAAK,OAAO,EAAmD,MAAM,MAAM,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAGjF,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,qBAAa,UAAW,SAAQ,OAAO;IACrC,eAAe,EAAE,mBAAmB,GAAG,SAAS,CAAA;IAEvC,kBAAkB,CAAC,eAAe,EAAE,mBAAmB;IAKnD,OAAO,CAClB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,OAAO,GAAG,YAAY,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,MAAM,CAAC;WAoDE,QAAQ,CAC1B,IAAI,EAAE,MAAM,GAAG,UAAU,EACzB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAY9B,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,MAAM;CAUf;AAED,qBAAa,QAAS,SAAQ,YAAY;IACxC,MAAM,CAAC,qBAAqB,SAA2D;IAGvF,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,cAAc,EAAE,cAAc,CAAA;gBAElB,MAAM,EAAE,kBAAkB;IAO/B,gBAAgB,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM;IAIrC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC;IAqB3D,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM;IAmB/E,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAc3C,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM;IAKxC,MAAM,CAAC,aAAa,CAAC,aAAa,EAAE,MAAM;CAK3C"}

package/dist/nevermined/utils/JwtUtils.js

@@ -0,0 +1,154 @@
+import { deflateSync, inflateSync } from 'fflate';
+import { SignJWT, decodeJwt, importJWK } from 'jose';
+import { hexToBytes, toHex } from 'viem';
+import { Instantiable } from '../../Instantiable.abstract.js';
+import { urlSafeBase64Decode, urlSafeBase64Encode } from '../../utils/helpers.js';
+import { getChecksumAddress } from './BlockchainViemUtils.js';
+import { SignatureUtils } from './SignatureUtils.js';
+export class EthSignJWT extends SignJWT {
+    protectedHeader;
+    setProtectedHeader(protectedHeader) {
+        this.protectedHeader = protectedHeader;
+        return this;
+    }
+    async ethSign(signatureUtils, account, eip712Data) {
+        const encoder = new TextEncoder();
+        const decoder = new TextDecoder();
+        let payload = this._payload;
+        if (eip712Data) {
+            payload = {
+                ...payload,
+                eip712Data,
+            };
+        }
+        const encodedPayload = encoder.encode(this.base64url(JSON.stringify(payload)));
+        const encodedHeader = encoder.encode(this.base64url(JSON.stringify(this.protectedHeader)));
+        const data = this.concat(encodedHeader, encoder.encode('.'), encodedPayload);
+        // EIP-712 signature
+        let sign;
+        if (eip712Data) {
+            const domain = {
+                name: 'Nevermined',
+                version: '1',
+                chainId: eip712Data.chainId,
+            };
+            const types = {
+                Nevermined: [
+                    { name: 'from', type: 'address' },
+                    { name: 'message', type: 'string' },
+                    { name: 'token', type: 'string' },
+                ],
+            };
+            const value = {
+                from: account.address,
+                message: eip712Data.message,
+                token: decoder.decode(data),
+            };
+            sign = await signatureUtils.signTypedData(domain, types, value, account);
+        }
+        else {
+            sign = await signatureUtils.signText(decoder.decode(data), account);
+        }
+        const input = hexToBytes(sign);
+        const signed = this.base64url(input);
+        const grantToken = `${decoder.decode(encodedHeader)}.${decoder.decode(encodedPayload)}.${signed}`;
+        return grantToken;
+    }
+    static async signText(text, account) {
+        try {
+            const message = typeof text === 'string' ? text : toHex(text);
+            return account.signMessage({
+                message: message,
+            });
+        }
+        catch (e) {
+            console.error('Error signing message:', e);
+            return undefined;
+        }
+    }
+    base64url(input) {
+        const buffer = typeof input === 'string' ? Buffer.from(input, 'utf-8') : Buffer.from(input);
+        return buffer.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+    }
+    concat(...buffers) {
+        const size = buffers.reduce((acc, { length }) => acc + length, 0);
+        const buf = new Uint8Array(size);
+        let i = 0;
+        buffers.forEach((buffer) => {
+            buf.set(buffer, i);
+            i += buffer.length;
+        });
+        return buf;
+    }
+}
+export class JwtUtils extends Instantiable {
+    static CLIENT_ASSERTION_TYPE = 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
+    // BASE_AUD = '/api/v1/node/services'
+    tokenCache;
+    signatureUtils;
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+        this.tokenCache = new Map();
+        this.signatureUtils = new SignatureUtils(config);
+    }
+    generateCacheKey(...args) {
+        return args.join();
+    }
+    async accountToJwk(account) {
+        const address = account.address.toLowerCase();
+        // Currently only works with HDWalletProvider
+        // eslint-disable-next-line
+        // @ts-ignore
+        const publicKey = this.web3.currentProvider.wallets[address].getPublicKey();
+        // eslint-disable-next-line
+        // @ts-ignore
+        const privateKey = this.web3.currentProvider.wallets[address].getPrivateKey();
+        return importJWK({
+            alg: 'ES256K',
+            crv: 'secp256k1',
+            kty: 'EC',
+            d: privateKey.toString('base64'),
+            x: publicKey.slice(0, 32).toString('base64'),
+            y: publicKey.slice(32, 64).toString('base64'),
+        });
+    }
+    async generateClientAssertion(account, message) {
+        let eip712Data;
+        if (message) {
+            eip712Data = {
+                message,
+                chainId: await this.publicClient.getChainId(),
+            };
+        }
+        const address = getChecksumAddress(account.address);
+        return new EthSignJWT({
+            iss: address,
+        })
+            .setProtectedHeader({ alg: 'ES256K' })
+            .setIssuedAt()
+            .setExpirationTime('1h')
+            .ethSign(this.signatureUtils, account, eip712Data);
+    }
+    isTokenValid(token) {
+        const decodedToken = decodeJwt(token);
+        if (!decodedToken) {
+            return false;
+        }
+        const expiry = decodedToken.exp;
+        if (expiry) {
+            const now = new Date();
+            return now.getTime() < Number(expiry) * 1000;
+        }
+        return false;
+    }
+    static createCompressedJwt(token) {
+        const compressed = deflateSync(new TextEncoder().encode(token));
+        return urlSafeBase64Encode(compressed);
+    }
+    static decompressJwt(compressedJwt) {
+        const decoded = urlSafeBase64Decode(compressedJwt);
+        const decompressed = inflateSync(decoded);
+        return new TextDecoder().decode(decompressed);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Account, type Hash } from 'viem';
+import { Instantiable, InstantiableConfig } from '../../Instantiable.abstract.js';
+import type { TypedDataDomain, TypedDataTypes } from '@nvm-monorepo/commons';
+import { SmartAccount } from 'viem/account-abstraction';
+export declare class SignatureUtils extends Instantiable {
+    constructor(config: InstantiableConfig);
+    signText(text: string | Uint8Array, account: Account | SmartAccount): Promise<Hash>;
+    signTypedData(domain: TypedDataDomain, types: TypedDataTypes, value: Record<string, any>, account: Account | SmartAccount): Promise<Hash>;
+    signTransaction(tx: `0x${string}`, account: Account | SmartAccount): Promise<string>;
+    verifyIsSigner(text: string, signature: string, signerAddress: string): Promise<boolean>;
+    static recoverSignerAddress(message: string, signature: string): Promise<string>;
+    static hash(seed: string): string;
+}
+//# sourceMappingURL=SignatureUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureUtils.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/SignatureUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,EAAmD,MAAM,MAAM,CAAA;AAC1F,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAEjF,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAGvD,qBAAa,cAAe,SAAQ,YAAY;gBAClC,MAAM,EAAE,kBAAkB;IAKzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBnF,aAAa,CACxB,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,OAAO,EAAE,OAAO,GAAG,YAAY,GAC9B,OAAO,CAAC,IAAI,CAAC;IA6BH,eAAe,CAC1B,EAAE,EAAE,KAAK,MAAM,EAAE,EACjB,OAAO,EAAE,OAAO,GAAG,YAAY,GAC9B,OAAO,CAAC,MAAM,CAAC;IAmBL,cAAc,CACzB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,OAAO,CAAC;WAQN,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOtF,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGlC"}

package/dist/nevermined/utils/SignatureUtils.js

@@ -0,0 +1,99 @@
+import { recoverMessageAddress, toHex } from 'viem';
+import { Instantiable } from '../../Instantiable.abstract.js';
+import { NvmAccountError } from '../../errors/NeverminedErrors.js';
+import { keccak256 } from './BlockchainViemUtils.js';
+export class SignatureUtils extends Instantiable {
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+    }
+    async signText(text, account) {
+        const message = typeof text === 'string' ? text : toHex(text);
+        if (account.type === 'smart') {
+            const result = await account.signMessage({ message });
+            return result;
+        }
+        else if (account.type === 'local') {
+            return account.signMessage({
+                message: message,
+            });
+        }
+        else if (account.type === 'json-rpc') {
+            const message = typeof text === 'string' ? text : toHex(text);
+            return await this.walletClient.signMessage({
+                account: account.address,
+                message: message,
+            });
+        }
+        else {
+            throw new NvmAccountError('The account type is not supported for signing');
+        }
+    }
+    async signTypedData(domain, types, value, account) {
+        if (account.type === 'smart') {
+            const signature = await account.signTypedData({
+                domain,
+                types: types,
+                message: value,
+                primaryType: 'Nevermined',
+            });
+            return signature;
+        }
+        else if (account.type === 'local') {
+            return await account.signTypedData({
+                domain,
+                types: types,
+                message: value,
+                primaryType: 'Nevermined',
+            });
+        }
+        else if (account.type === 'json-rpc') {
+            return await this.walletClient.signTypedData({
+                domain,
+                types: types,
+                message: value,
+                primaryType: 'Nevermined',
+                account: account.address,
+            });
+        }
+        else {
+            throw new NvmAccountError('The account type is not supported for typed signing');
+        }
+    }
+    async signTransaction(tx, account) {
+        // if (account.type === 'smart') {
+        //   return await account?.signTransaction({ data: tx })
+        // }
+        if (account.type === 'local') {
+            return account.signTransaction({
+                data: tx,
+            });
+        }
+        else if (account.type === 'json-rpc') {
+            return await this.walletClient.signTransaction({
+                data: tx,
+                account: account.address,
+                chain: this.client.chain,
+            });
+        }
+        else {
+            throw new NvmAccountError('The account type is not supported for signing');
+        }
+    }
+    async verifyIsSigner(text, signature, signerAddress) {
+        return this.client.public.verifyMessage({
+            message: text,
+            signature: signature,
+            address: signerAddress,
+        });
+    }
+    static async recoverSignerAddress(message, signature) {
+        return recoverMessageAddress({
+            message,
+            signature: signature,
+        });
+    }
+    static hash(seed) {
+        return keccak256(seed).replace(/^0x([a-f0-9]{64})(:!.+)?$/i, '0x$1');
+    }
+}

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

@@ -0,0 +1,32 @@
+import { BodyInit, Response } from 'node-fetch';
+import { ReadStream } from 'fs';
+import { URL } from 'whatwg-url';
+import { InstantiableConfig } from '../../Instantiable.abstract.js';
+/**
+ * Provides a common interface to web services.
+ */
+export declare class WebServiceConnector {
+    config: InstantiableConfig;
+    constructor(config: InstantiableConfig);
+    post(url: string, payload: BodyInit, headers?: {
+        [header: string]: string;
+    }): Promise<Response>;
+    get(url: string | URL, headers?: {
+        [header: string]: string;
+    }): Promise<Response>;
+    put(url: string, payload: BodyInit, headers?: {
+        [header: string]: string;
+    }): Promise<Response>;
+    delete(url: string, payload?: BodyInit, headers?: {
+        [header: string]: string;
+    }): Promise<Response>;
+    downloadUrl(url: string, headers?: any): Promise<string>;
+    uploadMessage(url: string, data: string, encrypt?: boolean): Promise<any>;
+    uploadFile(url: string, data: ReadStream, encrypt?: boolean): Promise<any>;
+    fetchToken(url: string, grantToken: string, numberTries?: number, apiKeyHash?: string): Promise<Response>;
+    fetchCID(cid: string): Promise<string>;
+    private static getIPFSAuthToken;
+    private fetch;
+    private _sleep;
+}
+//# sourceMappingURL=WebServiceConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebServiceConnector.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/WebServiceConnector.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAe,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAA;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAEhC,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAgBnE;;GAEG;AACH,qBAAa,mBAAmB;IAG9B,MAAM,EAAE,kBAAkB,CAAA;gBAEd,MAAM,EAAE,kBAAkB;IAM/B,IAAI,CACT,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,QAAQ,EACjB,OAAO,GAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GACzC,OAAO,CAAC,QAAQ,CAAC;IAWb,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,GAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IASrF,GAAG,CACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,QAAQ,EACjB,OAAO,GAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GACzC,OAAO,CAAC,QAAQ,CAAC;IAWb,MAAM,CACX,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,QAAQ,EAClB,OAAO,GAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GACzC,OAAO,CAAC,QAAQ,CAAC;IAgEP,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAQxD,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IASzE,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IAS1E,UAAU,CACrB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,WAAW,SAAI,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,QAAQ,CAAC;IAuBP,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBnD,OAAO,CAAC,MAAM,CAAC,gBAAgB;YAUjB,KAAK;IAiBnB,OAAO,CAAC,MAAM;CAGf"}

package/dist/nevermined/utils/WebServiceConnector.js

@@ -0,0 +1,191 @@
+import FormData from 'form-data';
+import { HttpError } from '../../errors/NeverminedErrors.js';
+import { JwtUtils } from '../../nevermined/utils/JwtUtils.js';
+let fetch;
+async function initializeFetch() {
+    if (typeof window !== 'undefined') {
+        fetch = window.fetch.bind(window);
+    }
+    else {
+        const nodeFetch = await import('node-fetch');
+        fetch = nodeFetch.default;
+    }
+    return fetch;
+}
+fetch = initializeFetch();
+/**
+ * Provides a common interface to web services.
+ */
+export class WebServiceConnector {
+    // extends Instantiable {
+    config;
+    constructor(config) {
+        // super()
+        // this.setInstanceConfig(config)
+        this.config = config;
+    }
+    post(url, payload, headers = {}) {
+        return this.fetch(url, {
+            method: 'POST',
+            body: payload,
+            headers: {
+                'Content-type': 'application/json',
+                ...headers,
+            },
+        });
+    }
+    get(url, headers = {}) {
+        return this.fetch(url, {
+            method: 'GET',
+            headers: {
+                ...headers,
+            },
+        });
+    }
+    put(url, payload, headers = {}) {
+        return this.fetch(url, {
+            method: 'PUT',
+            body: payload,
+            headers: {
+                'Content-type': 'application/json',
+                ...headers,
+            },
+        });
+    }
+    delete(url, payload, headers = {}) {
+        return this.fetch(url, {
+            method: 'DELETE',
+            body: payload,
+            headers: {
+                'Content-type': 'application/json',
+                ...headers,
+            },
+        });
+    }
+    // public async downloadFile(
+    //   url: string,
+    //   destination?: string,
+    //   index?: number,
+    //   headers?: { [key: string]: string },
+    // ): Promise<string> {
+    //   const { response, name } = await this.getFileResponse(url, index, headers)
+    //   if (destination) {
+    //     await new Promise((resolve, reject) => {
+    //       // @ts-ignore
+    //       fs.mkdirSync(destination, { recursive: true })
+    //       const fileStream = fs.createWriteStream(`${destination}${name}`)
+    //       response.body.pipe(fileStream)
+    //       response.body.on('error', reject)
+    //       fileStream.on('finish', resolve)
+    //       fileStream.on('close', resolve)
+    //     })
+    //   } else {
+    //     const buff = await response.arrayBuffer()
+    //     fileDownload(buff, name)
+    //     destination = process.cwd()
+    //   }
+    //   const d = path.join(destination, name)
+    //   return d
+    // }
+    // private async getFileResponse(
+    //   url: string,
+    //   index?: number,
+    //   headers?: { [key: string]: string },
+    // ): Promise<{ response: Response; name: string }> {
+    //   const response = await this.get(url, headers)
+    //   if (!response.ok) {
+    //     throw new Error('Response error.')
+    //   }
+    //   let name: string
+    //   try {
+    //     // @ts-ignore
+    //     ;[, name] = response.headers.get('content-disposition').match(/attachment;filename=(.+)/)
+    //   } catch {
+    //     try {
+    //       // @ts-ignore
+    //       name = url.split('/').pop()
+    //     } catch {
+    //       name = `file${index}`
+    //     }
+    //   }
+    //   return { response, name }
+    // }
+    async downloadUrl(url, headers) {
+        const response = await this.get(url, headers);
+        if (!response.ok) {
+            throw new Error('Response error.');
+        }
+        return await response.text();
+    }
+    async uploadMessage(url, data, encrypt) {
+        const form = new FormData();
+        form.append('message', data);
+        if (encrypt) {
+            form.append('encrypt', 'true');
+        }
+        return this.fetch(url, { method: 'POST', body: form });
+    }
+    async uploadFile(url, data, encrypt) {
+        const form = new FormData();
+        form.append('file', data);
+        if (encrypt) {
+            form.append('encrypt', 'true');
+        }
+        return this.fetch(url, { method: 'POST', body: form });
+    }
+    async fetchToken(url, grantToken, numberTries = 1, apiKeyHash) {
+        const bodyParams = new URLSearchParams({
+            client_assertion_type: JwtUtils.CLIENT_ASSERTION_TYPE,
+            client_assertion: grantToken,
+        });
+        if (apiKeyHash) {
+            bodyParams.append('nvm_key_hash', apiKeyHash);
+        }
+        return await fetch(url, {
+            method: 'POST',
+            body: bodyParams.toString(),
+            headers: {
+                'Content-type': 'application/x-www-form-urlencoded',
+            },
+        }, numberTries);
+    }
+    async fetchCID(cid) {
+        const url = `${this.config.config?.ipfsGateway}/api/v0/cat?arg=${cid.replace('cid://', '')}`;
+        const authToken = WebServiceConnector.getIPFSAuthToken();
+        const options = {
+            method: 'POST',
+            ...(authToken && {
+                headers: { Authorization: `Basic ${authToken}` },
+            }),
+        };
+        return fetch(url, options).then(async (res) => {
+            if (!res.ok) {
+                throw new Error(`${res.status}: ${res.statusText} - ${await res.text()}`);
+            }
+            return res.text();
+        });
+    }
+    static getIPFSAuthToken() {
+        if (!process.env.IPFS_PROJECT_ID || !process.env.IPFS_PROJECT_SECRET) {
+            return undefined;
+        }
+        else {
+            return Buffer.from(`${process.env.IPFS_PROJECT_ID}:${process.env.IPFS_PROJECT_SECRET}`).toString('base64');
+        }
+    }
+    async fetch(url, opts, numberTries = 1) {
+        let counterTries = 1;
+        let result;
+        while (counterTries <= numberTries) {
+            result = await fetch(url, opts);
+            if (result.ok)
+                return result;
+            counterTries++;
+            await this._sleep(500);
+        }
+        throw new HttpError(`Request ${opts.method} ${url} fail - ${await result.clone().text()}`, result.status);
+    }
+    _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Abi } from 'viem';
+export declare function getPolicy(permissions: any[]): import("@zerodev/permissions").Policy;
+export declare function getPermissions(config: any, functionNames: string[]): any[];
+export declare function getERC20ApprovePermissions(contractAddress: `0x${string}`): {
+    target: `0x${string}`;
+    abi: Abi;
+    functionName: string;
+};
+export declare const getERC20ApprovePolicy: (contractAddress: `0x${string}`) => import("@zerodev/permissions").Policy;
+export declare const getAgentRegistrationPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getPricingPlanRegistrationPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getRegisterAssetsPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getOrderPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getMintNFTPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getBurnNFTPolicy: () => import("@zerodev/permissions").Policy;
+export declare const getRegisterPolicy: () => import("@zerodev/permissions").Policy;
+export declare const buildPolicy: (permissions: string[], contractAddress: `0x${string}`) => import("@zerodev/permissions").Policy;
+export declare const getAllContractsPolicy: (contractAddress: `0x${string}`) => import("@zerodev/permissions").Policy;
+//# sourceMappingURL=ZeroDevPolicies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ZeroDevPolicies.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/ZeroDevPolicies.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,GAAG,EAAY,MAAM,MAAM,CAAA;AAEpC,wBAAgB,SAAS,CAAC,WAAW,EAAE,GAAG,EAAE,yCAK3C;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,SAelE;AAED,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,KAAK,MAAM,EAAE;;SAK/D,GAAG;;EAGZ;AACD,eAAO,MAAM,qBAAqB,GAAI,iBAAiB,KAAK,MAAM,EAAE,0CACV,CAAA;AAE1D,eAAO,MAAM,0BAA0B,6CACwB,CAAA;AAE/D,eAAO,MAAM,gCAAgC,6CACoB,CAAA;AAEjE,eAAO,MAAM,uBAAuB,6CACuC,CAAA;AAE3E,eAAO,MAAM,cAAc,6CACiD,CAAA;AAE5E,eAAO,MAAM,gBAAgB,6CAAkE,CAAA;AAE/F,eAAO,MAAM,gBAAgB,6CAAkE,CAAA;AAE/F,eAAO,MAAM,iBAAiB,6CAS3B,CAAA;AAEH,eAAO,MAAM,WAAW,GAAI,aAAa,MAAM,EAAE,EAAE,iBAAiB,KAAK,MAAM,EAAE,0CAoBhF,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,iBAAiB,KAAK,MAAM,EAAE,0CAcjE,CAAA"}

package/dist/nevermined/utils/ZeroDevPolicies.js

@@ -0,0 +1,78 @@
+import { CallPolicyVersion, toCallPolicy } from '@zerodev/permissions/policies';
+import { assetsRegistryConfig, fixedPaymentTemplateConfig, nft1155CreditsConfig, } from '../../artifacts/generated.js';
+import { parseAbi } from 'viem';
+export function getPolicy(permissions) {
+    return toCallPolicy({
+        policyVersion: CallPolicyVersion.V0_0_4,
+        permissions,
+    });
+}
+export function getPermissions(config, functionNames) {
+    const permissions = [];
+    functionNames.forEach((functionName) => {
+        const abis = config.abi.filter((item) => item.type === 'function' && item.name === functionName);
+        abis.forEach((abi) => {
+            permissions.push({
+                target: config.address,
+                abi: [abi],
+                functionName,
+            });
+        });
+    });
+    return permissions;
+}
+export function getERC20ApprovePermissions(contractAddress) {
+    return {
+        target: contractAddress,
+        abi: parseAbi([
+            'function approve(address spender, uint256 amount) external returns (bool)',
+        ]),
+        functionName: 'approve',
+    };
+}
+export const getERC20ApprovePolicy = (contractAddress) => getPolicy([getERC20ApprovePermissions(contractAddress)]);
+export const getAgentRegistrationPolicy = () => getPolicy(getPermissions(assetsRegistryConfig, ['register']));
+export const getPricingPlanRegistrationPolicy = () => getPolicy(getPermissions(assetsRegistryConfig, ['createPlan']));
+export const getRegisterAssetsPolicy = () => getPolicy(getPermissions(assetsRegistryConfig, ['registerAssetAndPlan']));
+export const getOrderPolicy = () => getPolicy(getPermissions(fixedPaymentTemplateConfig, ['createAgreement']));
+export const getMintNFTPolicy = () => getPolicy(getPermissions(nft1155CreditsConfig, ['mint']));
+export const getBurnNFTPolicy = () => getPolicy(getPermissions(nft1155CreditsConfig, ['burn']));
+export const getRegisterPolicy = () => getPolicy(getPermissions(assetsRegistryConfig, [
+    'register',
+    'createPlan',
+    'registerAssetAndPlan',
+    'addPlanToAsset',
+    'removePlanFromAsset',
+]));
+export const buildPolicy = (permissions, contractAddress) => {
+    const perms = [
+        ...(permissions.includes('register')
+            ? getPermissions(assetsRegistryConfig, [
+                'register',
+                'createPlan',
+                'registerAssetAndPlan',
+                'addPlanToAsset',
+                'removePlanFromAsset',
+            ])
+            : []),
+        ...(permissions.includes('mint') ? getPermissions(nft1155CreditsConfig, ['mint']) : []),
+        ...(permissions.includes('burn') ? getPermissions(nft1155CreditsConfig, ['burn']) : []),
+        ...(permissions.includes('order')
+            ? getPermissions(fixedPaymentTemplateConfig, ['createAgreement'])
+            : []),
+        ...(permissions.includes('order') ? [getERC20ApprovePermissions(contractAddress)] : []),
+    ];
+    return getPolicy(perms);
+};
+export const getAllContractsPolicy = (contractAddress) => getPolicy([
+    ...getPermissions(assetsRegistryConfig, [
+        'register',
+        'createPlan',
+        'registerAssetAndPlan',
+        'addPlanToAsset',
+        'removePlanFromAsset',
+    ]),
+    ...getPermissions(fixedPaymentTemplateConfig, ['createAgreement']),
+    ...getPermissions(nft1155CreditsConfig, ['mint', 'burn']),
+    getERC20ApprovePermissions(contractAddress),
+].filter(Boolean));

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

@@ -0,0 +1,6 @@
+export * from './BlockchainViemUtils.js';
+export * from './JwtUtils.js';
+export * from './SignatureUtils.js';
+export * from './WebServiceConnector.js';
+export * from './ZeroDevPolicies.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nevermined/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA"}

package/dist/nevermined/utils/index.js

@@ -0,0 +1,5 @@
+export * from './BlockchainViemUtils.js';
+export * from './JwtUtils.js';
+export * from './SignatureUtils.js';
+export * from './WebServiceConnector.js';
+export * from './ZeroDevPolicies.js';

package/dist/services/Api.d.ts

@@ -0,0 +1,7 @@
+import { Instantiable, InstantiableConfig } from '../Instantiable.abstract.js';
+export declare class Api extends Instantiable {
+    constructor(config: InstantiableConfig);
+    protected get url(): string | undefined;
+    validateAssertion(clientAssertion: string): Promise<string>;
+}
+//# sourceMappingURL=Api.d.ts.map

package/dist/services/Api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Api.d.ts","sourceRoot":"","sources":["../../src/services/Api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAK9E,qBAAa,GAAI,SAAQ,YAAY;gBACvB,MAAM,EAAE,kBAAkB;IAKtC,SAAS,KAAK,GAAG,uBAEhB;IAEY,iBAAiB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAkBzE"}

package/dist/services/Api.js

@@ -0,0 +1,25 @@
+import { Instantiable } from '../Instantiable.abstract.js';
+import { ApiError, HttpError } from '../errors/NeverminedErrors.js';
+const authPath = '/api/v1/api-keys';
+export class Api extends Instantiable {
+    constructor(config) {
+        super();
+        this.setInstanceConfig(config);
+    }
+    get url() {
+        return this.config.backendUrl;
+    }
+    async validateAssertion(clientAssertion) {
+        try {
+            const response = await this.nevermined.utils.fetch.fetchToken(`${this.url}${authPath}/validate-assertion`, clientAssertion);
+            if (!response.ok) {
+                throw new HttpError(`Error Login - ${response.statusText} ${response.url}`, response.status);
+            }
+            const backendAuthToken = (await response.json()).access_token;
+            return backendAuthToken;
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+}