@autonomys/auto-utils 1.5.1 → 1.5.3

package/dist/address.d.ts

@@ -1,3 +1,57 @@
+/**
+ * Converts an address to the standard Autonomys Network format with SS58 encoding.
+ *
+ * This function standardizes addresses across the Autonomys Network by encoding them
+ * using the SS58 format. It accepts both string addresses and Uint8Array representations,
+ * making it flexible for various use cases.
+ *
+ * @param address - The address to convert. Can be a string address or Uint8Array public key.
+ * @param ss58Format - The SS58 format number to use for encoding. Defaults to the mainnet format.
+ * @returns The standardized address string in SS58 format.
+ *
+ * @example
+ * import { address } from '@autonomys/auto-utils'
+ *
+ * // Convert a raw address to mainnet format
+ * const mainnetAddress = address('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+ * console.log(mainnetAddress) // Output: standardized mainnet address
+ *
+ * // Convert using custom SS58 format
+ * const customAddress = address('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 42)
+ * console.log(customAddress) // Output: address in format 42
+ *
+ * // Convert from Uint8Array public key
+ * const publicKey = new Uint8Array(32) // 32-byte public key
+ * const addressFromPubKey = address(publicKey)
+ * console.log(addressFromPubKey) // Output: standardized address
+ *
+ * @throws {Error} When the input address is invalid or cannot be encoded.
+ */
 export declare const address: (address: string | Uint8Array, ss58Format?: number) => string;
+/**
+ * Decodes an SS58 address to its raw Uint8Array representation.
+ *
+ * This function extracts the underlying public key bytes from an SS58-encoded address.
+ * It's useful when you need to work with the raw address data for cryptographic operations
+ * or when interfacing with lower-level blockchain functions.
+ *
+ * @param address - The SS58-encoded address string to decode.
+ * @returns The decoded address as a Uint8Array (32 bytes for most address types).
+ *
+ * @example
+ * import { decode } from '@autonomys/auto-utils'
+ *
+ * // Decode a mainnet address
+ * const addressString = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+ * const publicKeyBytes = decode(addressString)
+ * console.log(publicKeyBytes) // Output: Uint8Array(32) [...]
+ * console.log(publicKeyBytes.length) // Output: 32
+ *
+ * // Use decoded bytes for cryptographic operations
+ * const decoded = decode('5GmS1wtCfR4tK5SSgnZbVT4kYw5W8NmxmijcsxCQE6oLW6A8')
+ * // decoded can now be used with other crypto functions
+ *
+ * @throws {Error} When the address is invalid, malformed, or has an incorrect checksum.
+ */
 export declare const decode: (address: string) => Uint8Array;
 //# sourceMappingURL=address.d.ts.map

package/dist/address.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,GAClB,SAAS,MAAM,GAAG,UAAU,EAC5B,aAAY,MAA4B,KACvC,MAA4C,CAAA;AAE/C,eAAO,MAAM,MAAM,GAAI,SAAS,MAAM,KAAG,UAAoC,CAAA"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,MAAM,GAAG,UAAU,EAC5B,aAAY,MAA4B,KACvC,MAA4C,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,MAAM,KAAG,UAAoC,CAAA"}

package/dist/address.js

@@ -4,7 +4,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode = exports.address = void 0;
 const keyring_1 = require("@polkadot/keyring");
 const wallet_1 = require("./constants/wallet");
+/**
+ * Converts an address to the standard Autonomys Network format with SS58 encoding.
+ *
+ * This function standardizes addresses across the Autonomys Network by encoding them
+ * using the SS58 format. It accepts both string addresses and Uint8Array representations,
+ * making it flexible for various use cases.
+ *
+ * @param address - The address to convert. Can be a string address or Uint8Array public key.
+ * @param ss58Format - The SS58 format number to use for encoding. Defaults to the mainnet format.
+ * @returns The standardized address string in SS58 format.
+ *
+ * @example
+ * import { address } from '@autonomys/auto-utils'
+ *
+ * // Convert a raw address to mainnet format
+ * const mainnetAddress = address('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+ * console.log(mainnetAddress) // Output: standardized mainnet address
+ *
+ * // Convert using custom SS58 format
+ * const customAddress = address('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 42)
+ * console.log(customAddress) // Output: address in format 42
+ *
+ * // Convert from Uint8Array public key
+ * const publicKey = new Uint8Array(32) // 32-byte public key
+ * const addressFromPubKey = address(publicKey)
+ * console.log(addressFromPubKey) // Output: standardized address
+ *
+ * @throws {Error} When the input address is invalid or cannot be encoded.
+ */
 const address = (address, ss58Format = wallet_1.DEFAULT_SS58_FORMAT) => (0, keyring_1.encodeAddress)(address, ss58Format);
 exports.address = address;
+/**
+ * Decodes an SS58 address to its raw Uint8Array representation.
+ *
+ * This function extracts the underlying public key bytes from an SS58-encoded address.
+ * It's useful when you need to work with the raw address data for cryptographic operations
+ * or when interfacing with lower-level blockchain functions.
+ *
+ * @param address - The SS58-encoded address string to decode.
+ * @returns The decoded address as a Uint8Array (32 bytes for most address types).
+ *
+ * @example
+ * import { decode } from '@autonomys/auto-utils'
+ *
+ * // Decode a mainnet address
+ * const addressString = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+ * const publicKeyBytes = decode(addressString)
+ * console.log(publicKeyBytes) // Output: Uint8Array(32) [...]
+ * console.log(publicKeyBytes.length) // Output: 32
+ *
+ * // Use decoded bytes for cryptographic operations
+ * const decoded = decode('5GmS1wtCfR4tK5SSgnZbVT4kYw5W8NmxmijcsxCQE6oLW6A8')
+ * // decoded can now be used with other crypto functions
+ *
+ * @throws {Error} When the address is invalid, malformed, or has an incorrect checksum.
+ */
 const decode = (address) => (0, keyring_1.decodeAddress)(address);
 exports.decode = decode;

package/dist/api.d.ts

@@ -1,7 +1,155 @@
 import { ApiPromise } from '@polkadot/api';
 import { ActivateParams, ApiOptions, DomainParams, NetworkParams } from './types/network';
+/**
+ * Creates a connection to a Polkadot.js API instance with WebSocket provider.
+ *
+ * This function establishes a WebSocket connection to the Autonomys Network or domain
+ * and returns a fully initialized ApiPromise instance. It automatically includes
+ * the necessary chain types and waits for the API to be ready before returning.
+ *
+ * @param endpoint - The WebSocket endpoint URL(s) to connect to. Can be a single URL or array of URLs.
+ * @param options - Optional configuration for the API instance.
+ * @returns A Promise that resolves to an initialized ApiPromise instance.
+ *
+ * @example
+ * import { createConnection } from '@autonomys/auto-utils'
+ *
+ * // Connect to single endpoint
+ * const api = await createConnection('wss://rpc-0.taurus.autonomys.xyz/ws')
+ * console.log('Connected to API')
+ *
+ * // Connect with multiple endpoints for failover
+ * const endpoints = [
+ *   'wss://rpc-0.taurus.autonomys.xyz/ws',
+ *   'wss://rpc-1.taurus.autonomys.xyz/ws'
+ * ]
+ * const apiWithFailover = await createConnection(endpoints)
+ *
+ * // Connect with custom options
+ * const customApi = await createConnection(
+ *   'wss://rpc-0.taurus.autonomys.xyz/ws',
+ *   {
+ *     noInitWarn: false,
+ *     types: { CustomType: 'u32' }
+ *   }
+ * )
+ *
+ * // Always disconnect when done
+ * await api.disconnect()
+ *
+ * @throws {Error} When connection fails or API initialization fails.
+ */
 export declare const createConnection: (endpoint: string | string[], options?: ApiOptions) => Promise<ApiPromise>;
+/**
+ * Activates a connection to the Autonomys Network consensus layer.
+ *
+ * This function simplifies connecting to the Autonomys Network by automatically
+ * resolving the network RPC URLs and establishing a connection. It supports all
+ * available networks including mainnet, testnet, and local development networks.
+ *
+ * @param params - Optional network activation parameters including networkId and API options.
+ * @returns A Promise that resolves to an initialized ApiPromise instance for the consensus layer.
+ *
+ * @example
+ * import { activate } from '@autonomys/auto-utils'
+ *
+ * // Connect to default network (mainnet)
+ * const api = await activate()
+ * console.log('Connected to mainnet')
+ *
+ * // Connect to specific network
+ * const taurusApi = await activate({ networkId: 'taurus' })
+ * console.log('Connected to Taurus testnet')
+ *
+ * // Connect to local development network
+ * const localApi = await activate({ networkId: 'localhost' })
+ * console.log('Connected to localhost')
+ *
+ * // Connect with custom API options
+ * const customApi = await activate({
+ *   networkId: 'gemini-3h',
+ *   noInitWarn: false,
+ *   types: { CustomType: 'u64' }
+ * })
+ *
+ * // Always disconnect when done
+ * await api.disconnect()
+ *
+ * @throws {Error} When the specified network is not found or connection fails.
+ */
 export declare const activate: (params?: ActivateParams<NetworkParams>) => Promise<ApiPromise>;
+/**
+ * Activates a connection to a specific domain within the Autonomys Network.
+ *
+ * This function connects to domain-specific networks like Auto-EVM or Auto-ID
+ * which run as domains on top of the Autonomys consensus layer. Each domain
+ * has its own RPC endpoints and may have domain-specific functionality.
+ *
+ * @param params - Domain activation parameters including networkId, domainId, and API options.
+ * @returns A Promise that resolves to an initialized ApiPromise instance for the specified domain.
+ *
+ * @example
+ * import { activateDomain } from '@autonomys/auto-utils'
+ *
+ * // Connect to Auto-EVM domain on Taurus testnet
+ * const evmApi = await activateDomain({
+ *   networkId: 'taurus',
+ *   domainId: '0'
+ * })
+ * console.log('Connected to Auto-EVM domain')
+ *
+ * // Connect to Auto-ID domain on Gemini-3H
+ * const autoIdApi = await activateDomain({
+ *   networkId: 'gemini-3h',
+ *   domainId: '1'
+ * })
+ * console.log('Connected to Auto-ID domain')
+ *
+ * // Connect to localhost domain for development
+ * const localDomainApi = await activateDomain({
+ *   networkId: 'localhost',
+ *   domainId: '0'
+ * })
+ *
+ * // Connect with custom API options
+ * const customDomainApi = await activateDomain({
+ *   networkId: 'taurus',
+ *   domainId: '0',
+ *   noInitWarn: false
+ * })
+ *
+ * // Always disconnect when done
+ * await evmApi.disconnect()
+ *
+ * @throws {Error} When the specified network or domain is not found, or connection fails.
+ */
 export declare const activateDomain: (params: ActivateParams<DomainParams>) => Promise<ApiPromise>;
+/**
+ * Disconnects an active API connection and cleans up resources.
+ *
+ * This function properly closes the WebSocket connection and cleans up any
+ * resources associated with the API instance. It should always be called
+ * when you're done using an API connection to prevent resource leaks.
+ *
+ * @param api - The ApiPromise instance to disconnect.
+ * @returns A Promise that resolves when the disconnection is complete.
+ *
+ * @example
+ * import { activate, disconnect } from '@autonomys/auto-utils'
+ *
+ * // Connect and then disconnect
+ * const api = await activate({ networkId: 'taurus' })
+ *
+ * // Use the API for operations...
+ * const chainInfo = await api.rpc.system.chain()
+ * console.log('Chain:', chainInfo.toString())
+ *
+ * // Always disconnect when done
+ * await disconnect(api)
+ * console.log('API disconnected')
+ *
+ * // Or use the API instance method directly
+ * // await api.disconnect()
+ */
 export declare const disconnect: (api: ApiPromise) => Promise<void>;
 //# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAA;AAEtD,OAAO,EACL,cAAc,EACd,UAAU,EAEV,YAAY,EACZ,aAAa,EACd,MAAM,iBAAiB,CAAA;AAExB,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,GAAG,MAAM,EAAE,EAC3B,UAAU,UAAU,KACnB,OAAO,CAAC,UAAU,CAapB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAU,SAAS,cAAc,CAAC,aAAa,CAAC,KAAG,OAAO,CAAC,UAAU,CAOzF,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,QAAQ,cAAc,CAAC,YAAY,CAAC,KAAG,OAAO,CAAC,UAAU,CAQ7F,CAAA;AAED,eAAO,MAAM,UAAU,GAAU,KAAK,UAAU,KAAG,OAAO,CAAC,IAAI,CAG9D,CAAA"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAA;AAEtD,OAAO,EACL,cAAc,EACd,UAAU,EAEV,YAAY,EACZ,aAAa,EACd,MAAM,iBAAiB,CAAA;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,GAAG,MAAM,EAAE,EAC3B,UAAU,UAAU,KACnB,OAAO,CAAC,UAAU,CAapB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,QAAQ,GAAU,SAAS,cAAc,CAAC,aAAa,CAAC,KAAG,OAAO,CAAC,UAAU,CAOzF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,cAAc,GAAU,QAAQ,cAAc,CAAC,YAAY,CAAC,KAAG,OAAO,CAAC,UAAU,CAQ7F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU,GAAU,KAAK,UAAU,KAAG,OAAO,CAAC,IAAI,CAG9D,CAAA"}

package/dist/api.js

@@ -24,6 +24,45 @@ exports.disconnect = exports.activateDomain = exports.activate = exports.createC
 const api_1 = require("@polkadot/api");
 const network_1 = require("./network");
 const network_2 = require("./types/network");
+/**
+ * Creates a connection to a Polkadot.js API instance with WebSocket provider.
+ *
+ * This function establishes a WebSocket connection to the Autonomys Network or domain
+ * and returns a fully initialized ApiPromise instance. It automatically includes
+ * the necessary chain types and waits for the API to be ready before returning.
+ *
+ * @param endpoint - The WebSocket endpoint URL(s) to connect to. Can be a single URL or array of URLs.
+ * @param options - Optional configuration for the API instance.
+ * @returns A Promise that resolves to an initialized ApiPromise instance.
+ *
+ * @example
+ * import { createConnection } from '@autonomys/auto-utils'
+ *
+ * // Connect to single endpoint
+ * const api = await createConnection('wss://rpc-0.taurus.autonomys.xyz/ws')
+ * console.log('Connected to API')
+ *
+ * // Connect with multiple endpoints for failover
+ * const endpoints = [
+ *   'wss://rpc-0.taurus.autonomys.xyz/ws',
+ *   'wss://rpc-1.taurus.autonomys.xyz/ws'
+ * ]
+ * const apiWithFailover = await createConnection(endpoints)
+ *
+ * // Connect with custom options
+ * const customApi = await createConnection(
+ *   'wss://rpc-0.taurus.autonomys.xyz/ws',
+ *   {
+ *     noInitWarn: false,
+ *     types: { CustomType: 'u32' }
+ *   }
+ * )
+ *
+ * // Always disconnect when done
+ * await api.disconnect()
+ *
+ * @throws {Error} When connection fails or API initialization fails.
+ */
 const createConnection = (endpoint, options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     // Create the provider
@@ -34,6 +73,43 @@ const createConnection = (endpoint, options) => __awaiter(void 0, void 0, void 0
     return api;
 });
 exports.createConnection = createConnection;
+/**
+ * Activates a connection to the Autonomys Network consensus layer.
+ *
+ * This function simplifies connecting to the Autonomys Network by automatically
+ * resolving the network RPC URLs and establishing a connection. It supports all
+ * available networks including mainnet, testnet, and local development networks.
+ *
+ * @param params - Optional network activation parameters including networkId and API options.
+ * @returns A Promise that resolves to an initialized ApiPromise instance for the consensus layer.
+ *
+ * @example
+ * import { activate } from '@autonomys/auto-utils'
+ *
+ * // Connect to default network (mainnet)
+ * const api = await activate()
+ * console.log('Connected to mainnet')
+ *
+ * // Connect to specific network
+ * const taurusApi = await activate({ networkId: 'taurus' })
+ * console.log('Connected to Taurus testnet')
+ *
+ * // Connect to local development network
+ * const localApi = await activate({ networkId: 'localhost' })
+ * console.log('Connected to localhost')
+ *
+ * // Connect with custom API options
+ * const customApi = await activate({
+ *   networkId: 'gemini-3h',
+ *   noInitWarn: false,
+ *   types: { CustomType: 'u64' }
+ * })
+ *
+ * // Always disconnect when done
+ * await api.disconnect()
+ *
+ * @throws {Error} When the specified network is not found or connection fails.
+ */
 const activate = (params) => __awaiter(void 0, void 0, void 0, function* () {
     // Get the first rpc urls for the network
     const endpoint = (0, network_1.getNetworkRpcUrls)(params);
@@ -43,6 +119,51 @@ const activate = (params) => __awaiter(void 0, void 0, void 0, function* () {
     return yield (0, exports.createConnection)(endpoint, params);
 });
 exports.activate = activate;
+/**
+ * Activates a connection to a specific domain within the Autonomys Network.
+ *
+ * This function connects to domain-specific networks like Auto-EVM or Auto-ID
+ * which run as domains on top of the Autonomys consensus layer. Each domain
+ * has its own RPC endpoints and may have domain-specific functionality.
+ *
+ * @param params - Domain activation parameters including networkId, domainId, and API options.
+ * @returns A Promise that resolves to an initialized ApiPromise instance for the specified domain.
+ *
+ * @example
+ * import { activateDomain } from '@autonomys/auto-utils'
+ *
+ * // Connect to Auto-EVM domain on Taurus testnet
+ * const evmApi = await activateDomain({
+ *   networkId: 'taurus',
+ *   domainId: '0'
+ * })
+ * console.log('Connected to Auto-EVM domain')
+ *
+ * // Connect to Auto-ID domain on Gemini-3H
+ * const autoIdApi = await activateDomain({
+ *   networkId: 'gemini-3h',
+ *   domainId: '1'
+ * })
+ * console.log('Connected to Auto-ID domain')
+ *
+ * // Connect to localhost domain for development
+ * const localDomainApi = await activateDomain({
+ *   networkId: 'localhost',
+ *   domainId: '0'
+ * })
+ *
+ * // Connect with custom API options
+ * const customDomainApi = await activateDomain({
+ *   networkId: 'taurus',
+ *   domainId: '0',
+ *   noInitWarn: false
+ * })
+ *
+ * // Always disconnect when done
+ * await evmApi.disconnect()
+ *
+ * @throws {Error} When the specified network or domain is not found, or connection fails.
+ */
 const activateDomain = (params) => __awaiter(void 0, void 0, void 0, function* () {
     // Get the first rpc urls for the network
     const endpoint = (0, network_1.getNetworkDomainRpcUrls)(params);
@@ -52,6 +173,33 @@ const activateDomain = (params) => __awaiter(void 0, void 0, void 0, function* (
     return yield (0, exports.createConnection)(endpoint, rest);
 });
 exports.activateDomain = activateDomain;
+/**
+ * Disconnects an active API connection and cleans up resources.
+ *
+ * This function properly closes the WebSocket connection and cleans up any
+ * resources associated with the API instance. It should always be called
+ * when you're done using an API connection to prevent resource leaks.
+ *
+ * @param api - The ApiPromise instance to disconnect.
+ * @returns A Promise that resolves when the disconnection is complete.
+ *
+ * @example
+ * import { activate, disconnect } from '@autonomys/auto-utils'
+ *
+ * // Connect and then disconnect
+ * const api = await activate({ networkId: 'taurus' })
+ *
+ * // Use the API for operations...
+ * const chainInfo = await api.rpc.system.chain()
+ * console.log('Chain:', chainInfo.toString())
+ *
+ * // Always disconnect when done
+ * await disconnect(api)
+ * console.log('API disconnected')
+ *
+ * // Or use the API instance method directly
+ * // await api.disconnect()
+ */
 const disconnect = (api) => __awaiter(void 0, void 0, void 0, function* () {
     // Disconnect the API instance and the provider
     yield api.disconnect();

package/dist/crypto.d.ts

@@ -23,6 +23,34 @@ export declare function blake2b_256(data: Uint8Array): string;
 export declare function stringToUint8Array(text: string): Uint8Array;
 /**
  * Concatenates two Uint8Array instances into a single Uint8Array.
+ *
+ * This function efficiently combines two byte arrays into a single array, preserving
+ * the order of the input arrays. It's commonly used for combining data before hashing,
+ * creating composite data structures, or preparing data for cryptographic operations.
+ *
+ * @param array1 - The first Uint8Array to concatenate.
+ * @param array2 - The second Uint8Array to concatenate.
+ * @returns A new Uint8Array containing all bytes from array1 followed by all bytes from array2.
+ *
+ * @example
+ * import { stringToUint8Array, concatenateUint8Arrays } from '@autonomys/auto-utils'
+ *
+ * // Concatenate two strings as byte arrays
+ * const part1 = stringToUint8Array('Hello, ')
+ * const part2 = stringToUint8Array('Autonomys!')
+ * const combined = concatenateUint8Arrays(part1, part2)
+ *
+ * // Convert back to string to verify
+ * const result = new TextDecoder().decode(combined)
+ * console.log(result) // Output: "Hello, Autonomys!"
+ * console.log(combined.length) // Output: 16 (total length of both arrays)
+ *
+ * // Concatenate with hash data
+ * const data1 = stringToUint8Array('message1')
+ * const data2 = stringToUint8Array('message2')
+ * const combinedData = concatenateUint8Arrays(data1, data2)
+ * const hash = blake2b_256(combinedData)
+ * console.log(hash) // Output: hash of combined data
  */
 export declare function concatenateUint8Arrays(array1: Uint8Array, array2: Uint8Array): Uint8Array;
 //# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAG3D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAKzF"}
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAG3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAKzF"}

package/dist/crypto.js

@@ -35,6 +35,34 @@ function stringToUint8Array(text) {
 }
 /**
  * Concatenates two Uint8Array instances into a single Uint8Array.
+ *
+ * This function efficiently combines two byte arrays into a single array, preserving
+ * the order of the input arrays. It's commonly used for combining data before hashing,
+ * creating composite data structures, or preparing data for cryptographic operations.
+ *
+ * @param array1 - The first Uint8Array to concatenate.
+ * @param array2 - The second Uint8Array to concatenate.
+ * @returns A new Uint8Array containing all bytes from array1 followed by all bytes from array2.
+ *
+ * @example
+ * import { stringToUint8Array, concatenateUint8Arrays } from '@autonomys/auto-utils'
+ *
+ * // Concatenate two strings as byte arrays
+ * const part1 = stringToUint8Array('Hello, ')
+ * const part2 = stringToUint8Array('Autonomys!')
+ * const combined = concatenateUint8Arrays(part1, part2)
+ *
+ * // Convert back to string to verify
+ * const result = new TextDecoder().decode(combined)
+ * console.log(result) // Output: "Hello, Autonomys!"
+ * console.log(combined.length) // Output: 16 (total length of both arrays)
+ *
+ * // Concatenate with hash data
+ * const data1 = stringToUint8Array('message1')
+ * const data2 = stringToUint8Array('message2')
+ * const combinedData = concatenateUint8Arrays(data1, data2)
+ * const hash = blake2b_256(combinedData)
+ * console.log(hash) // Output: hash of combined data
  */
 function concatenateUint8Arrays(array1, array2) {
     const combined = new Uint8Array(array1.length + array2.length);