viem 0.0.0-portable-types-20230523145621 → 0.0.0-tmm-sign-typed-data-types.20230619T221425

package/src/types/filter.ts

@@ -1,11 +1,19 @@
 import type { Abi } from 'abitype'
 
 import type { MaybeExtractEventArgsFromAbi } from './contract.js'
-import type { Requests } from './eip1193.js'
+import type { EIP1193RequestFn, PublicRpcSchema } from './eip1193.js'
 import type { Hex } from './misc.js'
+import type { Filter as Filter_ } from './utils.js'
 
 export type FilterType = 'transaction' | 'block' | 'event'
 
+type FilterRpcSchema = Filter_<
+  PublicRpcSchema,
+  {
+    Method: 'eth_getFilterLogs' | 'eth_getFilterChanges' | 'eth_uninstallFilter'
+  }
+>
+
 export type Filter<
   TFilterType extends FilterType = 'event',
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -13,10 +21,10 @@ export type Filter<
   TArgs extends
     | MaybeExtractEventArgsFromAbi<TAbi, TEventName>
     | undefined = MaybeExtractEventArgsFromAbi<TAbi, TEventName>,
+  TStrict extends boolean | undefined = undefined,
 > = {
   id: Hex
-  // TODO: Narrow `request` to filter-based methods (ie. `eth_getFilterLogs`, etc).
-  request: Requests['request']
+  request: EIP1193RequestFn<FilterRpcSchema>
   type: TFilterType
 } & (TFilterType extends 'event'
   ? TAbi extends Abi
@@ -25,21 +33,25 @@ export type Filter<
           abi: TAbi
           args?: never
           eventName?: never
+          strict: TStrict
         }
       : TArgs extends MaybeExtractEventArgsFromAbi<TAbi, TEventName>
       ? {
           abi: TAbi
           args: TArgs
           eventName: TEventName
+          strict: TStrict
         }
       : {
           abi: TAbi
           args?: never
           eventName: TEventName
+          strict: TStrict
         }
     : {
         abi?: never
         args?: never
         eventName?: never
+        strict?: never
       }
   : {})

package/src/types/log.ts

@@ -16,6 +16,7 @@ export type Log<
   TQuantity = bigint,
   TIndex = number,
   TAbiEvent extends AbiEvent | undefined = undefined,
+  TStrict extends boolean | undefined = undefined,
   TAbi extends Abi | readonly unknown[] = [TAbiEvent],
   TEventName extends string | undefined = TAbiEvent extends AbiEvent
     ? TAbiEvent['name']
@@ -37,7 +38,7 @@ export type Log<
   transactionIndex: TIndex | null
   /** `true` if this filter has been destroyed and is invalid */
   removed: boolean
-} & GetInferredLogValues<TAbiEvent, TAbi, TEventName>
+} & GetInferredLogValues<TAbiEvent, TAbi, TEventName, TStrict>
 
 type Topics<
   THead extends AbiEvent['inputs'],
@@ -82,6 +83,7 @@ type GetInferredLogValues<
   TEventName extends string | undefined = TAbiEvent extends AbiEvent
     ? TAbiEvent['name']
     : undefined,
+  TStrict extends boolean | undefined = undefined,
   _EventNames extends string = TAbi extends Abi
     ? Abi extends TAbi
       ? string
@@ -93,7 +95,11 @@ type GetInferredLogValues<
         args: GetEventArgs<
           TAbi,
           TEventName,
-          { EnableUnion: false; IndexedOnly: false }
+          {
+            EnableUnion: false
+            IndexedOnly: false
+            Required: TStrict extends boolean ? TStrict : false
+          }
         >
         /** The event name decoded from `topics`. */
         eventName: TEventName
@@ -105,7 +111,11 @@ type GetInferredLogValues<
           args: GetEventArgs<
             TAbi,
             string,
-            { EnableUnion: false; IndexedOnly: false }
+            {
+              EnableUnion: false
+              IndexedOnly: false
+              Required: TStrict extends boolean ? TStrict : false
+            }
           >
           /** The event name decoded from `topics`. */
           eventName: TName

package/src/types/misc.ts

@@ -2,6 +2,12 @@ export type ByteArray = Uint8Array
 export type Hex = `0x${string}`
 export type Hash = `0x${string}`
 export type LogTopic = Hex | Hex[] | null
+export type SignableMessage =
+  | string
+  | {
+      /** Raw data representation of the message. */
+      raw: Hex | ByteArray
+    }
 export type Signature = {
   r: Hex
   s: Hex

package/src/types/rpc.ts

@@ -12,7 +12,7 @@ import type {
 export type Index = `0x${string}`
 export type Quantity = `0x${string}`
 export type Status = '0x0' | '0x1'
-export type TransactionType = '0x0' | '0x1' | '0x2'
+export type TransactionType = '0x0' | '0x1' | '0x2' | (string & {})
 
 export type RpcBlock = Block<Quantity, RpcTransaction>
 export type RpcBlockNumber = BlockNumber<Quantity>

package/src/types/transaction.ts

@@ -9,7 +9,7 @@ import type { ValueOf } from './utils.js'
 
 export type AccessList = { address: Address; storageKeys: Hex[] }[]
 
-export type TransactionType = ValueOf<typeof transactionType>
+export type TransactionType = ValueOf<typeof transactionType> | (string & {})
 
 export type TransactionReceipt<
   TQuantity = bigint,
@@ -52,8 +52,6 @@ export type TransactionBase<TQuantity = bigint, TIndex = number> = {
   blockHash: Hash | null
   /** Number of block containing this transaction or `null` if pending */
   blockNumber: TQuantity | null
-  /** Chain ID. */
-  chainId: TIndex
   /** Transaction sender */
   from: Address
   /** Gas provided for transaction execution */
@@ -84,6 +82,7 @@ export type TransactionLegacy<
 > = TransactionBase<TQuantity, TIndex> &
   FeeValuesLegacy<TQuantity> & {
     accessList?: never
+    chainId?: TIndex
     type: TType
   }
 export type TransactionEIP2930<
@@ -93,6 +92,7 @@ export type TransactionEIP2930<
 > = TransactionBase<TQuantity, TIndex> &
   FeeValuesLegacy<TQuantity> & {
     accessList: AccessList
+    chainId: TIndex
     type: TType
   }
 export type TransactionEIP1559<
@@ -102,6 +102,7 @@ export type TransactionEIP1559<
 > = TransactionBase<TQuantity, TIndex> &
   FeeValuesEIP1559<TQuantity> & {
     accessList: AccessList
+    chainId: TIndex
     type: TType
   }
 export type Transaction<TQuantity = bigint, TIndex = number> =
@@ -152,10 +153,15 @@ export type TransactionRequest<TQuantity = bigint, TIndex = number> =
 export type TransactionSerializedEIP1559 = `0x02${string}`
 export type TransactionSerializedEIP2930 = `0x01${string}`
 export type TransactionSerializedLegacy = Hex
+export type TransactionSerializedGeneric = Hex
 export type TransactionSerialized<TType extends TransactionType = 'legacy'> =
-  | (TType extends 'eip1559' ? TransactionSerializedEIP1559 : never)
-  | (TType extends 'eip2930' ? TransactionSerializedEIP2930 : never)
-  | (TType extends 'legacy' ? TransactionSerializedLegacy : never)
+  TType extends 'eip1559'
+    ? TransactionSerializedEIP1559
+    : TType extends 'eip2930'
+    ? TransactionSerializedEIP2930
+    : TType extends 'legacy'
+    ? TransactionSerializedLegacy
+    : TransactionSerializedGeneric
 
 export type TransactionSerializableBase<
   TQuantity = bigint,
@@ -190,7 +196,19 @@ export type TransactionSerializableEIP1559<
     type?: 'eip1559'
     yParity?: number
   }
+export type TransactionSerializableGeneric<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionSerializableBase<TQuantity, TIndex> & {
+  accessList?: AccessList
+  gasPrice?: TQuantity
+  maxFeePerGas?: TQuantity
+  maxPriorityFeePerGas?: TQuantity
+  type: string
+}
+
 export type TransactionSerializable<TQuantity = bigint, TIndex = number> =
   | TransactionSerializableLegacy<TQuantity, TIndex>
   | TransactionSerializableEIP2930<TQuantity, TIndex>
   | TransactionSerializableEIP1559<TQuantity, TIndex>
+  | TransactionSerializableGeneric<TQuantity, TIndex>

package/src/types/typedData.ts

@@ -1,81 +1,72 @@
 import type {
-  Narrow,
   TypedData,
   TypedDataDomain,
   TypedDataToPrimitiveTypes,
 } from 'abitype'
 
 export type TypedDataDefinition<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = {
-  primaryType: GetTypedDataPrimaryType<TTypedData, TPrimaryType>
-} & GetTypedDataMessage<TTypedData, TPrimaryType> &
+  TTypedData extends TypedData | Record<string, unknown> =
+    | TypedData
+    | Record<string, unknown>,
+  TPrimaryType extends keyof TTypedData | 'EIP712Domain' = keyof TTypedData,
+> = GetTypedDataPrimaryType<TTypedData, TPrimaryType> &
+  GetTypedDataMessage<TTypedData, TPrimaryType> &
   GetTypedDataTypes<TTypedData, TPrimaryType> &
   GetTypedDataDomain<TTypedData, TPrimaryType>
 
 export type GetTypedDataDomain<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
+  TTypedData extends TypedData | Record<string, unknown>,
+  TPrimaryType extends keyof TTypedData | 'EIP712Domain',
+  ///
+  Schema extends Record<string, unknown> = TTypedData extends TypedData
     ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key: string]: any },
-  TDomain = TSchema extends { EIP712Domain: infer Domain }
+    : { [_: string]: any },
+  TDomain = Schema extends { EIP712Domain: infer Domain }
     ? Domain
     : TypedDataDomain,
 > = TPrimaryType extends 'EIP712Domain'
-  ? {
-      domain: TDomain
-    }
-  : {
-      domain?: TDomain
-    }
+  ? { domain: TDomain }
+  : { domain?: TDomain }
 
 export type GetTypedDataMessage<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
+  TTypedData extends TypedData | Record<string, unknown>,
+  TPrimaryType extends keyof TTypedData | 'EIP712Domain',
+  ///
+  Schema extends Record<string, unknown> = TTypedData extends TypedData
     ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key: string]: any },
-  TMessage = TSchema[TPrimaryType extends keyof TSchema
+    : { [_: string]: any },
+  Message extends Schema[keyof Schema] = Schema[TPrimaryType extends keyof Schema
     ? TPrimaryType
-    : keyof TSchema],
+    : keyof Schema],
 > = TPrimaryType extends 'EIP712Domain'
   ? {}
-  : { [key: string]: any } extends TMessage // Check if we were able to infer the shape of typed data
+  : { [key: string]: any } extends Message // Check if we were able to infer the shape of typed data
   ? {
       /**
        * Data to sign
        *
        * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link types} for type inference.
        */
-      message: { [key: string]: unknown }
+      message: Record<string, unknown>
     }
   : {
       /** Data to sign */
-      message: TMessage
+      message: Message
     }
 
 export type GetTypedDataPrimaryType<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TTypedData extends TypedData
-  ? keyof TTypedData extends infer AbiFunctionNames
-    ?
-        | AbiFunctionNames
-        | (TPrimaryType extends AbiFunctionNames ? TPrimaryType : never)
-        | (TypedData extends TTypedData ? string : never)
-        | 'EIP712Domain'
-    : never
-  : TPrimaryType
+  TTypedData extends TypedData | Record<string, unknown>,
+  TPrimaryType extends keyof TTypedData,
+> = {
+  primaryType:
+    | TPrimaryType // infer value
+    | keyof TTypedData // show all values
+    | 'EIP712Domain'
+}
 
 export type GetTypedDataTypes<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  TTypedData extends TypedData | Record<string, unknown>,
+  TPrimaryType extends keyof TTypedData | 'EIP712Domain',
 > = TPrimaryType extends 'EIP712Domain'
-  ? {
-      types?: Narrow<TTypedData>
-    }
-  : {
-      types: Narrow<TTypedData>
-    }
+  ? { types?: TTypedData }
+  : { types: TTypedData }

package/src/types/utils.ts

@@ -106,6 +106,21 @@ export type MaybeRequired<T, TRequired extends boolean> = TRequired extends true
   ? Required<T>
   : T
 
+/**
+ * @description Makes the attribute on the type T allow undefined if TUndefinedish is true.
+ *
+ * @example
+ * MaybeUndefined<string, true>
+ * => string | undefined
+ *
+ * MaybeUndefined<string, false>
+ * => string
+ */
+export type MaybeUndefined<
+  T,
+  TUndefinedish extends boolean,
+> = TUndefinedish extends true ? T | undefined : T
+
 /**
  * @description Merges the intersection properties of T and U.
  *

package/src/utils/abi/decodeEventLog.ts

@@ -24,10 +24,12 @@ export type DecodeEventLogParameters<
   TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
 > = {
   abi: Narrow<TAbi>
   data?: TData
   eventName?: InferEventName<TAbi, TEventName>
+  strict?: TStrict
   topics: [signature: Hex, ...args: TTopics] | []
 }
 
@@ -36,6 +38,7 @@ export type DecodeEventLogReturnType<
   TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
   _EventNames extends string = TAbi extends Abi
     ? Abi extends TAbi
       ? string
@@ -45,13 +48,13 @@ export type DecodeEventLogReturnType<
   ? Prettify<
       {
         eventName: TEventName
-      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData>
+      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData, TStrict>
     >
   : {
       [TName in _EventNames]: Prettify<
         {
           eventName: TName
-        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData>
+        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData, TStrict>
       >
     }[_EventNames]
 
@@ -62,16 +65,20 @@ export function decodeEventLog<
   TEventName extends string | undefined = undefined,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
 >({
   abi,
   data,
+  strict: strict_,
   topics,
 }: DecodeEventLogParameters<
   TAbi,
   TEventName,
   TTopics,
-  TData
->): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData> {
+  TData,
+  TStrict
+>): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData, TStrict> {
+  const strict = strict_ ?? true
   const [signature, ...argTopics] = topics
   if (!signature)
     throw new AbiEventSignatureEmptyTopicsError({
@@ -82,7 +89,7 @@ export function decodeEventLog<
       x.type === 'event' &&
       signature === getEventSelector(formatAbiItem(x) as EventDefinition),
   )
-  if (!(abiItem && 'name' in abiItem))
+  if (!(abiItem && 'name' in abiItem) || abiItem.type !== 'event')
     throw new AbiEventSignatureNotFoundError(signature, {
       docsPath,
     })
@@ -109,32 +116,50 @@ export function decodeEventLog<
 
   // Decode data (non-indexed args).
   const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
-  if (data && data !== '0x') {
-    try {
-      const decodedData = decodeAbiParameters(nonIndexedInputs, data)
-      if (decodedData) {
-        if (isUnnamed) args = [...args, ...decodedData]
-        else {
-          for (let i = 0; i < nonIndexedInputs.length; i++) {
-            args[nonIndexedInputs[i].name!] = decodedData[i]
+  if (nonIndexedInputs.length > 0) {
+    if (data && data !== '0x') {
+      try {
+        const decodedData = decodeAbiParameters(nonIndexedInputs, data)
+        if (decodedData) {
+          if (isUnnamed) args = [...args, ...decodedData]
+          else {
+            for (let i = 0; i < nonIndexedInputs.length; i++) {
+              args[nonIndexedInputs[i].name!] = decodedData[i]
+            }
           }
         }
+      } catch (err) {
+        if (strict) {
+          if (err instanceof AbiDecodingDataSizeTooSmallError)
+            throw new DecodeLogDataMismatch({
+              abiItem,
+              data: err.data,
+              params: err.params,
+              size: err.size,
+            })
+          throw err
+        }
       }
-    } catch (err) {
-      if (err instanceof AbiDecodingDataSizeTooSmallError)
-        throw new DecodeLogDataMismatch({
-          data: err.data,
-          params: err.params,
-          size: err.size,
-        })
-      throw err
+    } else if (strict) {
+      throw new DecodeLogDataMismatch({
+        abiItem,
+        data: '0x',
+        params: nonIndexedInputs,
+        size: 0,
+      })
     }
   }
 
   return {
     eventName: name,
     args: Object.values(args).length > 0 ? args : undefined,
-  } as unknown as DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData>
+  } as unknown as DecodeEventLogReturnType<
+    TAbi,
+    TEventName,
+    TTopics,
+    TData,
+    TStrict
+  >
 }
 
 function decodeTopic({ param, value }: { param: AbiParameter; value: Hex }) {

package/src/utils/abi/encodeEventTopics.ts

@@ -66,17 +66,22 @@ export function encodeEventTopics<
     )
     const args_ = Array.isArray(args)
       ? args
-      : indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
-    topics =
-      indexedInputs?.map((param, i) =>
-        Array.isArray(args_[i])
-          ? args_[i].map((_: any, j: number) =>
-              encodeArg({ param, value: args_[i][j] }),
-            )
-          : args_[i]
-          ? encodeArg({ param, value: args_[i] })
-          : null,
-      ) ?? []
+      : Object.values(args).length > 0
+      ? indexedInputs?.map((x: any) => (args as any)[x.name]) ?? []
+      : []
+
+    if (args_.length > 0) {
+      topics =
+        indexedInputs?.map((param, i) =>
+          Array.isArray(args_[i])
+            ? args_[i].map((_: any, j: number) =>
+                encodeArg({ param, value: args_[i][j] }),
+              )
+            : args_[i]
+            ? encodeArg({ param, value: args_[i] })
+            : null,
+        ) ?? []
+    }
   }
   return [signature, ...topics]
 }

package/src/utils/abi/getAbiItem.ts

@@ -45,6 +45,7 @@ export function getAbiItem<
     }
     if (!abiItem.inputs) continue
     if (abiItem.inputs.length === 0) continue
+    if (abiItem.inputs.length !== args.length) continue
     const matched = (args as readonly unknown[]).every((arg, index) => {
       const abiParameter = 'inputs' in abiItem && abiItem.inputs![index]
       if (!abiParameter) return false

package/src/utils/encoding/toBytes.ts

@@ -6,7 +6,7 @@ import { pad } from '../data/pad.js'
 import { assertSize } from './fromHex.js'
 import { type NumberToHexOpts, numberToHex } from './toHex.js'
 
-const encoder = new TextEncoder()
+const encoder = /*#__PURE__*/ new TextEncoder()
 
 export type ToBytesParameters = {
   /** Size of the output bytes. */

package/src/utils/encoding/toHex.ts

@@ -4,7 +4,7 @@ import { pad } from '../data/pad.js'
 
 import { assertSize } from './fromHex.js'
 
-const hexes = Array.from({ length: 256 }, (_v, i) =>
+const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) =>
   i.toString(16).padStart(2, '0'),
 )
 
@@ -201,7 +201,7 @@ export type StringToHexOpts = {
   size?: number
 }
 
-const encoder = new TextEncoder()
+const encoder = /*#__PURE__*/ new TextEncoder()
 
 /**
  * Encodes a UTF-8 string into a hex string

package/src/utils/ens/encodeLabelhash.ts

@@ -0,0 +1,5 @@
+import type { Hex } from '../../index.js'
+
+export function encodeLabelhash(hash: Hex): `[${string}]` {
+  return `[${hash.slice(2)}]`
+}

package/src/utils/ens/encodedLabelToLabelhash.ts

@@ -0,0 +1,11 @@
+import type { Hex } from '../../index.js'
+import { isHex } from '../index.js'
+
+export function encodedLabelToLabelhash(label: string): Hex | null {
+  if (label.length !== 66) return null
+  if (label.indexOf('[') !== 0) return null
+  if (label.indexOf(']') !== 65) return null
+  const hash = `0x${label.slice(1, 65)}`
+  if (!isHex(hash)) return null
+  return hash
+}

package/src/utils/ens/labelhash.ts

@@ -1,6 +1,7 @@
 import { stringToBytes } from '../encoding/toBytes.js'
 import { bytesToHex } from '../encoding/toHex.js'
 import { keccak256 } from '../hash/keccak256.js'
+import { encodedLabelToLabelhash } from './encodedLabelToLabelhash.js'
 
 /**
  * @description Hashes ENS label
@@ -14,5 +15,5 @@ import { keccak256 } from '../hash/keccak256.js'
 export function labelhash(label: string) {
   const result = new Uint8Array(32).fill(0)
   if (!label) return bytesToHex(result)
-  return keccak256(stringToBytes(label))
+  return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label))
 }

package/src/utils/ens/namehash.ts

@@ -1,7 +1,8 @@
 import { concat } from '../data/concat.js'
-import { stringToBytes } from '../encoding/toBytes.js'
+import { stringToBytes, toBytes } from '../encoding/toBytes.js'
 import { bytesToHex } from '../encoding/toHex.js'
 import { keccak256 } from '../hash/keccak256.js'
+import { encodedLabelToLabelhash } from './encodedLabelToLabelhash.js'
 
 /**
  * @description Hashes ENS name
@@ -21,7 +22,10 @@ export function namehash(name: string) {
   const labels = name.split('.')
   // Iterate in reverse order building up hash
   for (let i = labels.length - 1; i >= 0; i -= 1) {
-    const hashed = keccak256(stringToBytes(labels[i]), 'bytes')
+    const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i])
+    const hashed = hashFromEncodedLabel
+      ? toBytes(hashFromEncodedLabel)
+      : keccak256(stringToBytes(labels[i]), 'bytes')
     result = keccak256(concat([result, hashed]), 'bytes')
   }
 

package/src/utils/ens/packetToBytes.ts

@@ -1,29 +1,33 @@
 // Adapted from https://github.com/mafintosh/dns-packet
 import type { ByteArray } from '../../types/misc.js'
 import { stringToBytes } from '../encoding/toBytes.js'
+import { encodeLabelhash } from './encodeLabelhash.js'
+import { labelhash } from './labelhash.js'
 
 /*
  * @description Encodes a DNS packet into a ByteArray containing a UDP payload.
  */
 export function packetToBytes(packet: string): ByteArray {
-  function length(value: string) {
-    if (value === '.' || value === '..') return 1
-    return stringToBytes(value.replace(/^\.|\.$/gm, '')).length + 2
-  }
-
-  const bytes = new Uint8Array(length(packet))
   // strip leading and trailing `.`
   const value = packet.replace(/^\.|\.$/gm, '')
-  if (!value.length) return bytes
+  if (value.length === 0) return new Uint8Array(1)
+
+  const bytes = new Uint8Array(stringToBytes(value).byteLength + 2)
 
   let offset = 0
   const list = value.split('.')
   for (let i = 0; i < list.length; i++) {
-    const encoded = stringToBytes(list[i])
+    let encoded = stringToBytes(list[i])
+    // if the length is > 255, make the encoded label value a labelhash
+    // this is compatible with the universal resolver
+    if (encoded.byteLength > 255)
+      encoded = stringToBytes(encodeLabelhash(labelhash(list[i])))
     bytes[offset] = encoded.length
     bytes.set(encoded, offset + 1)
     offset += encoded.length + 1
   }
 
+  if (bytes.byteLength !== offset + 1) return bytes.slice(0, offset + 1)
+
   return bytes
 }