viem 0.2.11 → 0.2.13

package/src/errors/abi.ts

@@ -0,0 +1,375 @@
+import type { AbiParameter } from 'abitype'
+import type { AbiItem, Hex } from '../types/index.js'
+import { formatAbiItem, formatAbiParams, size } from '../utils/index.js'
+import { BaseError } from './base.js'
+
+export class AbiConstructorNotFoundError extends BaseError {
+  name = 'AbiConstructorNotFoundError'
+  constructor({ docsPath }: { docsPath: string }) {
+    super(
+      [
+        'A constructor was not found on the ABI.',
+        'Make sure you are using the correct ABI and that the constructor exists on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiConstructorParamsNotFoundError extends BaseError {
+  name = 'AbiConstructorParamsNotFoundError'
+  constructor({ docsPath }: { docsPath: string }) {
+    super(
+      [
+        'Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.',
+        'Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiDecodingDataSizeInvalidError extends BaseError {
+  name = 'AbiDecodingDataSizeInvalidError'
+  constructor({ data, size }: { data: Hex; size: number }) {
+    super(
+      [
+        `Data size of ${size} bytes is invalid.`,
+        'Size must be in increments of 32 bytes (size % 32 === 0).',
+      ].join('\n'),
+      { metaMessages: [`Data: ${data} (${size} bytes)`] },
+    )
+  }
+}
+
+export class AbiDecodingDataSizeTooSmallError extends BaseError {
+  name = 'AbiDecodingDataSizeTooSmallError'
+
+  data: Hex
+  params: readonly AbiParameter[]
+  size: number
+
+  constructor({
+    data,
+    params,
+    size,
+  }: { data: Hex; params: readonly AbiParameter[]; size: number }) {
+    super(
+      [`Data size of ${size} bytes is too small for given parameters.`].join(
+        '\n',
+      ),
+      {
+        metaMessages: [
+          `Params: (${formatAbiParams(params, { includeName: true })})`,
+          `Data:   ${data} (${size} bytes)`,
+        ],
+      },
+    )
+
+    this.data = data
+    this.params = params
+    this.size = size
+  }
+}
+
+export class AbiDecodingZeroDataError extends BaseError {
+  name = 'AbiDecodingZeroDataError'
+  constructor() {
+    super('Cannot decode zero data ("0x") with ABI parameters.')
+  }
+}
+
+export class AbiEncodingArrayLengthMismatchError extends BaseError {
+  name = 'AbiEncodingArrayLengthMismatchError'
+  constructor({
+    expectedLength,
+    givenLength,
+    type,
+  }: { expectedLength: number; givenLength: number; type: string }) {
+    super(
+      [
+        `ABI encoding array length mismatch for type ${type}.`,
+        `Expected length: ${expectedLength}`,
+        `Given length: ${givenLength}`,
+      ].join('\n'),
+    )
+  }
+}
+
+export class AbiEncodingBytesSizeMismatchError extends BaseError {
+  name = 'AbiEncodingBytesSizeMismatchError'
+  constructor({ expectedSize, value }: { expectedSize: number; value: Hex }) {
+    super(
+      `Size of bytes "${value}" (bytes${size(
+        value,
+      )}) does not match expected size (bytes${expectedSize}).`,
+    )
+  }
+}
+
+export class AbiEncodingLengthMismatchError extends BaseError {
+  name = 'AbiEncodingLengthMismatchError'
+  constructor({
+    expectedLength,
+    givenLength,
+  }: { expectedLength: number; givenLength: number }) {
+    super(
+      [
+        'ABI encoding params/values length mismatch.',
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`,
+      ].join('\n'),
+    )
+  }
+}
+
+export class AbiErrorInputsNotFoundError extends BaseError {
+  name = 'AbiErrorInputsNotFoundError'
+  constructor(errorName: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
+        'Cannot encode error result without knowing what the parameter types are.',
+        'Make sure you are using the correct ABI and that the inputs exist on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiErrorNotFoundError extends BaseError {
+  name = 'AbiErrorNotFoundError'
+  constructor(errorName: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Error "${errorName}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the error exists on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiErrorSignatureNotFoundError extends BaseError {
+  name = 'AbiErrorSignatureNotFoundError'
+  constructor(signature: Hex, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Encoded error signature "${signature}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the error exists on it.',
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`,
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiEventSignatureEmptyTopicsError extends BaseError {
+  name = 'AbiEventSignatureEmptyTopicsError'
+  constructor({ docsPath }: { docsPath: string }) {
+    super('Cannot extract event signature from empty topics.', {
+      docsPath,
+    })
+  }
+}
+
+export class AbiEventSignatureNotFoundError extends BaseError {
+  name = 'AbiEventSignatureNotFoundError'
+  constructor(signature: Hex, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Encoded event signature "${signature}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the event exists on it.',
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`,
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiEventNotFoundError extends BaseError {
+  name = 'AbiEventNotFoundError'
+  constructor(eventName: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Event "${eventName}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the event exists on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiFunctionNotFoundError extends BaseError {
+  name = 'AbiFunctionNotFoundError'
+  constructor(functionName: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Function "${functionName}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the function exists on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiFunctionOutputsNotFoundError extends BaseError {
+  name = 'AbiFunctionOutputsNotFoundError'
+  constructor(functionName: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
+        'Cannot decode function result without knowing what the parameter types are.',
+        'Make sure you are using the correct ABI and that the function exists on it.',
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class AbiFunctionSignatureNotFoundError extends BaseError {
+  name = 'AbiFunctionSignatureNotFoundError'
+  constructor(signature: Hex, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Encoded function signature "${signature}" not found on ABI.`,
+        'Make sure you are using the correct ABI and that the function exists on it.',
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`,
+      ].join('\n'),
+      {
+        docsPath,
+      },
+    )
+  }
+}
+
+export class BytesSizeMismatchError extends BaseError {
+  name = 'BytesSizeMismatchError'
+  constructor({
+    expectedSize,
+    givenSize,
+  }: { expectedSize: number; givenSize: number }) {
+    super(`Expected bytes${expectedSize}, got bytes${givenSize}.`)
+  }
+}
+
+export class DecodeLogDataMismatch extends BaseError {
+  name = 'DecodeLogDataMismatch'
+
+  data: Hex
+  params: readonly AbiParameter[]
+  size: number
+
+  constructor({
+    data,
+    params,
+    size,
+  }: { data: Hex; params: readonly AbiParameter[]; size: number }) {
+    super(
+      [
+        `Data size of ${size} bytes is too small for non-indexed event parameters.`,
+      ].join('\n'),
+      {
+        metaMessages: [
+          'This error is usually caused if the ABI event has too many non-indexed event parameters for the emitted log.',
+          '',
+          `Params: (${formatAbiParams(params, { includeName: true })})`,
+          `Data:   ${data} (${size} bytes)`,
+        ],
+      },
+    )
+
+    this.data = data
+    this.params = params
+    this.size = size
+  }
+}
+
+export class DecodeLogTopicsMismatch extends BaseError {
+  name = 'DecodeLogTopicsMismatch'
+  constructor({
+    abiItem,
+    param,
+  }: {
+    abiItem: AbiItem
+    param: AbiParameter & { indexed: boolean }
+  }) {
+    super(
+      [
+        `Expected a topic for indexed event parameter${
+          param.name ? ` "${param.name}"` : ''
+        } on event "${formatAbiItem(abiItem, { includeName: true })}".`,
+      ].join('\n'),
+    )
+  }
+}
+
+export class InvalidAbiEncodingTypeError extends BaseError {
+  name = 'InvalidAbiEncodingType'
+  constructor(type: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Type "${type}" is not a valid encoding type.`,
+        'Please provide a valid ABI type.',
+      ].join('\n'),
+      { docsPath },
+    )
+  }
+}
+
+export class InvalidAbiDecodingTypeError extends BaseError {
+  name = 'InvalidAbiDecodingType'
+  constructor(type: string, { docsPath }: { docsPath: string }) {
+    super(
+      [
+        `Type "${type}" is not a valid decoding type.`,
+        'Please provide a valid ABI type.',
+      ].join('\n'),
+      { docsPath },
+    )
+  }
+}
+
+export class InvalidArrayError extends BaseError {
+  name = 'InvalidArrayError'
+  constructor(value: unknown) {
+    super([`Value "${value}" is not a valid array.`].join('\n'))
+  }
+}
+
+export class InvalidDefinitionTypeError extends BaseError {
+  name = 'InvalidDefinitionTypeError'
+  constructor(type: string) {
+    super(
+      [
+        `"${type}" is not a valid definition type.`,
+        'Valid types: "function", "event", "error"',
+      ].join('\n'),
+    )
+  }
+}
+
+export class UnsupportedPackedAbiType extends BaseError {
+  name = 'UnsupportedPackedAbiType'
+  constructor(type: unknown) {
+    super(`Type "${type}" is not supported for packed encoding.`)
+  }
+}

package/src/errors/account.ts

@@ -0,0 +1,17 @@
+import { BaseError } from './base.js'
+
+export class AccountNotFoundError extends BaseError {
+  name = 'AccountNotFoundError'
+  constructor({ docsPath }: { docsPath?: string } = {}) {
+    super(
+      [
+        'Could not find an Account to execute with this Action.',
+        'Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the WalletClient.',
+      ].join('\n'),
+      {
+        docsPath,
+        docsSlug: 'account',
+      },
+    )
+  }
+}

package/src/errors/address.ts

@@ -0,0 +1,8 @@
+import { BaseError } from './base.js'
+
+export class InvalidAddressError extends BaseError {
+  name = 'InvalidAddressError'
+  constructor({ address }: { address: string }) {
+    super(`Address "${address}" is invalid.`)
+  }
+}

package/src/errors/base.ts

@@ -0,0 +1,60 @@
+import { getVersion } from './utils.js'
+
+type BaseErrorParameters = {
+  docsPath?: string
+  docsSlug?: string
+  metaMessages?: string[]
+} & (
+  | {
+      cause?: never
+      details?: string
+    }
+  | {
+      cause: BaseError | Error
+      details?: never
+    }
+)
+
+export class BaseError extends Error {
+  details: string
+  docsPath?: string
+  metaMessages?: string[]
+  shortMessage: string
+
+  name = 'ViemError'
+
+  constructor(shortMessage: string, args: BaseErrorParameters = {}) {
+    const details =
+      args.cause instanceof BaseError
+        ? args.cause.details
+        : args.cause?.message
+        ? args.cause.message
+        : args.details!
+    const docsPath =
+      args.cause instanceof BaseError
+        ? args.cause.docsPath || args.docsPath
+        : args.docsPath
+    const message = [
+      shortMessage || 'An error occurred.',
+      '',
+      ...(args.metaMessages ? [...args.metaMessages, ''] : []),
+      ...(docsPath
+        ? [
+            `Docs: https://viem.sh${docsPath}.html${
+              args.docsSlug ? `#${args.docsSlug}` : ''
+            }`,
+          ]
+        : []),
+      ...(details ? [`Details: ${details}`] : []),
+      `Version: ${getVersion()}`,
+    ].join('\n')
+
+    super(message)
+
+    if (args.cause) this.cause = args.cause
+    this.details = details
+    this.docsPath = docsPath
+    this.metaMessages = args.metaMessages
+    this.shortMessage = shortMessage
+  }
+}

package/src/errors/block.ts

@@ -0,0 +1,18 @@
+import type { Hash } from '../types/index.js'
+import { BaseError } from './base.js'
+
+export class BlockNotFoundError extends BaseError {
+  name = 'BlockNotFoundError'
+  constructor({
+    blockHash,
+    blockNumber,
+  }: {
+    blockHash?: Hash
+    blockNumber?: bigint
+  }) {
+    let identifier = 'Block'
+    if (blockHash) identifier = `Block at hash "${blockHash}"`
+    if (blockNumber) identifier = `Block at number "${blockNumber}"`
+    super(`${identifier} could not be found.`)
+  }
+}

package/src/errors/chain.ts

@@ -0,0 +1,76 @@
+import type { Chain } from '../types/index.js'
+import { BaseError } from './base.js'
+
+export class ChainDoesNotSupportContract extends BaseError {
+  name = 'ChainDoesNotSupportContract'
+  constructor({
+    blockNumber,
+    chain,
+    contract,
+  }: {
+    blockNumber?: bigint
+    chain: Chain
+    contract: { name: string; blockCreated?: number }
+  }) {
+    super(
+      `Chain "${chain.name}" does not support contract "${contract.name}".`,
+      {
+        metaMessages: [
+          'This could be due to any of the following:',
+          ...(blockNumber &&
+          contract.blockCreated &&
+          contract.blockCreated > blockNumber
+            ? [
+                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`,
+              ]
+            : [
+                `- The chain does not have the contract "${contract.name}" configured.`,
+              ]),
+        ],
+      },
+    )
+  }
+}
+
+export class ChainMismatchError extends BaseError {
+  name = 'ChainMismatchError'
+
+  constructor({
+    chain,
+    currentChainId,
+  }: {
+    chain: Chain
+    currentChainId: number
+  }) {
+    super(
+      `The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} – ${chain.name}).`,
+      {
+        metaMessages: [
+          `Current Chain ID:  ${currentChainId}`,
+          `Expected Chain ID: ${chain.id} – ${chain.name}`,
+        ],
+      },
+    )
+  }
+}
+
+export class ChainNotFoundError extends BaseError {
+  name = 'ChainNotFoundError'
+
+  constructor() {
+    super(
+      [
+        'No chain was provided to the request.',
+        'Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient.',
+      ].join('\n'),
+    )
+  }
+}
+
+export class InvalidChainIdError extends BaseError {
+  name = 'InvalidChainIdError'
+
+  constructor({ chainId }: { chainId: number }) {
+    super(`Chain ID "${chainId}" is invalid.`)
+  }
+}