viem 2.0.0-alpha.12 → 2.0.0-alpha.13

package/utils/signature/hashMessage.ts

@@ -1,7 +1,13 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
-import { concat } from '../data/concat.js'
-import { stringToBytes, toBytes } from '../encoding/toBytes.js'
-import { keccak256 } from '../hash/keccak256.js'
+import { type ConcatErrorType, concat } from '../data/concat.js'
+import {
+  type StringToBytesErrorType,
+  type ToBytesErrorType,
+  stringToBytes,
+  toBytes,
+} from '../encoding/toBytes.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
 
@@ -9,6 +15,13 @@ export type HashMessage<TTo extends To> =
   | (TTo extends 'bytes' ? ByteArray : never)
   | (TTo extends 'hex' ? Hex : never)
 
+export type HashMessageErrorType =
+  | ConcatErrorType
+  | Keccak256ErrorType
+  | StringToBytesErrorType
+  | ToBytesErrorType
+  | ErrorType
+
 export function hashMessage<TTo extends To = 'hex'>(
   message: SignableMessage,
   to_?: TTo,

package/utils/signature/hashTypedData.ts

@@ -2,13 +2,22 @@
 
 import type { AbiParameter, TypedData, TypedDataDomain } from 'abitype'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { encodeAbiParameters } from '../abi/encodeAbiParameters.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from '../abi/encodeAbiParameters.js'
 import { concat } from '../data/concat.js'
-import { toHex } from '../encoding/toHex.js'
-import { keccak256 } from '../hash/keccak256.js'
-import { getTypesForEIP712Domain, validateTypedData } from '../typedData.js'
+import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import {
+  type GetTypesForEIP712DomainErrorType,
+  type ValidateTypedDataErrorType,
+  getTypesForEIP712Domain,
+  validateTypedData,
+} from '../typedData.js'
 
 type MessageTypeProperty = {
   name: string
@@ -22,6 +31,13 @@ export type HashTypedDataParameters<
 
 export type HashTypedDataReturnType = Hex
 
+export type HashTypedDataErrorType =
+  | GetTypesForEIP712DomainErrorType
+  | HashDomainErrorType
+  | HashStructErrorType
+  | ValidateTypedDataErrorType
+  | ErrorType
+
 export function hashTypedData<
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',
@@ -68,6 +84,8 @@ export function hashTypedData<
   return keccak256(concat(parts))
 }
 
+export type HashDomainErrorType = HashStructErrorType | ErrorType
+
 export function hashDomain({
   domain,
   types,
@@ -82,6 +100,8 @@ export function hashDomain({
   })
 }
 
+type HashStructErrorType = EncodeDataErrorType | Keccak256ErrorType | ErrorType
+
 function hashStruct({
   data,
   primaryType,
@@ -99,6 +119,12 @@ function hashStruct({
   return keccak256(encoded)
 }
 
+type EncodeDataErrorType =
+  | EncodeAbiParametersErrorType
+  | EncodeFieldErrorType
+  | HashTypeErrorType
+  | ErrorType
+
 function encodeData({
   data,
   primaryType,
@@ -125,6 +151,12 @@ function encodeData({
   return encodeAbiParameters(encodedTypes, encodedValues)
 }
 
+type HashTypeErrorType =
+  | ToHexErrorType
+  | EncodeTypeErrorType
+  | Keccak256ErrorType
+  | ErrorType
+
 function hashType({
   primaryType,
   types,
@@ -136,6 +168,8 @@ function hashType({
   return keccak256(encodedHashType)
 }
 
+type EncodeTypeErrorType = FindTypeDependenciesErrorType
+
 function encodeType({
   primaryType,
   types,
@@ -157,6 +191,8 @@ function encodeType({
   return result
 }
 
+type FindTypeDependenciesErrorType = ErrorType
+
 function findTypeDependencies(
   {
     primaryType: primaryType_,
@@ -181,6 +217,12 @@ function findTypeDependencies(
   return results
 }
 
+type EncodeFieldErrorType =
+  | Keccak256ErrorType
+  | EncodeAbiParametersErrorType
+  | ToHexErrorType
+  | ErrorType
+
 function encodeField({
   types,
   name,

package/utils/signature/hexToSignature.ts

@@ -1,7 +1,13 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex, Signature } from '../../types/misc.js'
-import { numberToHex } from '../../utils/encoding/toHex.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+
+export type HexToSignatureErrorType = NumberToHexErrorType | ErrorType
 
 /**
  * @description Parses a hex formatted signature into a structured signature.

package/utils/signature/recoverAddress.ts

@@ -3,14 +3,18 @@ import type { Address } from 'abitype'
 import { publicKeyToAddress } from '../../accounts/utils/publicKeyToAddress.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import { recoverPublicKey } from './recoverPublicKey.js'
 
 export type RecoverAddressParameters = {
   hash: Hex | ByteArray
   signature: Hex | ByteArray
 }
+
 export type RecoverAddressReturnType = Address
 
+export type RecoverAddressErrorType = ErrorType
+
 export async function recoverAddress({
   hash,
   signature,

package/utils/signature/recoverMessageAddress.ts

@@ -2,15 +2,25 @@ import type { Address } from 'abitype'
 
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 
-import { hashMessage } from './hashMessage.js'
-import { recoverAddress } from './recoverAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type HashMessageErrorType, hashMessage } from './hashMessage.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from './recoverAddress.js'
 
 export type RecoverMessageAddressParameters = {
   message: SignableMessage
   signature: Hex | ByteArray
 }
+
 export type RecoverMessageAddressReturnType = Address
 
+export type RecoverMessageAddressErrorType =
+  | HashMessageErrorType
+  | RecoverAddressErrorType
+  | ErrorType
+
 export async function recoverMessageAddress({
   message,
   signature,

package/utils/signature/recoverPublicKey.ts

@@ -1,14 +1,21 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { hexToNumber } from '../encoding/fromHex.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type HexToNumberErrorType, hexToNumber } from '../encoding/fromHex.js'
 import { toHex } from '../encoding/toHex.js'
 
 export type RecoverPublicKeyParameters = {
   hash: Hex | ByteArray
   signature: Hex | ByteArray
 }
+
 export type RecoverPublicKeyReturnType = Hex
 
+export type RecoverPublicKeyErrorType =
+  | HexToNumberErrorType
+  | IsHexErrorType
+  | ErrorType
+
 export async function recoverPublicKey({
   hash,
   signature,

package/utils/signature/recoverTypedDataAddress.ts

@@ -3,8 +3,12 @@ import type { Address, TypedData } from 'abitype'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
 
-import { hashTypedData } from './hashTypedData.js'
-import { recoverAddress } from './recoverAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type HashTypedDataErrorType, hashTypedData } from './hashTypedData.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from './recoverAddress.js'
 
 export type RecoverTypedDataAddressParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
@@ -12,8 +16,14 @@ export type RecoverTypedDataAddressParameters<
 > = TypedDataDefinition<typedData, primaryType> & {
   signature: Hex | ByteArray
 }
+
 export type RecoverTypedDataAddressReturnType = Address
 
+export type RecoverTypedDataAddressErrorType =
+  | RecoverAddressErrorType
+  | HashTypedDataErrorType
+  | ErrorType
+
 export async function recoverTypedDataAddress<
   const typedData extends TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | 'EIP712Domain',

package/utils/signature/signatureToHex.ts

@@ -1,8 +1,17 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex, Signature } from '../../types/misc.js'
-import { hexToBigInt } from '../../utils/encoding/fromHex.js'
-import { toHex } from '../../utils/encoding/toHex.js'
+import {
+  type HexToBigIntErrorType,
+  hexToBigInt,
+} from '../../utils/encoding/fromHex.js'
+import { type ToHexErrorType, toHex } from '../../utils/encoding/toHex.js'
+
+export type SignatureToHexErrorType =
+  | HexToBigIntErrorType
+  | ToHexErrorType
+  | ErrorType
 
 /**
  * @description Converts a signature into hex format.

package/utils/signature/verifyMessage.ts

@@ -1,10 +1,17 @@
 import type { Address } from 'abitype'
 
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
-import { getAddress } from '../address/getAddress.js'
-import { isAddressEqual } from '../address/isAddressEqual.js'
+import { type GetAddressErrorType, getAddress } from '../address/getAddress.js'
+import {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from '../address/isAddressEqual.js'
 
-import { recoverMessageAddress } from './recoverMessageAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type RecoverMessageAddressErrorType,
+  recoverMessageAddress,
+} from './recoverMessageAddress.js'
 
 export type VerifyMessageParameters = {
   /** The address that signed the original message. */
@@ -17,6 +24,12 @@ export type VerifyMessageParameters = {
 
 export type VerifyMessageReturnType = boolean
 
+export type VerifyMessageErrorType =
+  | IsAddressEqualErrorType
+  | GetAddressErrorType
+  | RecoverMessageAddressErrorType
+  | ErrorType
+
 /**
  * Verify that a message was signed by the provided address.
  *

package/utils/signature/verifyTypedData.ts

@@ -2,9 +2,13 @@ import type { Address, TypedData } from 'abitype'
 
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { getAddress } from '../address/getAddress.js'
-import { isAddressEqual } from '../address/isAddressEqual.js'
+import { type GetAddressErrorType, getAddress } from '../address/getAddress.js'
+import {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from '../address/isAddressEqual.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import {
   type RecoverTypedDataAddressParameters,
   recoverTypedDataAddress,
@@ -22,6 +26,12 @@ export type VerifyTypedDataParameters<
 
 export type VerifyTypedDataReturnType = boolean
 
+export type VerifyTypedDataErrorType =
+  | IsAddressEqualErrorType
+  | GetAddressErrorType
+  | RecoverTypedDataAddressParameters
+  | ErrorType
+
 /**
  * Verify that typed data was signed by the provided address.
  *

package/utils/stringify.ts

@@ -1,3 +1,7 @@
+import type { ErrorType } from '../errors/utils.js'
+
+export type StringifyErrorType = ErrorType
+
 export const stringify: typeof JSON.stringify = (value, replacer, space) =>
   JSON.stringify(
     value,

package/utils/transaction/assertRequest.ts

@@ -1,13 +1,36 @@
-import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
 import type { SendTransactionParameters } from '../../actions/wallet/sendTransaction.js'
-import { InvalidAddressError } from '../../errors/address.js'
-import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
-import { FeeConflictError } from '../../errors/transaction.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import {
+  FeeCapTooHighError,
+  type FeeCapTooHighErrorType,
+  TipAboveFeeCapError,
+  type TipAboveFeeCapErrorType,
+} from '../../errors/node.js'
+import {
+  FeeConflictError,
+  type FeeConflictErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import { isAddress } from '../address/isAddress.js'
 
 export type AssertRequestParameters = Partial<SendTransactionParameters<Chain>>
 
+export type AssertRequestErrorType =
+  | InvalidAddressErrorType
+  | FeeConflictErrorType
+  | FeeCapTooHighErrorType
+  | ParseAccountErrorType
+  | TipAboveFeeCapErrorType
+  | ErrorType
+
 export function assertRequest(args: AssertRequestParameters) {
   const {
     account: account_,

package/utils/transaction/assertTransaction.ts

@@ -1,13 +1,34 @@
-import { InvalidAddressError } from '../../errors/address.js'
-import { BaseError } from '../../errors/base.js'
-import { InvalidChainIdError } from '../../errors/chain.js'
-import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import { BaseError, type BaseErrorType } from '../../errors/base.js'
+import {
+  InvalidChainIdError,
+  type InvalidChainIdErrorType,
+} from '../../errors/chain.js'
+import {
+  FeeCapTooHighError,
+  type FeeCapTooHighErrorType,
+  TipAboveFeeCapError,
+  type TipAboveFeeCapErrorType,
+} from '../../errors/node.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
   TransactionSerializableLegacy,
 } from '../../types/transaction.js'
-import { isAddress } from '../address/isAddress.js'
+import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+
+export type AssertTransactionEIP1559ErrorType =
+  | BaseErrorType
+  | IsAddressErrorType
+  | InvalidAddressErrorType
+  | InvalidChainIdErrorType
+  | FeeCapTooHighErrorType
+  | TipAboveFeeCapErrorType
+  | ErrorType
 
 export function assertTransactionEIP1559(
   transaction: TransactionSerializableEIP1559,
@@ -30,6 +51,14 @@ export function assertTransactionEIP1559(
     throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
 }
 
+export type AssertTransactionEIP2930ErrorType =
+  | BaseErrorType
+  | IsAddressErrorType
+  | InvalidAddressErrorType
+  | InvalidChainIdErrorType
+  | FeeCapTooHighErrorType
+  | ErrorType
+
 export function assertTransactionEIP2930(
   transaction: TransactionSerializableEIP2930,
 ) {
@@ -45,6 +74,14 @@ export function assertTransactionEIP2930(
     throw new FeeCapTooHighError({ maxFeePerGas: gasPrice })
 }
 
+export type AssertTransactionLegacyErrorType =
+  | BaseErrorType
+  | IsAddressErrorType
+  | InvalidAddressErrorType
+  | InvalidChainIdErrorType
+  | FeeCapTooHighErrorType
+  | ErrorType
+
 export function assertTransactionLegacy(
   transaction: TransactionSerializableLegacy,
 ) {

package/utils/transaction/getSerializedTransactionType.ts

@@ -1,11 +1,15 @@
-import { InvalidSerializedTransactionTypeError } from '../../errors/transaction.js'
+import {
+  InvalidSerializedTransactionTypeError,
+  type InvalidSerializedTransactionTypeErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   TransactionSerialized,
   TransactionSerializedEIP1559,
   TransactionSerializedEIP2930,
 } from '../../types/transaction.js'
-import { sliceHex } from '../data/slice.js'
-import { hexToNumber } from '../encoding/fromHex.js'
+import { type SliceHexErrorType, sliceHex } from '../data/slice.js'
+import { type HexToNumberErrorType, hexToNumber } from '../encoding/fromHex.js'
 
 export type GetSerializedTransactionType<
   TTransactionSerialized extends TransactionSerialized = TransactionSerialized,
@@ -15,6 +19,12 @@ export type GetSerializedTransactionType<
   ? 'eip2930'
   : 'legacy'
 
+export type GetSerializedTransactionTypeErrorType =
+  | HexToNumberErrorType
+  | InvalidSerializedTransactionTypeErrorType
+  | SliceHexErrorType
+  | ErrorType
+
 export function getSerializedTransactionType<
   TSerialized extends TransactionSerialized,
 >(

package/utils/transaction/getTransactionType.ts

@@ -1,4 +1,8 @@
-import { InvalidSerializableTransactionError } from '../../errors/transaction.js'
+import {
+  InvalidSerializableTransactionError,
+  type InvalidSerializableTransactionErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   TransactionSerializable,
   TransactionSerializableEIP1559,
@@ -23,6 +27,10 @@ export type GetTransactionType<
       ? TTransactionSerializable['type']
       : never)
 
+export type GetTransationTypeErrorType =
+  | InvalidSerializableTransactionErrorType
+  | ErrorType
+
 export function getTransactionType<
   TTransactionSerializable extends TransactionSerializable,
 >(

package/utils/transaction/parseTransaction.ts

@@ -1,8 +1,14 @@
-import { InvalidAddressError } from '../../errors/address.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
 import {
   InvalidLegacyVError,
+  type InvalidLegacyVErrorType,
   InvalidSerializedTransactionError,
+  type InvalidSerializedTransactionErrorType,
 } from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex, Signature } from '../../types/misc.js'
 import type {
   AccessList,
@@ -16,22 +22,31 @@ import type {
   TransactionSerializedEIP2930,
   TransactionType,
 } from '../../types/transaction.js'
-import { isAddress } from '../address/isAddress.js'
-import { isHex } from '../data/isHex.js'
-import { padHex } from '../data/pad.js'
+import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type PadHexErrorType, padHex } from '../data/pad.js'
 import { trim } from '../data/trim.js'
-import { hexToBigInt, hexToNumber } from '../encoding/fromHex.js'
-import { fromRlp } from '../encoding/fromRlp.js'
+import {
+  type HexToBigIntErrorType,
+  type HexToNumberErrorType,
+  hexToBigInt,
+  hexToNumber,
+} from '../encoding/fromHex.js'
+import { type FromRlpErrorType, fromRlp } from '../encoding/fromRlp.js'
 import type { RecursiveArray } from '../encoding/toRlp.js'
 import { isHash } from '../hash/isHash.js'
 
 import {
+  type AssertTransactionEIP1559ErrorType,
+  type AssertTransactionEIP2930ErrorType,
+  type AssertTransactionLegacyErrorType,
   assertTransactionEIP1559,
   assertTransactionEIP2930,
   assertTransactionLegacy,
 } from './assertTransaction.js'
 import {
   type GetSerializedTransactionType,
+  type GetSerializedTransactionTypeErrorType,
   getSerializedTransactionType,
 } from './getSerializedTransactionType.js'
 
@@ -43,6 +58,12 @@ export type ParseTransactionReturnType<
   | (TType extends 'eip2930' ? TransactionSerializableEIP2930 : never)
   | (TType extends 'legacy' ? TransactionSerializableLegacy : never)
 
+export type ParseTransactionErrorType =
+  | GetSerializedTransactionTypeErrorType
+  | ParseTransactionEIP1559ErrorType
+  | ParseTransactionEIP2930ErrorType
+  | ParseTransactionLegacyErrorType
+
 export function parseTransaction<TSerialized extends TransactionSerialized>(
   serializedTransaction: TSerialized,
 ): ParseTransactionReturnType<TSerialized> {
@@ -63,6 +84,17 @@ export function parseTransaction<TSerialized extends TransactionSerialized>(
   ) as ParseTransactionReturnType<TSerialized>
 }
 
+type ParseTransactionEIP1559ErrorType =
+  | AssertTransactionEIP1559ErrorType
+  | ToTransactionArrayErrorType
+  | HexToBigIntErrorType
+  | HexToNumberErrorType
+  | InvalidLegacyVErrorType
+  | InvalidSerializedTransactionErrorType
+  | IsHexErrorType
+  | ParseEIP155SignatureErrorType
+  | ErrorType
+
 function parseTransactionEIP1559(
   serializedTransaction: TransactionSerializedEIP1559,
 ): TransactionSerializableEIP1559 {
@@ -133,6 +165,17 @@ function parseTransactionEIP1559(
   return { ...signature, ...transaction }
 }
 
+type ParseTransactionEIP2930ErrorType =
+  | AssertTransactionEIP2930ErrorType
+  | ToTransactionArrayErrorType
+  | HexToBigIntErrorType
+  | HexToNumberErrorType
+  | InvalidLegacyVErrorType
+  | InvalidSerializedTransactionErrorType
+  | IsHexErrorType
+  | ParseEIP155SignatureErrorType
+  | ErrorType
+
 function parseTransactionEIP2930(
   serializedTransaction: TransactionSerializedEIP2930,
 ): Omit<TransactionRequestEIP2930, 'from'> &
@@ -189,6 +232,16 @@ function parseTransactionEIP2930(
   return { ...signature, ...transaction }
 }
 
+type ParseTransactionLegacyErrorType =
+  | AssertTransactionLegacyErrorType
+  | FromRlpErrorType
+  | HexToBigIntErrorType
+  | HexToNumberErrorType
+  | InvalidLegacyVErrorType
+  | InvalidSerializedTransactionErrorType
+  | IsHexErrorType
+  | ErrorType
+
 function parseTransactionLegacy(
   serializedTransaction: Hex,
 ): Omit<TransactionRequestLegacy, 'from'> &
@@ -257,10 +310,17 @@ function parseTransactionLegacy(
   return transaction
 }
 
+export type ToTransactionArrayErrorType = FromRlpErrorType | ErrorType
+
 export function toTransactionArray(serializedTransaction: string) {
   return fromRlp(`0x${serializedTransaction.slice(4)}` as Hex, 'hex')
 }
 
+export type ParseAccessListErrorType =
+  | InvalidAddressErrorType
+  | IsAddressErrorType
+  | ErrorType
+
 export function parseAccessList(accessList_: RecursiveArray<Hex>): AccessList {
   const accessList: AccessList = []
   for (let i = 0; i < accessList_.length; i++) {
@@ -276,6 +336,11 @@ export function parseAccessList(accessList_: RecursiveArray<Hex>): AccessList {
   return accessList
 }
 
+type ParseEIP155SignatureErrorType =
+  | HexToBigIntErrorType
+  | PadHexErrorType
+  | ErrorType
+
 function parseEIP155Signature(
   transactionArray: RecursiveArray<Hex>,
 ): Signature & { yParity: number } {