@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.80df35f

package/dist/utils/signatureFormatter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import type { Hash } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  const cleanSig = signature.startsWith(\"0x\") ? signature.slice(2) : signature;\n\n  if (cleanSig.length !== 130) {\n    return signature;\n  }\n\n  const vHex = cleanSig.slice(128, 130);\n  const v = parseInt(vHex, 16);\n\n  if (isNaN(v)) {\n    return signature;\n  }\n\n  if (v < 27) {\n    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, \"0\");\n    return `0x${cleanSig.slice(0, 128)}${adjustedV}` as Hash;\n  }\n\n  return signature;\n}\n"],"mappings":"AAEA,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAChE,QAAM,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU,MAAM,CAAC,IAAI;AAEnE,MAAI,SAAS,WAAW,KAAK;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,MAAM,KAAK,GAAG;AACpC,QAAM,IAAI,SAAS,MAAM,EAAE;AAE3B,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,IAAI;AACV,UAAM,aAAa,IAAI,uBAAuB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1E,WAAO,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,SAAS;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import { type Hash, fromHex, toHex } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  // Convert to bytes for safer manipulation\n  const sigBytes = fromHex(signature, \"bytes\");\n\n  if (sigBytes.length !== 65) {\n    return signature;\n  }\n\n  // Extract v value (last byte)\n  const v = sigBytes[64];\n\n  if (v < 27) {\n    // Adjust v value\n    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;\n    // Convert back to hex\n    return toHex(sigBytes);\n  }\n\n  return signature;\n}\n"],"mappings":"AAAA,SAAoB,SAAS,aAAa;AAE1C,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAEhE,QAAM,WAAW,QAAQ,WAAW,OAAO;AAE3C,MAAI,SAAS,WAAW,IAAI;AAC1B,WAAO;AAAA,EACT;AAGA,QAAM,IAAI,SAAS,EAAE;AAErB,MAAI,IAAI,IAAI;AAEV,aAAS,EAAE,IAAI,IAAI;AAEnB,WAAO,MAAM,QAAQ;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/tests/multicall.test.d.ts

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

package/dist/utils/transactionHelpers.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/transactionHelpers.ts"],"sourcesContent":["/**\n * Helper functions for creating typed transaction POJOs\n */\n\nimport type { Hash, Address } from 'viem';\nimport type { TransactionResult } from '../types/operations';\nimport type { Contract, Fn } from '../generated/event-types';\n\n/**\n * Creates a strongly-typed TransactionResult POJO.\n * \n * @remarks\n * This helper ensures all required fields are present and typed correctly,\n * reducing boilerplate and preventing mistakes.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * return tx({\n *   hash,\n *   from: account.address,\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * ```\n */\nexport function tx<C extends Contract, F extends Fn<C>>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n\n/**\n * Creates a transaction result with literal type inference.\n * Use this when you need TypeScript to preserve exact string literals.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * const transaction = txLiteral({\n *   hash: '0x...',\n *   from: '0x...',\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission\n * ```\n */\nexport function txLiteral<\n  const C extends Contract,\n  const F extends Fn<C>\n>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCO,SAAS,GAAwC,OAS5B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;AA4BO,SAAS,UAGd,OAS0B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/transactionHelpers.ts"],"sourcesContent":["/**\n * Helper functions for creating typed transaction POJOs\n */\n\nimport type { Hash, Address } from \"viem\";\nimport type { TransactionResult } from \"../types/operations\";\nimport type { Contract, Fn } from \"../generated/event-types\";\n\n/**\n * Creates a strongly-typed TransactionResult POJO.\n *\n * @remarks\n * This helper ensures all required fields are present and typed correctly,\n * reducing boilerplate and preventing mistakes.\n *\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n *\n * @example\n * ```typescript\n * return tx({\n *   hash,\n *   from: account.address,\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * ```\n */\nexport function tx<C extends Contract, F extends Fn<C>>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n\n/**\n * Creates a transaction result with literal type inference.\n * Use this when you need TypeScript to preserve exact string literals.\n *\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n *\n * @example\n * ```typescript\n * const transaction = txLiteral({\n *   hash: '0x...',\n *   from: '0x...',\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission\n * ```\n */\nexport function txLiteral<\n  const C extends Contract,\n  const F extends Fn<C>,\n>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCO,SAAS,GAAwC,OAS5B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;AA4BO,SAAS,UAGd,OAS0B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;","names":[]}

package/dist/utils/transactionHelpers.d.ts

@@ -1,13 +1,9 @@
-import { Hash, Address } from 'viem';
-import { TransactionResult } from '../types/operations.js';
-import { Contract, Fn } from '../generated/event-types.js';
-import '../generated/server/server-exports.js';
-import '../generated/server/server.js';
-
 /**
  * Helper functions for creating typed transaction POJOs
  */
-
+import type { Hash, Address } from "viem";
+import type { TransactionResult } from "../types/operations";
+import type { Contract, Fn } from "../generated/event-types";
 /**
  * Creates a strongly-typed TransactionResult POJO.
  *
@@ -36,7 +32,7 @@ import '../generated/server/server.js';
  * });
  * ```
  */
-declare function tx<C extends Contract, F extends Fn<C>>(input: {
+export declare function tx<C extends Contract, F extends Fn<C>>(input: {
     hash: Hash;
     from: Address;
     contract: C;
@@ -72,7 +68,7 @@ declare function tx<C extends Contract, F extends Fn<C>>(input: {
  * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission
  * ```
  */
-declare function txLiteral<const C extends Contract, const F extends Fn<C>>(input: {
+export declare function txLiteral<const C extends Contract, const F extends Fn<C>>(input: {
     hash: Hash;
     from: Address;
     contract: C;
@@ -82,5 +78,3 @@ declare function txLiteral<const C extends Contract, const F extends Fn<C>>(inpu
     nonce?: number;
     to?: Address;
 }): TransactionResult<C, F>;
-
-export { tx, txLiteral };

package/dist/utils/transactionHelpers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/transactionHelpers.ts"],"sourcesContent":["/**\n * Helper functions for creating typed transaction POJOs\n */\n\nimport type { Hash, Address } from 'viem';\nimport type { TransactionResult } from '../types/operations';\nimport type { Contract, Fn } from '../generated/event-types';\n\n/**\n * Creates a strongly-typed TransactionResult POJO.\n * \n * @remarks\n * This helper ensures all required fields are present and typed correctly,\n * reducing boilerplate and preventing mistakes.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * return tx({\n *   hash,\n *   from: account.address,\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * ```\n */\nexport function tx<C extends Contract, F extends Fn<C>>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n\n/**\n * Creates a transaction result with literal type inference.\n * Use this when you need TypeScript to preserve exact string literals.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * const transaction = txLiteral({\n *   hash: '0x...',\n *   from: '0x...',\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission\n * ```\n */\nexport function txLiteral<\n  const C extends Contract,\n  const F extends Fn<C>\n>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}"],"mappings":"AAoCO,SAAS,GAAwC,OAS5B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;AA4BO,SAAS,UAGd,OAS0B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/transactionHelpers.ts"],"sourcesContent":["/**\n * Helper functions for creating typed transaction POJOs\n */\n\nimport type { Hash, Address } from \"viem\";\nimport type { TransactionResult } from \"../types/operations\";\nimport type { Contract, Fn } from \"../generated/event-types\";\n\n/**\n * Creates a strongly-typed TransactionResult POJO.\n *\n * @remarks\n * This helper ensures all required fields are present and typed correctly,\n * reducing boilerplate and preventing mistakes.\n *\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n *\n * @example\n * ```typescript\n * return tx({\n *   hash,\n *   from: account.address,\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * ```\n */\nexport function tx<C extends Contract, F extends Fn<C>>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n\n/**\n * Creates a transaction result with literal type inference.\n * Use this when you need TypeScript to preserve exact string literals.\n *\n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n *\n * @example\n * ```typescript\n * const transaction = txLiteral({\n *   hash: '0x...',\n *   from: '0x...',\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission\n * ```\n */\nexport function txLiteral<\n  const C extends Contract,\n  const F extends Fn<C>,\n>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n"],"mappings":"AAoCO,SAAS,GAAwC,OAS5B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;AA4BO,SAAS,UAGd,OAS0B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;","names":[]}

package/dist/utils/typeGuards.cjs

@@ -0,0 +1,109 @@
+"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 typeGuards_exports = {};
+__export(typeGuards_exports, {
+  assertDefined: () => assertDefined,
+  assertHasProperties: () => assertHasProperties,
+  assertNonEmptyString: () => assertNonEmptyString,
+  ensureDefault: () => ensureDefault,
+  ensureError: () => ensureError,
+  hasProperty: () => hasProperty,
+  isArray: () => isArray,
+  isDefined: () => isDefined,
+  isNonEmptyString: () => isNonEmptyString,
+  isObject: () => isObject,
+  safeArrayAccess: () => safeArrayAccess,
+  safeGet: () => safeGet
+});
+module.exports = __toCommonJS(typeGuards_exports);
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message);
+  }
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function assertNonEmptyString(value, message) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(message);
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function safeGet(obj, key) {
+  return obj?.[key];
+}
+function ensureDefault(value, defaultValue) {
+  return isDefined(value) ? value : defaultValue;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function safeArrayAccess(array, index) {
+  if (!array || index < 0 || index >= array.length) {
+    return void 0;
+  }
+  return array[index];
+}
+function hasProperty(obj, prop) {
+  return isObject(obj) && prop in obj;
+}
+function assertHasProperties(obj, properties, message) {
+  if (!isObject(obj)) {
+    throw new Error(`${message}: Value is not an object`);
+  }
+  for (const prop of properties) {
+    if (!(prop in obj)) {
+      throw new Error(`${message}: Missing required property '${prop}'`);
+    }
+  }
+}
+function ensureError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error) && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(fallbackMessage);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertDefined,
+  assertHasProperties,
+  assertNonEmptyString,
+  ensureDefault,
+  ensureError,
+  hasProperty,
+  isArray,
+  isDefined,
+  isNonEmptyString,
+  isObject,
+  safeArrayAccess,
+  safeGet
+});
+//# sourceMappingURL=typeGuards.cjs.map

package/dist/utils/typeGuards.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/typeGuards.ts"],"sourcesContent":["/**\n * Type guard utilities for runtime type checking and assertions.\n * These utilities provide type-safe alternatives to non-null assertions (!).\n *\n * @module typeGuards\n */\n\n/**\n * Asserts that a value is defined (not null or undefined).\n * Throws an error with a descriptive message if the assertion fails.\n *\n * @param value - The value to check\n * @param message - Error message to throw if value is not defined\n * @throws {Error} If value is null or undefined\n *\n * @example\n * ```typescript\n * const wallet = getWallet();\n * assertDefined(wallet, 'Wallet must be initialized before use');\n * // TypeScript now knows wallet is defined\n * console.log(wallet.address);\n * ```\n */\nexport function assertDefined<T>(\n  value: T | undefined | null,\n  message: string,\n): asserts value is T {\n  if (value === undefined || value === null) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is defined (not null or undefined).\n *\n * @param value - The value to check\n * @returns True if the value is defined, false otherwise\n *\n * @example\n * ```typescript\n * const values = [1, undefined, 3, null, 5];\n * const defined = values.filter(isDefined); // [1, 3, 5]\n * ```\n */\nexport function isDefined<T>(value: T | undefined | null): value is T {\n  return value !== undefined && value !== null;\n}\n\n/**\n * Asserts that a value is a non-empty string.\n *\n * @param value - The value to check\n * @param message - Error message if assertion fails\n * @throws {Error} If value is not a non-empty string\n */\nexport function assertNonEmptyString(\n  value: unknown,\n  message: string,\n): asserts value is string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is a non-empty string.\n *\n * @param value - The value to check\n * @returns True if value is a non-empty string\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === \"string\" && value.trim().length > 0;\n}\n\n/**\n * Safely gets a property from an object, returning undefined if the property doesn't exist.\n *\n * @param obj - The object to get the property from\n * @param key - The property key\n * @returns The property value or undefined\n *\n * @example\n * ```typescript\n * const config = { wallet: { address: '0x123' } };\n * const address = safeGet(config, 'wallet')?.address;\n * ```\n */\nexport function safeGet<T, K extends keyof T>(\n  obj: T | undefined | null,\n  key: K,\n): T[K] | undefined {\n  return obj?.[key];\n}\n\n/**\n * Ensures a value is defined or returns a default value.\n *\n * @param value - The value to check\n * @param defaultValue - The default value to use if undefined\n * @returns The value if defined, otherwise the default\n *\n * @example\n * ```typescript\n * const timeout = ensureDefault(config.timeout, 5000);\n * ```\n */\nexport function ensureDefault<T>(\n  value: T | undefined | null,\n  defaultValue: T,\n): T {\n  return isDefined(value) ? value : defaultValue;\n}\n\n/**\n * Type guard for checking if a value is an object (and not null).\n *\n * @param value - The value to check\n * @returns True if value is an object\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * Type guard for checking if a value is an array.\n *\n * @param value - The value to check\n * @returns True if value is an array\n */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Safely accesses an array element, returning undefined if out of bounds.\n *\n * @param array - The array to access\n * @param index - The index to access\n * @returns The element at the index or undefined\n *\n * @example\n * ```typescript\n * const items = [1, 2, 3];\n * const item = safeArrayAccess(items, 5); // undefined\n * ```\n */\nexport function safeArrayAccess<T>(\n  array: T[] | undefined | null,\n  index: number,\n): T | undefined {\n  if (!array || index < 0 || index >= array.length) {\n    return undefined;\n  }\n  return array[index];\n}\n\n/**\n * Type guard to check if a value has a specific property.\n *\n * @param obj - The object to check\n * @param prop - The property name\n * @returns True if the object has the property\n *\n * @example\n * ```typescript\n * if (hasProperty(response, 'error')) {\n *   console.error(response.error);\n * }\n * ```\n */\nexport function hasProperty<T extends string>(\n  obj: unknown,\n  prop: T,\n): obj is Record<T, unknown> {\n  return isObject(obj) && prop in obj;\n}\n\n/**\n * Asserts that an object has required properties.\n *\n * @param obj - The object to check\n * @param properties - Array of required property names\n * @param message - Error message if assertion fails\n * @throws {Error} If any required property is missing\n */\nexport function assertHasProperties<T extends string>(\n  obj: unknown,\n  properties: T[],\n  message: string,\n): asserts obj is Record<T, unknown> {\n  if (!isObject(obj)) {\n    throw new Error(`${message}: Value is not an object`);\n  }\n\n  for (const prop of properties) {\n    if (!(prop in obj)) {\n      throw new Error(`${message}: Missing required property '${prop}'`);\n    }\n  }\n}\n\n/**\n * Creates a type-safe error with a guaranteed message.\n *\n * @param error - The error or unknown value\n * @param fallbackMessage - Message to use if error doesn't have one\n * @returns An Error object with a message\n */\nexport function ensureError(error: unknown, fallbackMessage: string): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n  if (typeof error === \"string\") {\n    return new Error(error);\n  }\n  if (\n    isObject(error) &&\n    \"message\" in error &&\n    typeof error.message === \"string\"\n  ) {\n    return new Error(error.message);\n  }\n  return new Error(fallbackMessage);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBO,SAAS,cACd,OACA,SACoB;AACpB,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAcO,SAAS,UAAa,OAAyC;AACpE,SAAO,UAAU,UAAa,UAAU;AAC1C;AASO,SAAS,qBACd,OACA,SACyB;AACzB,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAQO,SAAS,iBAAiB,OAAiC;AAChE,SAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS;AAC5D;AAeO,SAAS,QACd,KACA,KACkB;AAClB,SAAO,MAAM,GAAG;AAClB;AAcO,SAAS,cACd,OACA,cACG;AACH,SAAO,UAAU,KAAK,IAAI,QAAQ;AACpC;AAQO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAQO,SAAS,QAAqB,OAA8B;AACjE,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAeO,SAAS,gBACd,OACA,OACe;AACf,MAAI,CAAC,SAAS,QAAQ,KAAK,SAAS,MAAM,QAAQ;AAChD,WAAO;AAAA,EACT;AACA,SAAO,MAAM,KAAK;AACpB;AAgBO,SAAS,YACd,KACA,MAC2B;AAC3B,SAAO,SAAS,GAAG,KAAK,QAAQ;AAClC;AAUO,SAAS,oBACd,KACA,YACA,SACmC;AACnC,MAAI,CAAC,SAAS,GAAG,GAAG;AAClB,UAAM,IAAI,MAAM,GAAG,OAAO,0BAA0B;AAAA,EACtD;AAEA,aAAW,QAAQ,YAAY;AAC7B,QAAI,EAAE,QAAQ,MAAM;AAClB,YAAM,IAAI,MAAM,GAAG,OAAO,gCAAgC,IAAI,GAAG;AAAA,IACnE;AAAA,EACF;AACF;AASO,SAAS,YAAY,OAAgB,iBAAgC;AAC1E,MAAI,iBAAiB,OAAO;AAC1B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,IAAI,MAAM,KAAK;AAAA,EACxB;AACA,MACE,SAAS,KAAK,KACd,aAAa,SACb,OAAO,MAAM,YAAY,UACzB;AACA,WAAO,IAAI,MAAM,MAAM,OAAO;AAAA,EAChC;AACA,SAAO,IAAI,MAAM,eAAe;AAClC;","names":[]}

package/dist/utils/typeGuards.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Type guard utilities for runtime type checking and assertions.
+ * These utilities provide type-safe alternatives to non-null assertions (!).
+ *
+ * @module typeGuards
+ */
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Throws an error with a descriptive message if the assertion fails.
+ *
+ * @param value - The value to check
+ * @param message - Error message to throw if value is not defined
+ * @throws {Error} If value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const wallet = getWallet();
+ * assertDefined(wallet, 'Wallet must be initialized before use');
+ * // TypeScript now knows wallet is defined
+ * console.log(wallet.address);
+ * ```
+ */
+export declare function assertDefined<T>(value: T | undefined | null, message: string): asserts value is T;
+/**
+ * Type guard to check if a value is defined (not null or undefined).
+ *
+ * @param value - The value to check
+ * @returns True if the value is defined, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const values = [1, undefined, 3, null, 5];
+ * const defined = values.filter(isDefined); // [1, 3, 5]
+ * ```
+ */
+export declare function isDefined<T>(value: T | undefined | null): value is T;
+/**
+ * Asserts that a value is a non-empty string.
+ *
+ * @param value - The value to check
+ * @param message - Error message if assertion fails
+ * @throws {Error} If value is not a non-empty string
+ */
+export declare function assertNonEmptyString(value: unknown, message: string): asserts value is string;
+/**
+ * Type guard to check if a value is a non-empty string.
+ *
+ * @param value - The value to check
+ * @returns True if value is a non-empty string
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Safely gets a property from an object, returning undefined if the property doesn't exist.
+ *
+ * @param obj - The object to get the property from
+ * @param key - The property key
+ * @returns The property value or undefined
+ *
+ * @example
+ * ```typescript
+ * const config = { wallet: { address: '0x123' } };
+ * const address = safeGet(config, 'wallet')?.address;
+ * ```
+ */
+export declare function safeGet<T, K extends keyof T>(obj: T | undefined | null, key: K): T[K] | undefined;
+/**
+ * Ensures a value is defined or returns a default value.
+ *
+ * @param value - The value to check
+ * @param defaultValue - The default value to use if undefined
+ * @returns The value if defined, otherwise the default
+ *
+ * @example
+ * ```typescript
+ * const timeout = ensureDefault(config.timeout, 5000);
+ * ```
+ */
+export declare function ensureDefault<T>(value: T | undefined | null, defaultValue: T): T;
+/**
+ * Type guard for checking if a value is an object (and not null).
+ *
+ * @param value - The value to check
+ * @returns True if value is an object
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard for checking if a value is an array.
+ *
+ * @param value - The value to check
+ * @returns True if value is an array
+ */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Safely accesses an array element, returning undefined if out of bounds.
+ *
+ * @param array - The array to access
+ * @param index - The index to access
+ * @returns The element at the index or undefined
+ *
+ * @example
+ * ```typescript
+ * const items = [1, 2, 3];
+ * const item = safeArrayAccess(items, 5); // undefined
+ * ```
+ */
+export declare function safeArrayAccess<T>(array: T[] | undefined | null, index: number): T | undefined;
+/**
+ * Type guard to check if a value has a specific property.
+ *
+ * @param obj - The object to check
+ * @param prop - The property name
+ * @returns True if the object has the property
+ *
+ * @example
+ * ```typescript
+ * if (hasProperty(response, 'error')) {
+ *   console.error(response.error);
+ * }
+ * ```
+ */
+export declare function hasProperty<T extends string>(obj: unknown, prop: T): obj is Record<T, unknown>;
+/**
+ * Asserts that an object has required properties.
+ *
+ * @param obj - The object to check
+ * @param properties - Array of required property names
+ * @param message - Error message if assertion fails
+ * @throws {Error} If any required property is missing
+ */
+export declare function assertHasProperties<T extends string>(obj: unknown, properties: T[], message: string): asserts obj is Record<T, unknown>;
+/**
+ * Creates a type-safe error with a guaranteed message.
+ *
+ * @param error - The error or unknown value
+ * @param fallbackMessage - Message to use if error doesn't have one
+ * @returns An Error object with a message
+ */
+export declare function ensureError(error: unknown, fallbackMessage: string): Error;

package/dist/utils/typeGuards.js

@@ -0,0 +1,74 @@
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message);
+  }
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function assertNonEmptyString(value, message) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(message);
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function safeGet(obj, key) {
+  return obj?.[key];
+}
+function ensureDefault(value, defaultValue) {
+  return isDefined(value) ? value : defaultValue;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function safeArrayAccess(array, index) {
+  if (!array || index < 0 || index >= array.length) {
+    return void 0;
+  }
+  return array[index];
+}
+function hasProperty(obj, prop) {
+  return isObject(obj) && prop in obj;
+}
+function assertHasProperties(obj, properties, message) {
+  if (!isObject(obj)) {
+    throw new Error(`${message}: Value is not an object`);
+  }
+  for (const prop of properties) {
+    if (!(prop in obj)) {
+      throw new Error(`${message}: Missing required property '${prop}'`);
+    }
+  }
+}
+function ensureError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error) && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(fallbackMessage);
+}
+export {
+  assertDefined,
+  assertHasProperties,
+  assertNonEmptyString,
+  ensureDefault,
+  ensureError,
+  hasProperty,
+  isArray,
+  isDefined,
+  isNonEmptyString,
+  isObject,
+  safeArrayAccess,
+  safeGet
+};
+//# sourceMappingURL=typeGuards.js.map

package/dist/utils/typeGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/typeGuards.ts"],"sourcesContent":["/**\n * Type guard utilities for runtime type checking and assertions.\n * These utilities provide type-safe alternatives to non-null assertions (!).\n *\n * @module typeGuards\n */\n\n/**\n * Asserts that a value is defined (not null or undefined).\n * Throws an error with a descriptive message if the assertion fails.\n *\n * @param value - The value to check\n * @param message - Error message to throw if value is not defined\n * @throws {Error} If value is null or undefined\n *\n * @example\n * ```typescript\n * const wallet = getWallet();\n * assertDefined(wallet, 'Wallet must be initialized before use');\n * // TypeScript now knows wallet is defined\n * console.log(wallet.address);\n * ```\n */\nexport function assertDefined<T>(\n  value: T | undefined | null,\n  message: string,\n): asserts value is T {\n  if (value === undefined || value === null) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is defined (not null or undefined).\n *\n * @param value - The value to check\n * @returns True if the value is defined, false otherwise\n *\n * @example\n * ```typescript\n * const values = [1, undefined, 3, null, 5];\n * const defined = values.filter(isDefined); // [1, 3, 5]\n * ```\n */\nexport function isDefined<T>(value: T | undefined | null): value is T {\n  return value !== undefined && value !== null;\n}\n\n/**\n * Asserts that a value is a non-empty string.\n *\n * @param value - The value to check\n * @param message - Error message if assertion fails\n * @throws {Error} If value is not a non-empty string\n */\nexport function assertNonEmptyString(\n  value: unknown,\n  message: string,\n): asserts value is string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Type guard to check if a value is a non-empty string.\n *\n * @param value - The value to check\n * @returns True if value is a non-empty string\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === \"string\" && value.trim().length > 0;\n}\n\n/**\n * Safely gets a property from an object, returning undefined if the property doesn't exist.\n *\n * @param obj - The object to get the property from\n * @param key - The property key\n * @returns The property value or undefined\n *\n * @example\n * ```typescript\n * const config = { wallet: { address: '0x123' } };\n * const address = safeGet(config, 'wallet')?.address;\n * ```\n */\nexport function safeGet<T, K extends keyof T>(\n  obj: T | undefined | null,\n  key: K,\n): T[K] | undefined {\n  return obj?.[key];\n}\n\n/**\n * Ensures a value is defined or returns a default value.\n *\n * @param value - The value to check\n * @param defaultValue - The default value to use if undefined\n * @returns The value if defined, otherwise the default\n *\n * @example\n * ```typescript\n * const timeout = ensureDefault(config.timeout, 5000);\n * ```\n */\nexport function ensureDefault<T>(\n  value: T | undefined | null,\n  defaultValue: T,\n): T {\n  return isDefined(value) ? value : defaultValue;\n}\n\n/**\n * Type guard for checking if a value is an object (and not null).\n *\n * @param value - The value to check\n * @returns True if value is an object\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * Type guard for checking if a value is an array.\n *\n * @param value - The value to check\n * @returns True if value is an array\n */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Safely accesses an array element, returning undefined if out of bounds.\n *\n * @param array - The array to access\n * @param index - The index to access\n * @returns The element at the index or undefined\n *\n * @example\n * ```typescript\n * const items = [1, 2, 3];\n * const item = safeArrayAccess(items, 5); // undefined\n * ```\n */\nexport function safeArrayAccess<T>(\n  array: T[] | undefined | null,\n  index: number,\n): T | undefined {\n  if (!array || index < 0 || index >= array.length) {\n    return undefined;\n  }\n  return array[index];\n}\n\n/**\n * Type guard to check if a value has a specific property.\n *\n * @param obj - The object to check\n * @param prop - The property name\n * @returns True if the object has the property\n *\n * @example\n * ```typescript\n * if (hasProperty(response, 'error')) {\n *   console.error(response.error);\n * }\n * ```\n */\nexport function hasProperty<T extends string>(\n  obj: unknown,\n  prop: T,\n): obj is Record<T, unknown> {\n  return isObject(obj) && prop in obj;\n}\n\n/**\n * Asserts that an object has required properties.\n *\n * @param obj - The object to check\n * @param properties - Array of required property names\n * @param message - Error message if assertion fails\n * @throws {Error} If any required property is missing\n */\nexport function assertHasProperties<T extends string>(\n  obj: unknown,\n  properties: T[],\n  message: string,\n): asserts obj is Record<T, unknown> {\n  if (!isObject(obj)) {\n    throw new Error(`${message}: Value is not an object`);\n  }\n\n  for (const prop of properties) {\n    if (!(prop in obj)) {\n      throw new Error(`${message}: Missing required property '${prop}'`);\n    }\n  }\n}\n\n/**\n * Creates a type-safe error with a guaranteed message.\n *\n * @param error - The error or unknown value\n * @param fallbackMessage - Message to use if error doesn't have one\n * @returns An Error object with a message\n */\nexport function ensureError(error: unknown, fallbackMessage: string): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n  if (typeof error === \"string\") {\n    return new Error(error);\n  }\n  if (\n    isObject(error) &&\n    \"message\" in error &&\n    typeof error.message === \"string\"\n  ) {\n    return new Error(error.message);\n  }\n  return new Error(fallbackMessage);\n}\n"],"mappings":"AAuBO,SAAS,cACd,OACA,SACoB;AACpB,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAcO,SAAS,UAAa,OAAyC;AACpE,SAAO,UAAU,UAAa,UAAU;AAC1C;AASO,SAAS,qBACd,OACA,SACyB;AACzB,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,MAAM,OAAO;AAAA,EACzB;AACF;AAQO,SAAS,iBAAiB,OAAiC;AAChE,SAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS;AAC5D;AAeO,SAAS,QACd,KACA,KACkB;AAClB,SAAO,MAAM,GAAG;AAClB;AAcO,SAAS,cACd,OACA,cACG;AACH,SAAO,UAAU,KAAK,IAAI,QAAQ;AACpC;AAQO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAQO,SAAS,QAAqB,OAA8B;AACjE,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAeO,SAAS,gBACd,OACA,OACe;AACf,MAAI,CAAC,SAAS,QAAQ,KAAK,SAAS,MAAM,QAAQ;AAChD,WAAO;AAAA,EACT;AACA,SAAO,MAAM,KAAK;AACpB;AAgBO,SAAS,YACd,KACA,MAC2B;AAC3B,SAAO,SAAS,GAAG,KAAK,QAAQ;AAClC;AAUO,SAAS,oBACd,KACA,YACA,SACmC;AACnC,MAAI,CAAC,SAAS,GAAG,GAAG;AAClB,UAAM,IAAI,MAAM,GAAG,OAAO,0BAA0B;AAAA,EACtD;AAEA,aAAW,QAAQ,YAAY;AAC7B,QAAI,EAAE,QAAQ,MAAM;AAClB,YAAM,IAAI,MAAM,GAAG,OAAO,gCAAgC,IAAI,GAAG;AAAA,IACnE;AAAA,EACF;AACF;AASO,SAAS,YAAY,OAAgB,iBAAgC;AAC1E,MAAI,iBAAiB,OAAO;AAC1B,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,IAAI,MAAM,KAAK;AAAA,EACxB;AACA,MACE,SAAS,KAAK,KACd,aAAa,SACb,OAAO,MAAM,YAAY,UACzB;AACA,WAAO,IAAI,MAAM,MAAM,OAAO;AAAA,EAChC;AACA,SAAO,IAAI,MAAM,eAAe;AAClC;","names":[]}

package/dist/utils/typedDataConverter.d.ts

@@ -1,6 +1,5 @@
-import { TypedDataDefinition } from 'viem';
-import { GenericTypedData } from '../types/permissions.js';
-
+import type { TypedDataDefinition } from "viem";
+import type { GenericTypedData } from "../types/permissions";
 /**
  * Converts a GenericTypedData object to a Viem-compatible TypedDataDefinition.
  * This function ensures type safety when passing typed data to viem's signTypedData method.
@@ -8,6 +7,4 @@ import { GenericTypedData } from '../types/permissions.js';
  * @param typedData - The typed data object to convert
  * @returns A properly typed TypedDataDefinition for use with viem
  */
-declare function toViemTypedDataDefinition(typedData: GenericTypedData): TypedDataDefinition;
-
-export { toViemTypedDataDefinition };
+export declare function toViemTypedDataDefinition(typedData: GenericTypedData): TypedDataDefinition;

package/dist/utils/urlResolver.cjs

@@ -33,7 +33,7 @@ class UrlResolutionError extends Error {
 }
 async function fetchFromUrl(url, downloadRelayer) {
   try {
-    const response = await (0, import_download.fetchWithRelayer)(url, downloadRelayer);
+    const response = await (0, import_download.universalFetch)(url, downloadRelayer);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }

package/dist/utils/urlResolver.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { fetchWithRelayer } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\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 the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await fetchWithRelayer(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAAiC;AAK1B,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,kCAAiB,KAAK,eAAe;AAE5D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\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 the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await universalFetch(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAA+B;AAKxB,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,UAAM,gCAAe,KAAK,eAAe;AAE1D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/utils/urlResolver.d.ts

@@ -7,7 +7,7 @@
 /**
  * Error thrown when URL resolution fails
  */
-declare class UrlResolutionError extends Error {
+export declare class UrlResolutionError extends Error {
     readonly url: string;
     readonly cause?: Error | undefined;
     constructor(message: string, url: string, cause?: Error | undefined);
@@ -33,8 +33,6 @@ declare class UrlResolutionError extends Error {
  * const schema = await fetchFromUrl(schemaDefinitionUrl);
  * ```
  */
-declare function fetchFromUrl(url: string, downloadRelayer?: {
+export declare function fetchFromUrl(url: string, downloadRelayer?: {
     proxyDownload: (url: string) => Promise<Blob>;
 }): Promise<unknown>;
-
-export { UrlResolutionError, fetchFromUrl };

package/dist/utils/urlResolver.js

@@ -1,4 +1,4 @@
-import { fetchWithRelayer } from "./download";
+import { universalFetch } from "./download";
 class UrlResolutionError extends Error {
   constructor(message, url, cause) {
     super(message);
@@ -9,7 +9,7 @@ class UrlResolutionError extends Error {
 }
 async function fetchFromUrl(url, downloadRelayer) {
   try {
-    const response = await fetchWithRelayer(url, downloadRelayer);
+    const response = await universalFetch(url, downloadRelayer);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }

package/dist/utils/urlResolver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { fetchWithRelayer } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\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 the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await fetchWithRelayer(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":"AAOA,SAAS,wBAAwB;AAK1B,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,MAAM,iBAAiB,KAAK,eAAe;AAE5D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/urlResolver.ts"],"sourcesContent":["/**\n * Universal URL resolver for the Vana SDK\n *\n * Handles fetching data from various protocols (IPFS, HTTP, Arweave, etc.)\n * in a consistent, reliable way.\n */\n\nimport { universalFetch } from \"./download\";\n\n/**\n * Error thrown when URL resolution fails\n */\nexport class UrlResolutionError extends Error {\n  constructor(\n    message: string,\n    public readonly url: string,\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"UrlResolutionError\";\n  }\n}\n\n/**\n * Fetches and parses JSON data from any supported URL protocol\n *\n * @param url - The URL to fetch from (supports ipfs://, https://, http://, ar://)\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 the parsed JSON data\n * @throws {UrlResolutionError} When the URL cannot be resolved or parsed\n *\n * @example\n * ```typescript\n * // Fetch from IPFS\n * const data = await fetchFromUrl(\"ipfs://QmXxx...\");\n *\n * // Fetch from HTTPS\n * const data = await fetchFromUrl(\"https://example.com/data.json\");\n *\n * // Handles protocol conversion internally\n * const schema = await fetchFromUrl(schemaDefinitionUrl);\n * ```\n */\nexport async function fetchFromUrl(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<unknown> {\n  try {\n    // Use unified download utility with automatic fallbacks\n    const response = await universalFetch(url, downloadRelayer);\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Parse JSON response\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    throw new UrlResolutionError(\n      `Failed to fetch from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      url,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n"],"mappings":"AAOA,SAAS,sBAAsB;AAKxB,MAAM,2BAA2B,MAAM;AAAA,EAC5C,YACE,SACgB,KACS,OACzB;AACA,UAAM,OAAO;AAHG;AACS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAuBA,eAAsB,aACpB,KACA,iBACkB;AAClB,MAAI;AAEF,UAAM,WAAW,MAAM,eAAe,KAAK,eAAe;AAE1D,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU,EAAE;AAAA,IACnE;AAGA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,wBAAwB,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACxF;AAAA,MACA,iBAAiB,QAAQ,QAAQ;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/utils/wallet.cjs

@@ -0,0 +1,62 @@
+"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 wallet_exports = {};
+__export(wallet_exports, {
+  extractAddress: () => extractAddress,
+  extractAddressSafe: () => extractAddressSafe,
+  hasAddress: () => hasAddress
+});
+module.exports = __toCommonJS(wallet_exports);
+function extractAddress(account) {
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  if (typeof account === "string") {
+    return account;
+  }
+  if (typeof account === "object" && "address" in account && account.address) {
+    return account.address;
+  }
+  throw new Error("Unable to determine wallet address from account");
+}
+function extractAddressSafe(account) {
+  try {
+    return extractAddress(account);
+  } catch {
+    return void 0;
+  }
+}
+function hasAddress(account) {
+  if (!account) return false;
+  if (typeof account === "string") {
+    return /^0x[a-fA-F0-9]{40}$/.test(account);
+  }
+  if (typeof account === "object" && "address" in account) {
+    const addr = account.address;
+    return typeof addr === "string" && /^0x[a-fA-F0-9]{40}$/.test(addr);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractAddress,
+  extractAddressSafe,
+  hasAddress
+});
+//# sourceMappingURL=wallet.cjs.map

package/dist/utils/wallet.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/wallet.ts"],"sourcesContent":["import type { Account, Address } from \"viem\";\n\n/**\n * Extracts an Ethereum address from various account formats.\n *\n * Viem's Account type can be:\n * - A string address directly\n * - An object with an address property\n * - A LocalAccount with address property\n *\n * This utility provides a single source of truth for address extraction,\n * eliminating duplicate logic throughout the codebase.\n *\n * @param account - The account to extract address from\n * @returns The extracted Ethereum address\n * @throws Error if account is undefined or address cannot be determined\n */\nexport function extractAddress(\n  account: Account | Address | undefined | null,\n): Address {\n  if (!account) {\n    throw new Error(\"No account provided\");\n  }\n\n  // Handle string address directly\n  if (typeof account === \"string\") {\n    return account as Address;\n  }\n\n  // Handle object with address property\n  if (typeof account === \"object\" && \"address\" in account && account.address) {\n    return account.address;\n  }\n\n  throw new Error(\"Unable to determine wallet address from account\");\n}\n\n/**\n * Safely extracts an address, returning undefined instead of throwing.\n * Useful for optional address resolution.\n *\n * @param account - The account to extract address from\n * @returns The extracted address or undefined\n */\nexport function extractAddressSafe(\n  account: Account | Address | undefined | null,\n): Address | undefined {\n  try {\n    return extractAddress(account);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Type guard to check if an account has a valid address.\n *\n * @param account - The account to check\n * @returns True if account has a valid address\n */\nexport function hasAddress(account: unknown): account is Account | Address {\n  if (!account) return false;\n\n  if (typeof account === \"string\") {\n    // Basic check for Ethereum address format\n    return /^0x[a-fA-F0-9]{40}$/.test(account);\n  }\n\n  if (typeof account === \"object\" && \"address\" in account) {\n    const addr = (account as any).address;\n    return typeof addr === \"string\" && /^0x[a-fA-F0-9]{40}$/.test(addr);\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,eACd,SACS;AACT,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAGA,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,YAAY,YAAY,aAAa,WAAW,QAAQ,SAAS;AAC1E,WAAO,QAAQ;AAAA,EACjB;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;AASO,SAAS,mBACd,SACqB;AACrB,MAAI;AACF,WAAO,eAAe,OAAO;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,SAAS,WAAW,SAAgD;AACzE,MAAI,CAAC,QAAS,QAAO;AAErB,MAAI,OAAO,YAAY,UAAU;AAE/B,WAAO,sBAAsB,KAAK,OAAO;AAAA,EAC3C;AAEA,MAAI,OAAO,YAAY,YAAY,aAAa,SAAS;AACvD,UAAM,OAAQ,QAAgB;AAC9B,WAAO,OAAO,SAAS,YAAY,sBAAsB,KAAK,IAAI;AAAA,EACpE;AAEA,SAAO;AACT;","names":[]}