@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.1.0

package/dist/utils/crypto-utils.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var crypto_utils_exports = {};
+__export(crypto_utils_exports, {
+  assertUncompressedPublicKey: () => assertUncompressedPublicKey,
+  bytesEqual: () => bytesEqual,
+  copyBytes: () => copyBytes,
+  generateSeed: () => generateSeed,
+  isValidPrivateKeyFormat: () => isValidPrivateKeyFormat,
+  isValidPublicKeyFormat: () => isValidPublicKeyFormat,
+  parseEncryptedDataBuffer: () => parseEncryptedDataBuffer,
+  processWalletPrivateKey: () => processWalletPrivateKey,
+  processWalletPublicKey: () => processWalletPublicKey
+});
+module.exports = __toCommonJS(crypto_utils_exports);
+var import_viem = require("viem");
+function processWalletPublicKey(publicKey) {
+  return typeof publicKey === "string" ? (0, import_viem.fromHex)(
+    publicKey.startsWith("0x") ? publicKey : `0x${publicKey}`,
+    "bytes"
+  ) : publicKey;
+}
+function processWalletPrivateKey(privateKey) {
+  return typeof privateKey === "string" ? (0, import_viem.fromHex)(
+    privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`,
+    "bytes"
+  ) : privateKey;
+}
+function parseEncryptedDataBuffer(encryptedBuffer) {
+  return {
+    iv: encryptedBuffer.slice(0, 16),
+    ephemPublicKey: encryptedBuffer.slice(16, 81),
+    // 65 bytes for uncompressed public key
+    ciphertext: encryptedBuffer.slice(81, -32),
+    mac: encryptedBuffer.slice(-32)
+  };
+}
+function generateSeed(message) {
+  const encoder = new TextEncoder();
+  return encoder.encode(message);
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function copyBytes(bytes) {
+  return new Uint8Array(bytes);
+}
+function isValidPublicKeyFormat(publicKey) {
+  const len = publicKey.length;
+  if (len === 33) {
+    return publicKey[0] === 2 || publicKey[0] === 3;
+  }
+  if (len === 65) {
+    return publicKey[0] === 4;
+  }
+  if (len === 64) {
+    return true;
+  }
+  return false;
+}
+function isValidPrivateKeyFormat(privateKey) {
+  return privateKey.length === 32;
+}
+function assertUncompressedPublicKey(publicKey) {
+  if (publicKey.length !== 65) {
+    throw new Error(
+      `Public key must be uncompressed (65 bytes), got ${publicKey.length} bytes. Use provider.normalizeToUncompressed() to convert compressed keys.`
+    );
+  }
+  if (publicKey[0] !== 4) {
+    throw new Error(
+      `Uncompressed public key must start with 0x04 prefix, got 0x${publicKey[0].toString(16).padStart(2, "0")}`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertUncompressedPublicKey,
+  bytesEqual,
+  copyBytes,
+  generateSeed,
+  isValidPrivateKeyFormat,
+  isValidPublicKeyFormat,
+  parseEncryptedDataBuffer,
+  processWalletPrivateKey,
+  processWalletPublicKey
+});
+//# sourceMappingURL=crypto-utils.cjs.map

package/dist/utils/crypto-utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/crypto-utils.ts"],"sourcesContent":["/**\n * Provides platform-agnostic cryptographic utility functions.\n *\n * @remarks\n * This module contains utility functions for cryptographic operations that work\n * consistently across Node.js and browser environments. All functions use `Uint8Array`\n * exclusively for binary data to ensure cross-platform compatibility.\n *\n * @category Cryptography\n */\n\nimport { fromHex } from \"viem\";\n\n/**\n * Processes a wallet public key for cryptographic operations.\n *\n * @remarks\n * Converts hex string public keys to Uint8Array format.\n * For normalization to uncompressed format, use the crypto provider's\n * normalizeToUncompressed method.\n *\n * @param publicKey - The wallet public key as hex string or byte array.\n * @returns The public key as a Uint8Array.\n *\n * @example\n * ```typescript\n * const keyBytes = processWalletPublicKey(\"0x04...\");\n * const normalized = provider.normalizeToUncompressed(keyBytes);\n * ```\n */\nexport function processWalletPublicKey(\n  publicKey: string | Uint8Array,\n): Uint8Array {\n  // Convert to bytes if hex string\n  return typeof publicKey === \"string\"\n    ? fromHex(\n        (publicKey.startsWith(\"0x\")\n          ? publicKey\n          : `0x${publicKey}`) as `0x${string}`,\n        \"bytes\",\n      )\n    : publicKey;\n}\n\n/**\n * Processes a wallet private key for cryptographic operations.\n *\n * @param privateKey - The wallet private key as hex string or byte array.\n * @returns The private key as a Uint8Array.\n *\n * @example\n * ```typescript\n * const key = processWalletPrivateKey(\"0x...\");\n * console.log(key.length); // 32 (secp256k1 private key)\n * ```\n */\nexport function processWalletPrivateKey(\n  privateKey: string | Uint8Array,\n): Uint8Array {\n  // Convert to bytes\n  return typeof privateKey === \"string\"\n    ? fromHex(\n        (privateKey.startsWith(\"0x\")\n          ? privateKey\n          : `0x${privateKey}`) as `0x${string}`,\n        \"bytes\",\n      )\n    : privateKey;\n}\n\n/**\n * Parses legacy eccrypto-format encrypted data buffer.\n * Format: [iv(16)][ephemPublicKey(65)][ciphertext(variable)][mac(32)]\n *\n * @param encryptedBuffer - Buffer containing encrypted data in eccrypto format\n * @returns Parsed encrypted data components\n */\nexport function parseEncryptedDataBuffer(encryptedBuffer: Uint8Array): {\n  iv: Uint8Array;\n  ephemPublicKey: Uint8Array;\n  ciphertext: Uint8Array;\n  mac: Uint8Array;\n} {\n  return {\n    iv: encryptedBuffer.slice(0, 16),\n    ephemPublicKey: encryptedBuffer.slice(16, 81), // 65 bytes for uncompressed public key\n    ciphertext: encryptedBuffer.slice(81, -32),\n    mac: encryptedBuffer.slice(-32),\n  };\n}\n\n/**\n * Generates a deterministic seed from a message for key derivation\n *\n * @param message - Message to derive seed from\n * @returns Seed as Uint8Array\n */\nexport function generateSeed(message: string): Uint8Array {\n  // Use encoding utils for consistent string-to-bytes conversion\n  const encoder = new TextEncoder();\n  return encoder.encode(message);\n}\n\n/**\n * Compares two Uint8Arrays for equality\n *\n * @param a - First array\n * @param b - Second array\n * @returns True if arrays are equal\n */\nexport function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Creates a copy of a Uint8Array\n *\n * @param bytes - Array to copy\n * @returns New array with same contents\n */\nexport function copyBytes(bytes: Uint8Array): Uint8Array {\n  return new Uint8Array(bytes);\n}\n\n/**\n * Validates a secp256k1 public key format\n *\n * @param publicKey - Public key to validate\n * @returns True if valid format (33, 65, or 64 bytes)\n */\nexport function isValidPublicKeyFormat(publicKey: Uint8Array): boolean {\n  const len = publicKey.length;\n\n  // Compressed (33 bytes)\n  if (len === 33) {\n    return publicKey[0] === 0x02 || publicKey[0] === 0x03;\n  }\n\n  // Uncompressed (65 bytes)\n  if (len === 65) {\n    return publicKey[0] === 0x04;\n  }\n\n  // Raw coordinates (64 bytes - no prefix)\n  if (len === 64) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Validates a secp256k1 private key format\n *\n * @param privateKey - Private key to validate\n * @returns True if valid format (32 bytes)\n */\nexport function isValidPrivateKeyFormat(privateKey: Uint8Array): boolean {\n  return privateKey.length === 32;\n}\n\n/**\n * Asserts that a public key is in uncompressed format (65 bytes with 0x04 prefix).\n * This validation function only checks format, it does not transform keys.\n * For key normalization (including decompression), use the crypto provider's\n * normalizeToUncompressed method.\n *\n * @param publicKey - Public key to validate\n * @throws {Error} When public key is not in uncompressed format\n */\nexport function assertUncompressedPublicKey(publicKey: Uint8Array): void {\n  if (publicKey.length !== 65) {\n    throw new Error(\n      `Public key must be uncompressed (65 bytes), got ${publicKey.length} bytes. ` +\n        `Use provider.normalizeToUncompressed() to convert compressed keys.`,\n    );\n  }\n\n  if (publicKey[0] !== 0x04) {\n    throw new Error(\n      `Uncompressed public key must start with 0x04 prefix, got 0x${publicKey[0].toString(16).padStart(2, \"0\")}`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kBAAwB;AAmBjB,SAAS,uBACd,WACY;AAEZ,SAAO,OAAO,cAAc,eACxB;AAAA,IACG,UAAU,WAAW,IAAI,IACtB,YACA,KAAK,SAAS;AAAA,IAClB;AAAA,EACF,IACA;AACN;AAcO,SAAS,wBACd,YACY;AAEZ,SAAO,OAAO,eAAe,eACzB;AAAA,IACG,WAAW,WAAW,IAAI,IACvB,aACA,KAAK,UAAU;AAAA,IACnB;AAAA,EACF,IACA;AACN;AASO,SAAS,yBAAyB,iBAKvC;AACA,SAAO;AAAA,IACL,IAAI,gBAAgB,MAAM,GAAG,EAAE;AAAA,IAC/B,gBAAgB,gBAAgB,MAAM,IAAI,EAAE;AAAA;AAAA,IAC5C,YAAY,gBAAgB,MAAM,IAAI,GAAG;AAAA,IACzC,KAAK,gBAAgB,MAAM,GAAG;AAAA,EAChC;AACF;AAQO,SAAS,aAAa,SAA6B;AAExD,QAAM,UAAU,IAAI,YAAY;AAChC,SAAO,QAAQ,OAAO,OAAO;AAC/B;AASO,SAAS,WAAW,GAAe,GAAwB;AAChE,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAG,QAAO;AAAA,EAC5B;AACA,SAAO;AACT;AAQO,SAAS,UAAU,OAA+B;AACvD,SAAO,IAAI,WAAW,KAAK;AAC7B;AAQO,SAAS,uBAAuB,WAAgC;AACrE,QAAM,MAAM,UAAU;AAGtB,MAAI,QAAQ,IAAI;AACd,WAAO,UAAU,CAAC,MAAM,KAAQ,UAAU,CAAC,MAAM;AAAA,EACnD;AAGA,MAAI,QAAQ,IAAI;AACd,WAAO,UAAU,CAAC,MAAM;AAAA,EAC1B;AAGA,MAAI,QAAQ,IAAI;AACd,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAQO,SAAS,wBAAwB,YAAiC;AACvE,SAAO,WAAW,WAAW;AAC/B;AAWO,SAAS,4BAA4B,WAA6B;AACvE,MAAI,UAAU,WAAW,IAAI;AAC3B,UAAM,IAAI;AAAA,MACR,mDAAmD,UAAU,MAAM;AAAA,IAErE;AAAA,EACF;AAEA,MAAI,UAAU,CAAC,MAAM,GAAM;AACzB,UAAM,IAAI;AAAA,MACR,8DAA8D,UAAU,CAAC,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,IAC1G;AAAA,EACF;AACF;","names":[]}

package/dist/utils/crypto-utils.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Provides platform-agnostic cryptographic utility functions.
+ *
+ * @remarks
+ * This module contains utility functions for cryptographic operations that work
+ * consistently across Node.js and browser environments. All functions use `Uint8Array`
+ * exclusively for binary data to ensure cross-platform compatibility.
+ *
+ * @category Cryptography
+ */
+/**
+ * Processes a wallet public key for cryptographic operations.
+ *
+ * @remarks
+ * Converts hex string public keys to Uint8Array format.
+ * For normalization to uncompressed format, use the crypto provider's
+ * normalizeToUncompressed method.
+ *
+ * @param publicKey - The wallet public key as hex string or byte array.
+ * @returns The public key as a Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const keyBytes = processWalletPublicKey("0x04...");
+ * const normalized = provider.normalizeToUncompressed(keyBytes);
+ * ```
+ */
+export declare function processWalletPublicKey(publicKey: string | Uint8Array): Uint8Array;
+/**
+ * Processes a wallet private key for cryptographic operations.
+ *
+ * @param privateKey - The wallet private key as hex string or byte array.
+ * @returns The private key as a Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const key = processWalletPrivateKey("0x...");
+ * console.log(key.length); // 32 (secp256k1 private key)
+ * ```
+ */
+export declare function processWalletPrivateKey(privateKey: string | Uint8Array): Uint8Array;
+/**
+ * Parses legacy eccrypto-format encrypted data buffer.
+ * Format: [iv(16)][ephemPublicKey(65)][ciphertext(variable)][mac(32)]
+ *
+ * @param encryptedBuffer - Buffer containing encrypted data in eccrypto format
+ * @returns Parsed encrypted data components
+ */
+export declare function parseEncryptedDataBuffer(encryptedBuffer: Uint8Array): {
+    iv: Uint8Array;
+    ephemPublicKey: Uint8Array;
+    ciphertext: Uint8Array;
+    mac: Uint8Array;
+};
+/**
+ * Generates a deterministic seed from a message for key derivation
+ *
+ * @param message - Message to derive seed from
+ * @returns Seed as Uint8Array
+ */
+export declare function generateSeed(message: string): Uint8Array;
+/**
+ * Compares two Uint8Arrays for equality
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns True if arrays are equal
+ */
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Creates a copy of a Uint8Array
+ *
+ * @param bytes - Array to copy
+ * @returns New array with same contents
+ */
+export declare function copyBytes(bytes: Uint8Array): Uint8Array;
+/**
+ * Validates a secp256k1 public key format
+ *
+ * @param publicKey - Public key to validate
+ * @returns True if valid format (33, 65, or 64 bytes)
+ */
+export declare function isValidPublicKeyFormat(publicKey: Uint8Array): boolean;
+/**
+ * Validates a secp256k1 private key format
+ *
+ * @param privateKey - Private key to validate
+ * @returns True if valid format (32 bytes)
+ */
+export declare function isValidPrivateKeyFormat(privateKey: Uint8Array): boolean;
+/**
+ * Asserts that a public key is in uncompressed format (65 bytes with 0x04 prefix).
+ * This validation function only checks format, it does not transform keys.
+ * For key normalization (including decompression), use the crypto provider's
+ * normalizeToUncompressed method.
+ *
+ * @param publicKey - Public key to validate
+ * @throws {Error} When public key is not in uncompressed format
+ */
+export declare function assertUncompressedPublicKey(publicKey: Uint8Array): void;

package/dist/utils/crypto-utils.js

@@ -0,0 +1,76 @@
+import { fromHex } from "viem";
+function processWalletPublicKey(publicKey) {
+  return typeof publicKey === "string" ? fromHex(
+    publicKey.startsWith("0x") ? publicKey : `0x${publicKey}`,
+    "bytes"
+  ) : publicKey;
+}
+function processWalletPrivateKey(privateKey) {
+  return typeof privateKey === "string" ? fromHex(
+    privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`,
+    "bytes"
+  ) : privateKey;
+}
+function parseEncryptedDataBuffer(encryptedBuffer) {
+  return {
+    iv: encryptedBuffer.slice(0, 16),
+    ephemPublicKey: encryptedBuffer.slice(16, 81),
+    // 65 bytes for uncompressed public key
+    ciphertext: encryptedBuffer.slice(81, -32),
+    mac: encryptedBuffer.slice(-32)
+  };
+}
+function generateSeed(message) {
+  const encoder = new TextEncoder();
+  return encoder.encode(message);
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function copyBytes(bytes) {
+  return new Uint8Array(bytes);
+}
+function isValidPublicKeyFormat(publicKey) {
+  const len = publicKey.length;
+  if (len === 33) {
+    return publicKey[0] === 2 || publicKey[0] === 3;
+  }
+  if (len === 65) {
+    return publicKey[0] === 4;
+  }
+  if (len === 64) {
+    return true;
+  }
+  return false;
+}
+function isValidPrivateKeyFormat(privateKey) {
+  return privateKey.length === 32;
+}
+function assertUncompressedPublicKey(publicKey) {
+  if (publicKey.length !== 65) {
+    throw new Error(
+      `Public key must be uncompressed (65 bytes), got ${publicKey.length} bytes. Use provider.normalizeToUncompressed() to convert compressed keys.`
+    );
+  }
+  if (publicKey[0] !== 4) {
+    throw new Error(
+      `Uncompressed public key must start with 0x04 prefix, got 0x${publicKey[0].toString(16).padStart(2, "0")}`
+    );
+  }
+}
+export {
+  assertUncompressedPublicKey,
+  bytesEqual,
+  copyBytes,
+  generateSeed,
+  isValidPrivateKeyFormat,
+  isValidPublicKeyFormat,
+  parseEncryptedDataBuffer,
+  processWalletPrivateKey,
+  processWalletPublicKey
+};
+//# sourceMappingURL=crypto-utils.js.map

package/dist/utils/crypto-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/crypto-utils.ts"],"sourcesContent":["/**\n * Provides platform-agnostic cryptographic utility functions.\n *\n * @remarks\n * This module contains utility functions for cryptographic operations that work\n * consistently across Node.js and browser environments. All functions use `Uint8Array`\n * exclusively for binary data to ensure cross-platform compatibility.\n *\n * @category Cryptography\n */\n\nimport { fromHex } from \"viem\";\n\n/**\n * Processes a wallet public key for cryptographic operations.\n *\n * @remarks\n * Converts hex string public keys to Uint8Array format.\n * For normalization to uncompressed format, use the crypto provider's\n * normalizeToUncompressed method.\n *\n * @param publicKey - The wallet public key as hex string or byte array.\n * @returns The public key as a Uint8Array.\n *\n * @example\n * ```typescript\n * const keyBytes = processWalletPublicKey(\"0x04...\");\n * const normalized = provider.normalizeToUncompressed(keyBytes);\n * ```\n */\nexport function processWalletPublicKey(\n  publicKey: string | Uint8Array,\n): Uint8Array {\n  // Convert to bytes if hex string\n  return typeof publicKey === \"string\"\n    ? fromHex(\n        (publicKey.startsWith(\"0x\")\n          ? publicKey\n          : `0x${publicKey}`) as `0x${string}`,\n        \"bytes\",\n      )\n    : publicKey;\n}\n\n/**\n * Processes a wallet private key for cryptographic operations.\n *\n * @param privateKey - The wallet private key as hex string or byte array.\n * @returns The private key as a Uint8Array.\n *\n * @example\n * ```typescript\n * const key = processWalletPrivateKey(\"0x...\");\n * console.log(key.length); // 32 (secp256k1 private key)\n * ```\n */\nexport function processWalletPrivateKey(\n  privateKey: string | Uint8Array,\n): Uint8Array {\n  // Convert to bytes\n  return typeof privateKey === \"string\"\n    ? fromHex(\n        (privateKey.startsWith(\"0x\")\n          ? privateKey\n          : `0x${privateKey}`) as `0x${string}`,\n        \"bytes\",\n      )\n    : privateKey;\n}\n\n/**\n * Parses legacy eccrypto-format encrypted data buffer.\n * Format: [iv(16)][ephemPublicKey(65)][ciphertext(variable)][mac(32)]\n *\n * @param encryptedBuffer - Buffer containing encrypted data in eccrypto format\n * @returns Parsed encrypted data components\n */\nexport function parseEncryptedDataBuffer(encryptedBuffer: Uint8Array): {\n  iv: Uint8Array;\n  ephemPublicKey: Uint8Array;\n  ciphertext: Uint8Array;\n  mac: Uint8Array;\n} {\n  return {\n    iv: encryptedBuffer.slice(0, 16),\n    ephemPublicKey: encryptedBuffer.slice(16, 81), // 65 bytes for uncompressed public key\n    ciphertext: encryptedBuffer.slice(81, -32),\n    mac: encryptedBuffer.slice(-32),\n  };\n}\n\n/**\n * Generates a deterministic seed from a message for key derivation\n *\n * @param message - Message to derive seed from\n * @returns Seed as Uint8Array\n */\nexport function generateSeed(message: string): Uint8Array {\n  // Use encoding utils for consistent string-to-bytes conversion\n  const encoder = new TextEncoder();\n  return encoder.encode(message);\n}\n\n/**\n * Compares two Uint8Arrays for equality\n *\n * @param a - First array\n * @param b - Second array\n * @returns True if arrays are equal\n */\nexport function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Creates a copy of a Uint8Array\n *\n * @param bytes - Array to copy\n * @returns New array with same contents\n */\nexport function copyBytes(bytes: Uint8Array): Uint8Array {\n  return new Uint8Array(bytes);\n}\n\n/**\n * Validates a secp256k1 public key format\n *\n * @param publicKey - Public key to validate\n * @returns True if valid format (33, 65, or 64 bytes)\n */\nexport function isValidPublicKeyFormat(publicKey: Uint8Array): boolean {\n  const len = publicKey.length;\n\n  // Compressed (33 bytes)\n  if (len === 33) {\n    return publicKey[0] === 0x02 || publicKey[0] === 0x03;\n  }\n\n  // Uncompressed (65 bytes)\n  if (len === 65) {\n    return publicKey[0] === 0x04;\n  }\n\n  // Raw coordinates (64 bytes - no prefix)\n  if (len === 64) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Validates a secp256k1 private key format\n *\n * @param privateKey - Private key to validate\n * @returns True if valid format (32 bytes)\n */\nexport function isValidPrivateKeyFormat(privateKey: Uint8Array): boolean {\n  return privateKey.length === 32;\n}\n\n/**\n * Asserts that a public key is in uncompressed format (65 bytes with 0x04 prefix).\n * This validation function only checks format, it does not transform keys.\n * For key normalization (including decompression), use the crypto provider's\n * normalizeToUncompressed method.\n *\n * @param publicKey - Public key to validate\n * @throws {Error} When public key is not in uncompressed format\n */\nexport function assertUncompressedPublicKey(publicKey: Uint8Array): void {\n  if (publicKey.length !== 65) {\n    throw new Error(\n      `Public key must be uncompressed (65 bytes), got ${publicKey.length} bytes. ` +\n        `Use provider.normalizeToUncompressed() to convert compressed keys.`,\n    );\n  }\n\n  if (publicKey[0] !== 0x04) {\n    throw new Error(\n      `Uncompressed public key must start with 0x04 prefix, got 0x${publicKey[0].toString(16).padStart(2, \"0\")}`,\n    );\n  }\n}\n"],"mappings":"AAWA,SAAS,eAAe;AAmBjB,SAAS,uBACd,WACY;AAEZ,SAAO,OAAO,cAAc,WACxB;AAAA,IACG,UAAU,WAAW,IAAI,IACtB,YACA,KAAK,SAAS;AAAA,IAClB;AAAA,EACF,IACA;AACN;AAcO,SAAS,wBACd,YACY;AAEZ,SAAO,OAAO,eAAe,WACzB;AAAA,IACG,WAAW,WAAW,IAAI,IACvB,aACA,KAAK,UAAU;AAAA,IACnB;AAAA,EACF,IACA;AACN;AASO,SAAS,yBAAyB,iBAKvC;AACA,SAAO;AAAA,IACL,IAAI,gBAAgB,MAAM,GAAG,EAAE;AAAA,IAC/B,gBAAgB,gBAAgB,MAAM,IAAI,EAAE;AAAA;AAAA,IAC5C,YAAY,gBAAgB,MAAM,IAAI,GAAG;AAAA,IACzC,KAAK,gBAAgB,MAAM,GAAG;AAAA,EAChC;AACF;AAQO,SAAS,aAAa,SAA6B;AAExD,QAAM,UAAU,IAAI,YAAY;AAChC,SAAO,QAAQ,OAAO,OAAO;AAC/B;AASO,SAAS,WAAW,GAAe,GAAwB;AAChE,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAG,QAAO;AAAA,EAC5B;AACA,SAAO;AACT;AAQO,SAAS,UAAU,OAA+B;AACvD,SAAO,IAAI,WAAW,KAAK;AAC7B;AAQO,SAAS,uBAAuB,WAAgC;AACrE,QAAM,MAAM,UAAU;AAGtB,MAAI,QAAQ,IAAI;AACd,WAAO,UAAU,CAAC,MAAM,KAAQ,UAAU,CAAC,MAAM;AAAA,EACnD;AAGA,MAAI,QAAQ,IAAI;AACd,WAAO,UAAU,CAAC,MAAM;AAAA,EAC1B;AAGA,MAAI,QAAQ,IAAI;AACd,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAQO,SAAS,wBAAwB,YAAiC;AACvE,SAAO,WAAW,WAAW;AAC/B;AAWO,SAAS,4BAA4B,WAA6B;AACvE,MAAI,UAAU,WAAW,IAAI;AAC3B,UAAM,IAAI;AAAA,MACR,mDAAmD,UAAU,MAAM;AAAA,IAErE;AAAA,EACF;AAEA,MAAI,UAAU,CAAC,MAAM,GAAM;AACzB,UAAM,IAAI;AAAA,MACR,8DAA8D,UAAU,CAAC,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,IAC1G;AAAA,EACF;AACF;","names":[]}

package/dist/utils/crypto-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/download.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var download_exports = {};
+__export(download_exports, {
+  universalFetch: () => universalFetch
+});
+module.exports = __toCommonJS(download_exports);
+var import_ipfs = require("./ipfs");
+async function universalFetch(url, downloadRelayer) {
+  let processedUrl = url;
+  if (url.startsWith("ar://")) {
+    const txId = url.replace("ar://", "");
+    processedUrl = `https://arweave.net/${txId}`;
+  }
+  const ipfsHash = (0, import_ipfs.extractIpfsHash)(processedUrl);
+  if (ipfsHash) {
+    try {
+      return await (0, import_ipfs.fetchWithFallbacks)(url);
+    } catch (ipfsError) {
+      if (downloadRelayer) {
+        try {
+          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;
+          const blob = await downloadRelayer.proxyDownload(gatewayUrl);
+          return new Response(blob);
+        } catch {
+          throw ipfsError;
+        }
+      }
+      throw ipfsError;
+    }
+  }
+  try {
+    const response = await fetch(processedUrl);
+    return response;
+  } catch (error) {
+    if (downloadRelayer) {
+      try {
+        const blob = await downloadRelayer.proxyDownload(processedUrl);
+        return new Response(blob);
+      } catch {
+        throw error;
+      }
+    }
+    throw new Error(
+      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  universalFetch
+});
+//# sourceMappingURL=download.cjs.map

package/dist/utils/download.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Universal fetch with protocol support and automatic fallbacks\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)\n * 2. Arweave URLs with ar:// protocol conversion\n * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer\n * 4. Automatic fallback strategies for resilient downloads\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // IPFS URL - automatically uses gateway fallbacks\n * const ipfsResponse = await universalFetch('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n *\n * // With optional download relayer for CORS bypass\n * const response = await universalFetch(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n * ```\n */\nexport async function universalFetch(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAAoD;AAkCpD,eAAsB,eACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,eAAW,6BAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,UAAM,gCAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}

package/dist/utils/download.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Universal download utility with CORS bypass and IPFS gateway fallbacks
+ *
+ * @category Utilities
+ */
+/**
+ * Universal fetch with protocol support and automatic fallbacks
+ *
+ * @remarks
+ * This utility provides a robust download mechanism that handles:
+ * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)
+ * 2. Arweave URLs with ar:// protocol conversion
+ * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer
+ * 4. Automatic fallback strategies for resilient downloads
+ *
+ * The function automatically determines the best strategy based on the URL
+ * and available configuration, providing transparent fallback behavior.
+ *
+ * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)
+ * @param downloadRelayer - Optional download relayer for CORS bypass
+ * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+ * @returns Promise resolving to Response object
+ * @throws Error if all download attempts fail
+ * @example
+ * ```typescript
+ * // IPFS URL - automatically uses gateway fallbacks
+ * const ipfsResponse = await universalFetch('ipfs://QmHash123');
+ * const content = await ipfsResponse.text();
+ *
+ * // With optional download relayer for CORS bypass
+ * const response = await universalFetch(
+ *   'https://drive.google.com/file.json',
+ *   vana.downloadRelayer
+ * );
+ * const data = await response.json();
+ * ```
+ */
+export declare function universalFetch(url: string, downloadRelayer?: {
+    proxyDownload: (url: string) => Promise<Blob>;
+}): Promise<Response>;

package/dist/utils/download.js

@@ -0,0 +1,45 @@
+import { fetchWithFallbacks, extractIpfsHash } from "./ipfs";
+async function universalFetch(url, downloadRelayer) {
+  let processedUrl = url;
+  if (url.startsWith("ar://")) {
+    const txId = url.replace("ar://", "");
+    processedUrl = `https://arweave.net/${txId}`;
+  }
+  const ipfsHash = extractIpfsHash(processedUrl);
+  if (ipfsHash) {
+    try {
+      return await fetchWithFallbacks(url);
+    } catch (ipfsError) {
+      if (downloadRelayer) {
+        try {
+          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;
+          const blob = await downloadRelayer.proxyDownload(gatewayUrl);
+          return new Response(blob);
+        } catch {
+          throw ipfsError;
+        }
+      }
+      throw ipfsError;
+    }
+  }
+  try {
+    const response = await fetch(processedUrl);
+    return response;
+  } catch (error) {
+    if (downloadRelayer) {
+      try {
+        const blob = await downloadRelayer.proxyDownload(processedUrl);
+        return new Response(blob);
+      } catch {
+        throw error;
+      }
+    }
+    throw new Error(
+      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+export {
+  universalFetch
+};
+//# sourceMappingURL=download.js.map

package/dist/utils/download.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Universal fetch with protocol support and automatic fallbacks\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)\n * 2. Arweave URLs with ar:// protocol conversion\n * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer\n * 4. Automatic fallback strategies for resilient downloads\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // IPFS URL - automatically uses gateway fallbacks\n * const ipfsResponse = await universalFetch('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n *\n * // With optional download relayer for CORS bypass\n * const response = await universalFetch(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n * ```\n */\nexport async function universalFetch(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":"AAMA,SAAS,oBAAoB,uBAAuB;AAkCpD,eAAsB,eACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,WAAW,gBAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,MAAM,mBAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}

package/dist/utils/encoding.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encoding_exports = {};
+__export(encoding_exports, {
+  fromBase64: () => fromBase64,
+  isBrowserEnvironment: () => isBrowserEnvironment,
+  isNodeEnvironment: () => isNodeEnvironment,
+  toBase64: () => toBase64
+});
+module.exports = __toCommonJS(encoding_exports);
+function toBase64(data) {
+  if (typeof Buffer !== "undefined" && Buffer.from) {
+    return Buffer.from(data).toString("base64");
+  }
+  if (typeof btoa !== "undefined") {
+    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(
+      ""
+    );
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoding method available in this environment");
+}
+function fromBase64(str) {
+  if (typeof Buffer !== "undefined" && Buffer.from) {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  if (typeof atob !== "undefined") {
+    const binary = atob(str);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  throw new Error("No base64 decoding method available in this environment");
+}
+function isNodeEnvironment() {
+  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions?.node !== void 0;
+}
+function isBrowserEnvironment() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromBase64,
+  isBrowserEnvironment,
+  isNodeEnvironment,
+  toBase64
+});
+//# sourceMappingURL=encoding.cjs.map

package/dist/utils/encoding.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/encoding.ts"],"sourcesContent":["/**\n * Provides platform-aware base64 encoding utilities.\n *\n * @remarks\n * This module provides base64 encoding/decoding operations across Node.js and browser\n * environments. For hex and string conversions, use viem's utilities directly:\n * - `toHex` / `fromHex` from 'viem'\n * - `stringToBytes` / `bytesToString` from 'viem'\n *\n * @category Utilities\n */\n\n/**\n * Converts a Uint8Array to a base64 string.\n *\n * @param data - The byte array to encode into base64 format.\n * @returns The base64-encoded string representation.\n * @throws {Error} When no base64 encoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]);\n * const encoded = toBase64(bytes);\n * console.log(encoded); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return Buffer.from(data).toString(\"base64\");\n  }\n\n  // Browser path - using native btoa\n  if (typeof btoa !== \"undefined\") {\n    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(\n      \"\",\n    );\n    return btoa(binary);\n  }\n\n  throw new Error(\"No base64 encoding method available in this environment\");\n}\n\n/**\n * Converts a base64 string to a Uint8Array.\n *\n * @param str - The base64-encoded string to decode.\n * @returns The decoded byte array.\n * @throws {Error} When no base64 decoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const decoded = fromBase64(\"SGVsbG8=\");\n * console.log(new TextDecoder().decode(decoded)); // \"Hello\"\n * ```\n */\nexport function fromBase64(str: string): Uint8Array {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return new Uint8Array(Buffer.from(str, \"base64\"));\n  }\n\n  // Browser path - using native atob\n  if (typeof atob !== \"undefined\") {\n    const binary = atob(str);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  throw new Error(\"No base64 decoding method available in this environment\");\n}\n\n/**\n * Type guard to check if running in Node.js environment\n *\n * @returns True if running in Node.js\n */\nexport function isNodeEnvironment(): boolean {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.from === \"function\" &&\n    typeof process !== \"undefined\" &&\n    process.versions?.node !== undefined\n  );\n}\n\n/**\n * Type guard to check if running in browser environment\n *\n * @returns True if running in browser\n */\nexport function isBrowserEnvironment(): boolean {\n  return (\n    typeof window !== \"undefined\" && typeof window.document !== \"undefined\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BO,SAAS,SAAS,MAA0B;AAEjD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAAA,EAC5C;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,MAAM,KAAK,MAAM,CAAC,SAAS,OAAO,aAAa,IAAI,CAAC,EAAE;AAAA,MACnE;AAAA,IACF;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAeO,SAAS,WAAW,KAAyB;AAElD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,IAAI,WAAW,OAAO,KAAK,KAAK,QAAQ,CAAC;AAAA,EAClD;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,KAAK,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAOO,SAAS,oBAA6B;AAC3C,SACE,OAAO,WAAW,eAClB,OAAO,OAAO,SAAS,cACvB,OAAO,YAAY,eACnB,QAAQ,UAAU,SAAS;AAE/B;AAOO,SAAS,uBAAgC;AAC9C,SACE,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa;AAEhE;","names":[]}

package/dist/utils/encoding.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Provides platform-aware base64 encoding utilities.
+ *
+ * @remarks
+ * This module provides base64 encoding/decoding operations across Node.js and browser
+ * environments. For hex and string conversions, use viem's utilities directly:
+ * - `toHex` / `fromHex` from 'viem'
+ * - `stringToBytes` / `bytesToString` from 'viem'
+ *
+ * @category Utilities
+ */
+/**
+ * Converts a Uint8Array to a base64 string.
+ *
+ * @param data - The byte array to encode into base64 format.
+ * @returns The base64-encoded string representation.
+ * @throws {Error} When no base64 encoding method is available in the environment.
+ *
+ * @example
+ * ```typescript
+ * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+ * const encoded = toBase64(bytes);
+ * console.log(encoded); // "SGVsbG8="
+ * ```
+ */
+export declare function toBase64(data: Uint8Array): string;
+/**
+ * Converts a base64 string to a Uint8Array.
+ *
+ * @param str - The base64-encoded string to decode.
+ * @returns The decoded byte array.
+ * @throws {Error} When no base64 decoding method is available in the environment.
+ *
+ * @example
+ * ```typescript
+ * const decoded = fromBase64("SGVsbG8=");
+ * console.log(new TextDecoder().decode(decoded)); // "Hello"
+ * ```
+ */
+export declare function fromBase64(str: string): Uint8Array;
+/**
+ * Type guard to check if running in Node.js environment
+ *
+ * @returns True if running in Node.js
+ */
+export declare function isNodeEnvironment(): boolean;
+/**
+ * Type guard to check if running in browser environment
+ *
+ * @returns True if running in browser
+ */
+export declare function isBrowserEnvironment(): boolean;

package/dist/utils/encoding.js

@@ -0,0 +1,39 @@
+function toBase64(data) {
+  if (typeof Buffer !== "undefined" && Buffer.from) {
+    return Buffer.from(data).toString("base64");
+  }
+  if (typeof btoa !== "undefined") {
+    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(
+      ""
+    );
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoding method available in this environment");
+}
+function fromBase64(str) {
+  if (typeof Buffer !== "undefined" && Buffer.from) {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  if (typeof atob !== "undefined") {
+    const binary = atob(str);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  throw new Error("No base64 decoding method available in this environment");
+}
+function isNodeEnvironment() {
+  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions?.node !== void 0;
+}
+function isBrowserEnvironment() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+export {
+  fromBase64,
+  isBrowserEnvironment,
+  isNodeEnvironment,
+  toBase64
+};
+//# sourceMappingURL=encoding.js.map