@nevermined-io/core-kit 0.1.4 → 0.1.5

package/dist/services/Profiles.js

@@ -0,0 +1,84 @@
+import { ApiError, HttpError } from '../errors/NeverminedErrors.js';
+import { Api } from './Api.js';
+const profilePath = '/api/v1/metadata/profiles';
+export class Profiles extends Api {
+    /**
+     * Create user profile
+     */
+    async create(newProfile, backendAuthToken) {
+        const fullUrl = `${this.url}${profilePath}`;
+        try {
+            const response = await this.nevermined.utils.fetch.post(fullUrl, JSON.stringify(newProfile), {
+                Authorization: `Bearer ${backendAuthToken}`,
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new HttpError(`Create profile fail - ${response.statusText} ${response.url}`, response.status);
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Update user profile
+     */
+    async update(userId, profile, backendAuthToken) {
+        const fullUrl = `${this.url}${profilePath}/${userId}`;
+        try {
+            const response = await this.nevermined.utils.fetch.put(fullUrl, JSON.stringify(profile), {
+                Authorization: `Bearer ${backendAuthToken}`,
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new HttpError(`Update profile fail - ${response.statusText} ${response.url}`, response.status);
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async findOneByUserId(userId, backendAuthToken) {
+        const fullUrl = `${this.url}${profilePath}/${userId}`;
+        try {
+            const response = await this.nevermined.utils.fetch.get(fullUrl, {
+                Authorization: `Bearer ${backendAuthToken}`,
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new HttpError(`Find profile with userId ${userId} fail - ${response.statusText} ${response.url}`, response.status);
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async findOneByAddress(address) {
+        const fullUrl = `${this.url}${profilePath}/address/${address}`;
+        try {
+            const response = await this.nevermined.utils.fetch.get(fullUrl);
+            if (response.ok) {
+                return response.json();
+            }
+            throw new HttpError(`Find profile with address ${address} fail - ${response.statusText} ${response.url}`, response.status);
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async disableOneByUserId(userId, backendAuthToken) {
+        const fullUrl = `${this.url}${profilePath}/${userId}`;
+        try {
+            const response = await this.nevermined.utils.fetch.delete(fullUrl, undefined, {
+                Authorization: `Bearer ${backendAuthToken}`,
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new HttpError(`Disable profile with userId ${userId} fail - ${response.statusText} ${response.url}`, response.status);
+        }
+        catch (error) {
+            throw new ApiError(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Api.js';
+export * from './Profiles.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA"}

package/dist/services/index.js

@@ -0,0 +1,2 @@
+export * from './Api.js';
+export * from './Profiles.js';

package/dist/utils/ConversionTypeHelpers.d.ts

@@ -0,0 +1,5 @@
+export declare const zeroX: (input: string) => `0x${string}`;
+export declare const noZeroX: (input: string) => string;
+export declare function zeroXTransformer(input: string | undefined, zeroOutput: boolean): string;
+export declare function toAgentId(input: string | bigint): bigint;
+//# sourceMappingURL=ConversionTypeHelpers.d.ts.map

package/dist/utils/ConversionTypeHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConversionTypeHelpers.d.ts","sourceRoot":"","sources":["../../src/utils/ConversionTypeHelpers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,KAAsC,KAAK,MAAM,EAAE,CAAA;AACtF,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,WAAmC,CAAA;AAExE,wBAAgB,gBAAgB,CAAC,KAAK,oBAAK,EAAE,UAAU,EAAE,OAAO,UAG/D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAMxD"}

package/dist/utils/ConversionTypeHelpers.js

@@ -0,0 +1,30 @@
+import { LoggerInstance } from '../models/Logger.js';
+// Ox transformer
+export const zeroX = (input) => zeroXTransformer(input, true);
+export const noZeroX = (input) => zeroXTransformer(input, false);
+export function zeroXTransformer(input = '', zeroOutput) {
+    const { valid, output } = inputMatch(input, /^(?:0x)*([a-f0-9]+)$/i, 'zeroXTransformer');
+    return (zeroOutput && valid ? '0x' : '') + output;
+}
+export function toAgentId(input) {
+    if (typeof input === 'bigint') {
+        return input;
+    }
+    else {
+        return BigInt(input);
+    }
+}
+// Shared functions
+function inputMatch(input, regexp, conversorName) {
+    if (typeof input !== 'string') {
+        LoggerInstance().debug('Not input string:');
+        LoggerInstance().debug(input);
+        throw new Error(`[${conversorName}] Expected string, input type: ${typeof input}`);
+    }
+    const match = input.match(regexp);
+    if (!match) {
+        LoggerInstance().debug(`[${conversorName}] Input transformation failed for input ${input}.`);
+        return { valid: false, output: input };
+    }
+    return { valid: true, output: match[1] };
+}

package/dist/utils/DeploymentInfo.d.ts

@@ -0,0 +1,15 @@
+export interface DeploymentInfo {
+    version?: string;
+    chainId?: number;
+    contracts: Record<string, string>;
+}
+/**
+ * Get deployment information from generated artifacts.
+ * This includes all contract addresses that are available in the generated.ts file.
+ *
+ * @param chainId - Optional chain ID to include in the response
+ * @param version - Optional version to include in the response
+ * @returns Deployment information with contract addresses
+ */
+export declare function getDeploymentInfo(chainId?: number, version?: string): DeploymentInfo;
+//# sourceMappingURL=DeploymentInfo.d.ts.map

package/dist/utils/DeploymentInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeploymentInfo.d.ts","sourceRoot":"","sources":["../../src/utils/DeploymentInfo.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,cAAc,CA6BpF"}

package/dist/utils/DeploymentInfo.js

@@ -0,0 +1,38 @@
+import { accessManagerAddress, agreementsStoreAddress, assetsRegistryAddress, distributePaymentsConditionAddress, erc2771ForwarderAddress, fiatPaymentTemplateAddress, fiatSettlementConditionAddress, fixedPaymentTemplateAddress, linearPricingAddress, lockPaymentConditionAddress, nft1155CreditsAddress, nft1155ExpirableCreditsAddress, nft1155ExpirableCreditsV2Address, nvmConfigAddress, oneTimeCreatorHookAddress, payAsYouGoTemplateAddress, paymentsVaultAddress, protocolStandardFeesAddress, tokenUtilsAddress, transferCreditsConditionAddress, } from '../artifacts/generated.js';
+/**
+ * Get deployment information from generated artifacts.
+ * This includes all contract addresses that are available in the generated.ts file.
+ *
+ * @param chainId - Optional chain ID to include in the response
+ * @param version - Optional version to include in the response
+ * @returns Deployment information with contract addresses
+ */
+export function getDeploymentInfo(chainId, version) {
+    const contracts = {
+        AccessManager: accessManagerAddress,
+        AgreementsStore: agreementsStoreAddress,
+        AssetsRegistry: assetsRegistryAddress,
+        DistributePaymentsCondition: distributePaymentsConditionAddress,
+        ERC2771Forwarder: erc2771ForwarderAddress,
+        FiatPaymentTemplate: fiatPaymentTemplateAddress,
+        FiatSettlementCondition: fiatSettlementConditionAddress,
+        FixedPaymentTemplate: fixedPaymentTemplateAddress,
+        LinearPricing: linearPricingAddress,
+        LockPaymentCondition: lockPaymentConditionAddress,
+        NFT1155Credits: nft1155CreditsAddress,
+        NFT1155ExpirableCredits: nft1155ExpirableCreditsAddress,
+        NFT1155ExpirableCreditsV2: nft1155ExpirableCreditsV2Address,
+        NVMConfig: nvmConfigAddress,
+        OneTimeCreatorHook: oneTimeCreatorHookAddress,
+        PayAsYouGoTemplate: payAsYouGoTemplateAddress,
+        PaymentsVault: paymentsVaultAddress,
+        ProtocolStandardFees: protocolStandardFeesAddress,
+        TokenUtils: tokenUtilsAddress,
+        TransferCreditsCondition: transferCreditsConditionAddress,
+    };
+    return {
+        ...(version && { version }),
+        ...(chainId && { chainId }),
+        contracts,
+    };
+}

package/dist/utils/Network.d.ts

@@ -0,0 +1,5 @@
+import { type Chain } from 'viem/chains';
+export declare function getNetworkName(networkId: number): Promise<string>;
+export declare function isTestnet(networkId: number): boolean;
+export declare function getChain(networkId: number | undefined): Chain;
+//# sourceMappingURL=Network.d.ts.map

package/dist/utils/Network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Network.d.ts","sourceRoot":"","sources":["../../src/utils/Network.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,KAAK,EAeX,MAAM,aAAa,CAAA;AAGpB,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmEvE;AACD,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAmEpD;AACD,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,CAoF7D"}

package/dist/utils/Network.js

@@ -0,0 +1,224 @@
+import { defineChain } from 'viem';
+import { arbitrum, arbitrumSepolia, aurora, auroraTestnet, base, baseSepolia, celo, celoAlfajores, gnosis, hardhat, mainnet, optimism, polygon, polygonMumbai, } from 'viem/chains';
+import { ContractsError } from '../errors/NeverminedErrors.js';
+export async function getNetworkName(networkId) {
+    switch (networkId) {
+        case 1:
+            return 'mainnet';
+        case 2:
+            return 'morden';
+        case 3:
+            return 'ropsten';
+        case 4:
+            return 'rinkeby';
+        case 5:
+            return 'goerli';
+        case 10:
+            return 'optimism';
+        case 77:
+            return 'poa_sokol';
+        case 99:
+            return 'poa_core';
+        case 42:
+            return 'kovan';
+        case 100:
+            return 'gnosis';
+        case 137:
+            return 'matic';
+        case 1337:
+            return 'geth-localnet';
+        case 3141:
+            return 'hyperspace';
+        case 3338:
+            return 'peaq-mainnet';
+        case 8453:
+            return 'base';
+        case 84532:
+            return 'base-sepolia';
+        case 10200:
+            return 'chiado'; // Gnosis testnet
+        case 31337:
+            return 'geth-localnet';
+        case 8996:
+            return 'spree';
+        case 8997:
+            return 'polygon-localnet';
+        case 8998:
+            return 'hardhat';
+        case 42220:
+            return 'celo';
+        case 44787:
+            return 'celo-alfajores';
+        case 62320:
+            return 'celo-baklava';
+        case 80001:
+            return 'mumbai';
+        case 42161:
+            return 'arbitrum-one';
+        case 421613:
+            return 'arbitrum-goerli';
+        case 421614:
+            return 'arbitrum-sepolia';
+        case 1313161554:
+            return 'aurora';
+        case 1313161555:
+            return 'aurora-testnet';
+        case 1313161556:
+            return 'aurora-betanet';
+        default:
+            throw new ContractsError(`Network with id ${networkId} not supported.`);
+    }
+}
+export function isTestnet(networkId) {
+    switch (networkId) {
+        case 1:
+            return false;
+        case 2:
+            return true;
+        case 3:
+            return true;
+        case 4:
+            return true;
+        case 5:
+            return true;
+        case 10:
+            return false;
+        case 77:
+            return false;
+        case 99:
+            return false;
+        case 42:
+            return true;
+        case 100:
+            return false;
+        case 137:
+            return false;
+        case 1337:
+            return true;
+        case 3141:
+            return true;
+        case 3338:
+            return false;
+        case 8453:
+            return false;
+        case 84532:
+            return true;
+        case 10200:
+            return true;
+        case 31337:
+            return true;
+        case 8996:
+            return true;
+        case 8997:
+            return true;
+        case 8998:
+            return true;
+        case 42220:
+            return false;
+        case 44787:
+            return true;
+        case 62320:
+            return true;
+        case 80001:
+            return true;
+        case 42161:
+            return false;
+        case 421613:
+            return true;
+        case 421614:
+            return true;
+        case 1313161554:
+            return false;
+        case 1313161555:
+            return true;
+        case 1313161556:
+            return true;
+        default:
+            throw new ContractsError(`Network with id ${networkId} not supported.`);
+    }
+}
+export function getChain(networkId) {
+    switch (networkId) {
+        case 1:
+            return mainnet;
+        case 10:
+            return optimism;
+        case 100:
+            return gnosis;
+        case 137:
+            return polygon;
+        case 3338:
+            return defineChain({
+                id: networkId,
+                name: 'peaq-network',
+                nativeCurrency: {
+                    name: 'Peaq',
+                    symbol: 'PEAQ',
+                    decimals: 18,
+                },
+                rpcUrls: {
+                    default: {
+                        http: ['https://evm.peaq.network'],
+                    },
+                },
+            });
+        case 8453:
+            return base;
+        case 84532:
+            return baseSepolia;
+        case 42161:
+            return arbitrum;
+        case 42220:
+            return celo;
+        case 44787:
+            return celoAlfajores;
+        case 80001:
+            return polygonMumbai;
+        case 421614:
+            return arbitrumSepolia;
+        case 1313161554:
+            return aurora;
+        case 1313161555:
+            return auroraTestnet;
+        case 8996:
+        case 8997:
+        case 8998:
+            return defineChain({
+                id: networkId,
+                name: 'Localhost',
+                fees: {
+                    baseFeeMultiplier: 1.2,
+                    //defaultPriorityFee: parseGwei('0.01'),
+                },
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: {
+                    default: {
+                        http: [`http://127.0.0.1:${process.env.ETH_PORT || 18545}`],
+                    },
+                },
+            });
+        case 1337:
+            return defineChain({
+                id: networkId,
+                name: 'geth-localnet',
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: {
+                    default: {
+                        http: ['http://contracts.nevermined.localnet'],
+                    },
+                },
+            });
+        case 31337:
+            return hardhat;
+        default:
+            throw new ContractsError(`Network with id ${networkId} not supported.`);
+    }
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,40 @@
+import { SearchQuery } from '@nvm-monorepo/commons';
+import { URL } from 'whatwg-url';
+interface ECIES {
+    iv: Buffer;
+    ephemPublicKey: Buffer;
+    ciphertext: Buffer;
+    mac: Buffer;
+}
+export declare const buildQuery: (url: string, query?: SearchQuery) => URL;
+export declare const getCircularReplacer: () => (_key: string, value: unknown) => unknown;
+export declare const jsonReplacer: (_key: string, value: unknown) => unknown;
+export declare function getRandomBigInt(bits?: number): bigint;
+export declare function generateId(length?: number): string;
+export declare function generateZeroXId(): `0x${string}`;
+export declare function _sleep(ms: number): Promise<unknown>;
+/**
+ * Wait for balance to be updated after a transaction.
+ * Checks the balance immediately first, then polls with delays if needed.
+ *
+ * @param getBalance - Function that returns the current balance
+ * @param expectedMinBalance - Minimum expected balance
+ * @param maxRetries - Maximum number of retry attempts (default: 5)
+ * @param delayMs - Delay between retries in milliseconds (default: 1000)
+ * @returns The updated balance
+ * @throws Error if balance doesn't reach expected minimum after all retries
+ */
+export declare function waitForBalanceUpdate({ getBalance, expectedMinBalance, maxRetries, delayMs, }: {
+    getBalance: () => Promise<bigint>;
+    expectedMinBalance: bigint;
+    maxRetries?: number;
+    delayMs?: number;
+}): Promise<bigint>;
+export declare function urlSafeBase64Encode(input: Uint8Array): string;
+export declare function urlSafeBase64Decode(input: string): Uint8Array;
+export declare function encryptMessage(message: string, receiverPublicKey: string): Promise<string>;
+export declare function serializeECIES(ecies: ECIES): string;
+export declare function deserializeECIES(serialized: string): ECIES;
+export declare function decryptMessage(encryptedMessage: string, privateKey: string | any): Promise<string>;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utils/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAInD,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAIhC,UAAU,KAAK;IACb,EAAE,EAAE,MAAM,CAAA;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,QAAQ,WAAW,QAY1D,CAAA;AAED,eAAO,MAAM,mBAAmB,SAEtB,MAAM,MAAM,EAAE,OAAO,OAAO,YASrC,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,OAAO,OAAO,YAGxD,CAAA;AAED,wBAAgB,eAAe,CAAC,IAAI,SAAM,GAAG,MAAM,CAWlD;AAED,wBAAgB,UAAU,CAAC,MAAM,SAAK,UAMrC;AAED,wBAAgB,eAAe,IAAI,KAAK,MAAM,EAAE,CAE/C;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,oBAEhC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,kBAAkB,EAClB,UAAc,EACd,OAAc,GACf,EAAE;IACD,UAAU,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IACjC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsBlB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAO7D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAY7D;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,mBAmB9E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,UAoB1C;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,CAyB1D;AAED,wBAAsB,cAAc,CAAC,gBAAgB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,mBAqBtF"}

package/dist/utils/helpers.js

@@ -0,0 +1,189 @@
+import { decrypt, encrypt } from 'eciesjs';
+import { v4 } from 'uuid';
+import { keccak256, toBytes } from 'viem';
+import { URL } from 'whatwg-url';
+import { noZeroX } from './ConversionTypeHelpers.js';
+export const buildQuery = (url, query) => {
+    const fullUrl = new URL(url);
+    if (!query) {
+        return fullUrl;
+    }
+    fullUrl.searchParams.append('sort', decodeURIComponent(JSON.stringify(query.sort)));
+    fullUrl.searchParams.append('offset', query.offset?.toString());
+    fullUrl.searchParams.append('page', query.page?.toString());
+    return fullUrl;
+};
+export const getCircularReplacer = () => {
+    const seen = new WeakSet();
+    return (_key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) {
+                return;
+            }
+            seen.add(value);
+        }
+        return value;
+    };
+};
+export const jsonReplacer = (_key, value) => {
+    // Modify the value or return undefined to exclude the property
+    return typeof value === 'bigint' ? value.toString() : value;
+};
+export function getRandomBigInt(bits = 128) {
+    const bytes = Math.ceil(bits / 8);
+    const array = new Uint8Array(bytes);
+    crypto.getRandomValues(array);
+    let result = 0n;
+    for (const byte of array) {
+        result = (result << 8n) | BigInt(byte);
+    }
+    return result;
+}
+export function generateId(length = 64) {
+    let id = '';
+    while (id.length < length) {
+        id += v4().replace(/-/g, '');
+    }
+    return id.slice(0, length);
+}
+export function generateZeroXId() {
+    return keccak256(toBytes(Math.random().toString()));
+}
+export function _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Wait for balance to be updated after a transaction.
+ * Checks the balance immediately first, then polls with delays if needed.
+ *
+ * @param getBalance - Function that returns the current balance
+ * @param expectedMinBalance - Minimum expected balance
+ * @param maxRetries - Maximum number of retry attempts (default: 5)
+ * @param delayMs - Delay between retries in milliseconds (default: 1000)
+ * @returns The updated balance
+ * @throws Error if balance doesn't reach expected minimum after all retries
+ */
+export async function waitForBalanceUpdate({ getBalance, expectedMinBalance, maxRetries = 5, delayMs = 1000, }) {
+    // Check immediately first (no delay)
+    let currentBalance = await getBalance();
+    if (currentBalance >= expectedMinBalance) {
+        return currentBalance;
+    }
+    // If not satisfied, start polling with delays
+    for (let i = 0; i < maxRetries; i++) {
+        await _sleep(delayMs);
+        currentBalance = await getBalance();
+        if (currentBalance >= expectedMinBalance) {
+            return currentBalance;
+        }
+    }
+    // Failed to reach expected balance
+    throw new Error(`Balance did not reach expected minimum after ${maxRetries} retries. Expected at least ${expectedMinBalance}, got ${currentBalance}`);
+}
+export function urlSafeBase64Encode(input) {
+    let binary = '';
+    const len = input.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(input[i]);
+    }
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export function urlSafeBase64Decode(input) {
+    input = input.replace(/-/g, '+').replace(/_/g, '/');
+    while (input.length % 4) {
+        input += '=';
+    }
+    const binary = atob(input);
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+export async function encryptMessage(message, receiverPublicKey) {
+    const publicKeyBuffer = Buffer.from(noZeroX(receiverPublicKey), 'hex');
+    const messageBuffer = Buffer.from(message);
+    try {
+        const ecies = await encrypt(publicKeyBuffer, messageBuffer);
+        // Handle both cases: when encrypt returns a Buffer or an ECIES object
+        if (Buffer.isBuffer(ecies)) {
+            // If it returns a Buffer, we need to handle it differently
+            // This might be the case with some versions of eciesjs
+            return ecies.toString('base64');
+        }
+        else {
+            // If it returns an ECIES object, serialize it
+            return serializeECIES(ecies);
+        }
+    }
+    catch (error) {
+        throw new Error(`Encryption failed: ${error}`);
+    }
+}
+export function serializeECIES(ecies) {
+    // Validate that all required properties exist
+    if (!ecies || typeof ecies !== 'object') {
+        throw new Error('Invalid ECIES object: must be a valid object');
+    }
+    const requiredProps = ['iv', 'ephemPublicKey', 'ciphertext', 'mac'];
+    for (const prop of requiredProps) {
+        if (!ecies[prop]) {
+            throw new Error(`Invalid ECIES object: missing required property '${prop}'`);
+        }
+    }
+    const serialized = JSON.stringify({
+        iv: Buffer.from(ecies.iv).toString('base64'),
+        ephemPublicKey: Buffer.from(ecies.ephemPublicKey).toString('base64'),
+        ciphertext: Buffer.from(ecies.ciphertext).toString('base64'),
+        mac: Buffer.from(ecies.mac).toString('base64'),
+    });
+    return serialized;
+}
+export function deserializeECIES(serialized) {
+    if (!serialized || typeof serialized !== 'string') {
+        throw new Error('Invalid serialized ECIES: must be a valid string');
+    }
+    let _obj;
+    try {
+        _obj = JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new Error('Invalid serialized ECIES: not a valid JSON string');
+    }
+    const requiredProps = ['iv', 'ephemPublicKey', 'ciphertext', 'mac'];
+    for (const prop of requiredProps) {
+        if (!_obj[prop]) {
+            throw new Error(`Invalid serialized ECIES: missing required property '${prop}'`);
+        }
+    }
+    return {
+        iv: Buffer.from(_obj.iv, 'base64'),
+        ephemPublicKey: Buffer.from(_obj.ephemPublicKey, 'base64'),
+        ciphertext: Buffer.from(_obj.ciphertext, 'base64'),
+        mac: Buffer.from(_obj.mac, 'base64'),
+    };
+}
+export async function decryptMessage(encryptedMessage, privateKey) {
+    const pk = typeof privateKey === 'string' ? noZeroX(privateKey) : privateKey;
+    const privateKeyBuffer = Buffer.from(pk, 'hex');
+    // Try to parse as JSON first (ECIES object)
+    try {
+        const ecies = deserializeECIES(encryptedMessage);
+        // For eciesjs, we need to serialize the ECIES object back to a buffer
+        const eciesBuffer = Buffer.concat([ecies.iv, ecies.ephemPublicKey, ecies.ciphertext, ecies.mac]);
+        const decrypted = await decrypt(privateKeyBuffer, eciesBuffer);
+        return decrypted.toString();
+    }
+    catch (error) {
+        // If JSON parsing fails, try as base64 Buffer
+        try {
+            const encryptedBuffer = Buffer.from(encryptedMessage, 'base64');
+            const decrypted = await decrypt(privateKeyBuffer, encryptedBuffer);
+            return decrypted.toString();
+        }
+        catch (secondError) {
+            throw new Error(`Failed to decrypt message: ${secondError}`);
+        }
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ConversionTypeHelpers.js';
+export * from './DeploymentInfo.js';
+export * from './helpers.js';
+export * from './Network.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}