FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/viem/utils/blob/blobsToCommitments.ts

@@ -0,0 +1,71 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Kzg } from '../../types/kzg.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type BlobsToCommitmentsParameters<
+  blobs extends readonly ByteArray[] | readonly Hex[] =
+    | readonly ByteArray[]
+    | readonly Hex[],
+  to extends To | undefined = undefined,
+> = {
+  /** Blobs to transform into commitments. */
+  blobs: blobs | readonly ByteArray[] | readonly Hex[]
+  /** KZG implementation. */
+  kzg: Pick<Kzg, 'blobToKzgCommitment'>
+  /** Return type. */
+  to?: to | To | undefined
+}
+
+export type BlobsToCommitmentsReturnType<to extends To> =
+  | (to extends 'bytes' ? readonly ByteArray[] : never)
+  | (to extends 'hex' ? readonly Hex[] : never)
+
+export type BlobsToCommitmentsErrorType =
+  | HexToBytesErrorType
+  | BytesToHexErrorType
+  | ErrorType
+
+/**
+ * Compute commitments from a list of blobs.
+ *
+ * @example
+ * ```ts
+ * import { blobsToCommitments, toBlobs } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * ```
+ */
+export function blobsToCommitments<
+  const blobs extends readonly ByteArray[] | readonly Hex[],
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+>(
+  parameters: BlobsToCommitmentsParameters<blobs, to>,
+): BlobsToCommitmentsReturnType<to> {
+  const { kzg } = parameters
+
+  const to =
+    parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes')
+  const blobs = (
+    typeof parameters.blobs[0] === 'string'
+      ? parameters.blobs.map((x) => hexToBytes(x as any))
+      : parameters.blobs
+  ) as ByteArray[]
+
+  const commitments: ByteArray[] = []
+  for (const blob of blobs)
+    commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)))
+
+  return (to === 'bytes'
+    ? commitments
+    : commitments.map((x) =>
+        bytesToHex(x),
+      )) as {} as BlobsToCommitmentsReturnType<to>
+}

node_modules/viem/utils/blob/blobsToProofs.ts

@@ -0,0 +1,93 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Kzg } from '../../types/kzg.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type blobsToProofsParameters<
+  blobs extends readonly ByteArray[] | readonly Hex[],
+  commitments extends readonly ByteArray[] | readonly Hex[],
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+  ///
+  _blobsType =
+    | (blobs extends readonly Hex[] ? readonly Hex[] : never)
+    | (blobs extends readonly ByteArray[] ? readonly ByteArray[] : never),
+> = {
+  /** Blobs to transform into proofs. */
+  blobs: blobs
+  /** Commitments for the blobs. */
+  commitments: commitments &
+    (commitments extends _blobsType
+      ? {}
+      : `commitments must be the same type as blobs`)
+  /** KZG implementation. */
+  kzg: Pick<Kzg, 'computeBlobKzgProof'>
+  /** Return type. */
+  to?: to | To | undefined
+}
+
+export type blobsToProofsReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
+
+export type blobsToProofsErrorType =
+  | BytesToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+/**
+ * Compute the proofs for a list of blobs and their commitments.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const proofs = blobsToProofs({ blobs, commitments, kzg })
+ * ```
+ */
+export function blobsToProofs<
+  const blobs extends readonly ByteArray[] | readonly Hex[],
+  const commitments extends readonly ByteArray[] | readonly Hex[],
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+>(
+  parameters: blobsToProofsParameters<blobs, commitments, to>,
+): blobsToProofsReturnType<to> {
+  const { kzg } = parameters
+
+  const to =
+    parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes')
+
+  const blobs = (
+    typeof parameters.blobs[0] === 'string'
+      ? parameters.blobs.map((x) => hexToBytes(x as any))
+      : parameters.blobs
+  ) as ByteArray[]
+  const commitments = (
+    typeof parameters.commitments[0] === 'string'
+      ? parameters.commitments.map((x) => hexToBytes(x as any))
+      : parameters.commitments
+  ) as ByteArray[]
+
+  const proofs: ByteArray[] = []
+  for (let i = 0; i < blobs.length; i++) {
+    const blob = blobs[i]
+    const commitment = commitments[i]
+    proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)))
+  }
+
+  return (to === 'bytes'
+    ? proofs
+    : proofs.map((x) => bytesToHex(x))) as {} as blobsToProofsReturnType<to>
+}

node_modules/viem/utils/blob/commitmentToVersionedHash.ts

@@ -0,0 +1,62 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+import { type Sha256ErrorType, sha256 } from '../hash/sha256.js'
+
+type To = 'hex' | 'bytes'
+
+export type CommitmentToVersionedHashParameters<
+  commitment extends Uint8Array | Hex = Uint8Array | Hex,
+  to extends To | undefined = undefined,
+> = {
+  /** Commitment from blob. */
+  commitment: commitment | Uint8Array | Hex
+  /** Return type. */
+  to?: to | To | undefined
+  /** Version to tag onto the hash. */
+  version?: number | undefined
+}
+
+export type CommitmentToVersionedHashReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
+
+export type CommitmentToVersionedHashErrorType =
+  | Sha256ErrorType
+  | BytesToHexErrorType
+  | ErrorType
+
+/**
+ * Transform a commitment to it's versioned hash.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   commitmentToVersionedHash,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const [commitment] = blobsToCommitments({ blobs, kzg })
+ * const versionedHash = commitmentToVersionedHash({ commitment })
+ * ```
+ */
+export function commitmentToVersionedHash<
+  const commitment extends Hex | ByteArray,
+  to extends To =
+    | (commitment extends Hex ? 'hex' : never)
+    | (commitment extends ByteArray ? 'bytes' : never),
+>(
+  parameters: CommitmentToVersionedHashParameters<commitment, to>,
+): CommitmentToVersionedHashReturnType<to> {
+  const { commitment, version = 1 } = parameters
+  const to = parameters.to ?? (typeof commitment === 'string' ? 'hex' : 'bytes')
+
+  const versionedHash = sha256(commitment, 'bytes')
+  versionedHash.set([version], 0)
+  return (
+    to === 'bytes' ? versionedHash : bytesToHex(versionedHash)
+  ) as CommitmentToVersionedHashReturnType<to>
+}

node_modules/viem/utils/blob/commitmentsToVersionedHashes.ts

@@ -0,0 +1,73 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import {
+  type CommitmentToVersionedHashErrorType,
+  commitmentToVersionedHash,
+} from './commitmentToVersionedHash.js'
+
+type To = 'hex' | 'bytes'
+
+export type CommitmentsToVersionedHashesParameters<
+  commitments extends readonly Uint8Array[] | readonly Hex[] =
+    | readonly Uint8Array[]
+    | readonly Hex[],
+  to extends To | undefined = undefined,
+> = {
+  /** Commitments from blobs. */
+  commitments: commitments | readonly Uint8Array[] | readonly Hex[]
+  /** Return type. */
+  to?: to | To | undefined
+  /** Version to tag onto the hashes. */
+  version?: number | undefined
+}
+
+export type CommitmentsToVersionedHashesReturnType<to extends To> =
+  | (to extends 'bytes' ? readonly ByteArray[] : never)
+  | (to extends 'hex' ? readonly Hex[] : never)
+
+export type CommitmentsToVersionedHashesErrorType =
+  | CommitmentToVersionedHashErrorType
+  | ErrorType
+
+/**
+ * Transform a list of commitments to their versioned hashes.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   commitmentsToVersionedHashes,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const versionedHashes = commitmentsToVersionedHashes({ commitments })
+ * ```
+ */
+export function commitmentsToVersionedHashes<
+  const commitments extends readonly Uint8Array[] | readonly Hex[],
+  to extends To =
+    | (commitments extends readonly Hex[] ? 'hex' : never)
+    | (commitments extends readonly ByteArray[] ? 'bytes' : never),
+>(
+  parameters: CommitmentsToVersionedHashesParameters<commitments, to>,
+): CommitmentsToVersionedHashesReturnType<to> {
+  const { commitments, version } = parameters
+
+  const to =
+    parameters.to ?? (typeof commitments[0] === 'string' ? 'hex' : 'bytes')
+
+  const hashes: Uint8Array[] | Hex[] = []
+  for (const commitment of commitments) {
+    hashes.push(
+      commitmentToVersionedHash({
+        commitment,
+        to,
+        version,
+      }) as any,
+    )
+  }
+  return hashes as any
+}

node_modules/viem/utils/blob/fromBlobs.ts

@@ -0,0 +1,75 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type CreateCursorErrorType, createCursor } from '../cursor.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type FromBlobsParameters<
+  blobs extends readonly Hex[] | readonly ByteArray[] =
+    | readonly Hex[]
+    | readonly ByteArray[],
+  to extends To | undefined = undefined,
+> = {
+  /** Blobs to transform to data. */
+  blobs: blobs | readonly Hex[] | readonly ByteArray[]
+  to?: to | To | undefined
+}
+
+export type FromBlobsReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
+
+export type FromBlobsErrorType =
+  | BytesToHexErrorType
+  | CreateCursorErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+export function fromBlobs<
+  const blobs extends readonly Hex[] | readonly ByteArray[],
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+>(parameters: FromBlobsParameters<blobs, to>): FromBlobsReturnType<to> {
+  const to =
+    parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes')
+  const blobs = (
+    typeof parameters.blobs[0] === 'string'
+      ? parameters.blobs.map((x) => hexToBytes(x as Hex))
+      : parameters.blobs
+  ) as ByteArray[]
+
+  const length = blobs.reduce((length, blob) => length + blob.length, 0)
+  const data = createCursor(new Uint8Array(length))
+  let active = true
+
+  for (const blob of blobs) {
+    const cursor = createCursor(blob)
+    while (active && cursor.position < blob.length) {
+      // First byte will be a zero 0x00 byte – we can skip.
+      cursor.incrementPosition(1)
+
+      let consume = 31
+      if (blob.length - cursor.position < 31)
+        consume = blob.length - cursor.position
+
+      for (const _ in Array.from({ length: consume })) {
+        const byte = cursor.readByte()
+        const isTerminator =
+          byte === 0x80 && !cursor.inspectBytes(cursor.remaining).includes(0x80)
+        if (isTerminator) {
+          active = false
+          break
+        }
+        data.pushByte(byte)
+      }
+    }
+  }
+
+  const trimmedData = data.bytes.slice(0, data.position)
+  return (
+    to === 'hex' ? bytesToHex(trimmedData) : trimmedData
+  ) as FromBlobsReturnType<to>
+}

node_modules/viem/utils/blob/sidecarsToVersionedHashes.ts

@@ -0,0 +1,66 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { BlobSidecars } from '../../types/eip4844.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import {
+  type CommitmentToVersionedHashErrorType,
+  commitmentToVersionedHash,
+} from './commitmentToVersionedHash.js'
+
+type To = 'hex' | 'bytes'
+
+export type SidecarsToVersionedHashesParameters<
+  sidecars extends BlobSidecars = BlobSidecars,
+  to extends To | undefined = undefined,
+> = {
+  /** Sidecars from blobs. */
+  sidecars: sidecars | BlobSidecars
+  /** Return type. */
+  to?: to | To | undefined
+  /** Version to tag onto the hashes. */
+  version?: number | undefined
+}
+
+export type SidecarsToVersionedHashesReturnType<to extends To> =
+  | (to extends 'bytes' ? readonly ByteArray[] : never)
+  | (to extends 'hex' ? readonly Hex[] : never)
+
+export type SidecarsToVersionedHashesErrorType =
+  | CommitmentToVersionedHashErrorType
+  | ErrorType
+
+/**
+ * Transforms a list of sidecars to their versioned hashes.
+ *
+ * @example
+ * ```ts
+ * import { toBlobSidecars, sidecarsToVersionedHashes, stringToHex } from 'viem'
+ *
+ * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+ * const versionedHashes = sidecarsToVersionedHashes({ sidecars })
+ * ```
+ */
+export function sidecarsToVersionedHashes<
+  const sidecars extends BlobSidecars,
+  to extends To =
+    | (sidecars extends BlobSidecars<Hex> ? 'hex' : never)
+    | (sidecars extends BlobSidecars<ByteArray> ? 'bytes' : never),
+>(
+  parameters: SidecarsToVersionedHashesParameters<sidecars, to>,
+): SidecarsToVersionedHashesReturnType<to> {
+  const { sidecars, version } = parameters
+
+  const to =
+    parameters.to ?? (typeof sidecars[0].blob === 'string' ? 'hex' : 'bytes')
+
+  const hashes: Uint8Array[] | Hex[] = []
+  for (const { commitment } of sidecars) {
+    hashes.push(
+      commitmentToVersionedHash({
+        commitment,
+        to,
+        version,
+      }) as any,
+    )
+  }
+  return hashes as any
+}

node_modules/viem/utils/blob/toBlobSidecars.ts

@@ -0,0 +1,112 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { BlobSidecars } from '../../types/eip4844.js'
+import type { Kzg } from '../../types/kzg.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import type { OneOf } from '../../types/utils.js'
+import {
+  type BlobsToCommitmentsErrorType,
+  blobsToCommitments,
+} from './blobsToCommitments.js'
+import { blobsToProofs, type blobsToProofsErrorType } from './blobsToProofs.js'
+import { type ToBlobsErrorType, toBlobs } from './toBlobs.js'
+
+type To = 'hex' | 'bytes'
+
+export type ToBlobSidecarsParameters<
+  data extends Hex | ByteArray | undefined = undefined,
+  blobs extends readonly Hex[] | readonly ByteArray[] | undefined = undefined,
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+  ///
+  _blobsType =
+    | (blobs extends readonly Hex[] ? readonly Hex[] : never)
+    | (blobs extends readonly ByteArray[] ? readonly ByteArray[] : never),
+> = {
+  /** Return type. */
+  to?: to | To | undefined
+} & OneOf<
+  | {
+      /** Data to transform into blobs. */
+      data: data | Hex | ByteArray
+      /** KZG implementation. */
+      kzg: Kzg
+    }
+  | {
+      /** Blobs. */
+      blobs: blobs | readonly Hex[] | readonly ByteArray[]
+      /** Commitment for each blob. */
+      commitments: _blobsType | readonly Hex[] | readonly ByteArray[]
+      /** Proof for each blob. */
+      proofs: _blobsType | readonly Hex[] | readonly ByteArray[]
+    }
+>
+
+export type ToBlobSidecarsReturnType<to extends To> =
+  | (to extends 'bytes' ? BlobSidecars<ByteArray> : never)
+  | (to extends 'hex' ? BlobSidecars<Hex> : never)
+
+export type ToBlobSidecarsErrorType =
+  | BlobsToCommitmentsErrorType
+  | ToBlobsErrorType
+  | blobsToProofsErrorType
+  | ErrorType
+
+/**
+ * Transforms arbitrary data (or blobs, commitments, & proofs) into a sidecar array.
+ *
+ * @example
+ * ```ts
+ * import { toBlobSidecars, stringToHex } from 'viem'
+ *
+ * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   toBlobs,
+ *   blobsToProofs,
+ *   toBlobSidecars,
+ *   stringToHex
+ * } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const proofs = blobsToProofs({ blobs, commitments, kzg })
+ *
+ * const sidecars = toBlobSidecars({ blobs, commitments, proofs })
+ * ```
+ */
+export function toBlobSidecars<
+  const data extends Hex | ByteArray | undefined = undefined,
+  const blobs extends
+    | readonly Hex[]
+    | readonly ByteArray[]
+    | undefined = undefined,
+  to extends To =
+    | (data extends Hex ? 'hex' : never)
+    | (data extends ByteArray ? 'bytes' : never)
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+>(
+  parameters: ToBlobSidecarsParameters<data, blobs, to>,
+): ToBlobSidecarsReturnType<to> {
+  const { data, kzg, to } = parameters
+  const blobs = parameters.blobs ?? toBlobs({ data: data!, to })
+  const commitments =
+    parameters.commitments ?? blobsToCommitments({ blobs, kzg: kzg!, to })
+  const proofs =
+    parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg: kzg!, to })
+
+  const sidecars: BlobSidecars = []
+  for (let i = 0; i < blobs.length; i++)
+    sidecars.push({
+      blob: blobs[i],
+      commitment: commitments[i],
+      proof: proofs[i],
+    })
+
+  return sidecars as ToBlobSidecarsReturnType<to>
+}

node_modules/viem/utils/blob/toBlobs.ts

@@ -0,0 +1,114 @@
+import {
+  bytesPerBlob,
+  bytesPerFieldElement,
+  fieldElementsPerBlob,
+  maxBytesPerTransaction,
+} from '../../constants/blob.js'
+import {
+  BlobSizeTooLargeError,
+  type BlobSizeTooLargeErrorType,
+  EmptyBlobError,
+  type EmptyBlobErrorType,
+} from '../../errors/blob.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type CreateCursorErrorType, createCursor } from '../cursor.js'
+import { type SizeErrorType, size } from '../data/size.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type ToBlobsParameters<
+  data extends Hex | ByteArray = Hex | ByteArray,
+  to extends To | undefined = undefined,
+> = {
+  /** Data to transform to a blob. */
+  data: data | Hex | ByteArray
+  /** Return type. */
+  to?: to | To | undefined
+}
+
+export type ToBlobsReturnType<to extends To> =
+  | (to extends 'bytes' ? readonly ByteArray[] : never)
+  | (to extends 'hex' ? readonly Hex[] : never)
+
+export type ToBlobsErrorType =
+  | BlobSizeTooLargeErrorType
+  | BytesToHexErrorType
+  | CreateCursorErrorType
+  | EmptyBlobErrorType
+  | HexToBytesErrorType
+  | SizeErrorType
+  | ErrorType
+
+/**
+ * Transforms arbitrary data to blobs.
+ *
+ * @example
+ * ```ts
+ * import { toBlobs, stringToHex } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * ```
+ */
+export function toBlobs<
+  const data extends Hex | ByteArray,
+  to extends To =
+    | (data extends Hex ? 'hex' : never)
+    | (data extends ByteArray ? 'bytes' : never),
+>(parameters: ToBlobsParameters<data, to>): ToBlobsReturnType<to> {
+  const to =
+    parameters.to ?? (typeof parameters.data === 'string' ? 'hex' : 'bytes')
+  const data = (
+    typeof parameters.data === 'string'
+      ? hexToBytes(parameters.data)
+      : parameters.data
+  ) as ByteArray
+
+  const size_ = size(data)
+  if (!size_) throw new EmptyBlobError()
+  if (size_ > maxBytesPerTransaction)
+    throw new BlobSizeTooLargeError({
+      maxSize: maxBytesPerTransaction,
+      size: size_,
+    })
+
+  const blobs = []
+
+  let active = true
+  let position = 0
+  while (active) {
+    const blob = createCursor(new Uint8Array(bytesPerBlob))
+
+    let size = 0
+    while (size < fieldElementsPerBlob) {
+      const bytes = data.slice(position, position + (bytesPerFieldElement - 1))
+
+      // Push a zero byte so the field element doesn't overflow the BLS modulus.
+      blob.pushByte(0x00)
+
+      // Push the current segment of data bytes.
+      blob.pushBytes(bytes)
+
+      // If we detect that the current segment of data bytes is less than 31 bytes,
+      // we can stop processing and push a terminator byte to indicate the end of the blob.
+      if (bytes.length < 31) {
+        blob.pushByte(0x80)
+        active = false
+        break
+      }
+
+      size++
+      position += 31
+    }
+
+    blobs.push(blob)
+  }
+
+  return (
+    to === 'bytes'
+      ? blobs.map((x) => x.bytes)
+      : blobs.map((x) => bytesToHex(x.bytes))
+  ) as any
+}