voltaire-effect 0.2.23 → 0.2.25

package/src/primitives/AccessList/is.ts

@@ -0,0 +1,23 @@
+/**
+ * @module is
+ * @description Type guard for AccessList
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Type guard: Check if value is AccessList
+ *
+ * @param value - Value to check
+ * @returns true if value is AccessList
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * if (AccessList.is(value)) {
+ *   const cost = AccessList.gasCost(value)
+ * }
+ * ```
+ */
+export const is = (value: unknown): value is BrandedAccessList =>
+  AccessList.is(value);

package/src/primitives/AccessList/isEmpty.ts

@@ -0,0 +1,23 @@
+/**
+ * @module isEmpty
+ * @description Check if access list is empty
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Check if access list is empty
+ *
+ * @param list - Access list to check
+ * @returns true if empty
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * if (AccessList.isEmpty(list)) {
+ *   console.log('No access list entries')
+ * }
+ * ```
+ */
+export const isEmpty = (list: BrandedAccessList): boolean =>
+  AccessList.isEmpty(list);

package/src/primitives/AccessList/isItem.ts

@@ -0,0 +1,22 @@
+/**
+ * @module isItem
+ * @description Type guard for AccessList Item
+ * @since 0.1.0
+ */
+import { AccessList, type Item } from "@tevm/voltaire/AccessList";
+
+/**
+ * Type guard: Check if value is AccessListItem
+ *
+ * @param value - Value to check
+ * @returns true if value is AccessListItem
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * if (AccessList.isItem(value)) {
+ *   console.log(value.address, value.storageKeys)
+ * }
+ * ```
+ */
+export const isItem = (value: unknown): value is Item => AccessList.isItem(value);

package/src/primitives/AccessList/keysFor.ts

@@ -0,0 +1,29 @@
+/**
+ * @module keysFor
+ * @description Get all storage keys for an address
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type { AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Get all storage keys for an address
+ *
+ * @param list - Access list to search
+ * @param address - Address to get keys for
+ * @returns Array of storage keys, or undefined if address not found
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const keys = AccessList.keysFor(list, address)
+ * if (keys) {
+ *   console.log(`Found ${keys.length} storage keys`)
+ * }
+ * ```
+ */
+export const keysFor = (
+  list: BrandedAccessList,
+  address: AddressType,
+): readonly HashType[] | undefined => AccessList.keysFor(list, address);

package/src/primitives/AccessList/merge.ts

@@ -0,0 +1,24 @@
+/**
+ * @module merge
+ * @description Merge multiple access lists
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Merge multiple access lists
+ *
+ * Combines multiple access lists and deduplicates.
+ *
+ * @param accessLists - Access lists to merge
+ * @returns Merged and deduplicated access list
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const merged = AccessList.merge(list1, list2, list3)
+ * ```
+ */
+export const merge = (
+  ...accessLists: BrandedAccessList[]
+): BrandedAccessList => AccessList.merge(...accessLists);

package/src/primitives/AccessList/storageKeyCount.ts

@@ -0,0 +1,21 @@
+/**
+ * @module storageKeyCount
+ * @description Count total storage keys across all addresses
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Count total storage keys across all addresses
+ *
+ * @param list - Access list to count
+ * @returns Total number of storage keys
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const keyCount = AccessList.storageKeyCount(list)
+ * ```
+ */
+export const storageKeyCount = (list: BrandedAccessList): number =>
+  AccessList.storageKeyCount(list);

package/src/primitives/AccessList/toBytes.ts

@@ -0,0 +1,23 @@
+/**
+ * @module toBytes
+ * @description Encode access list to RLP
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Encode access list to RLP
+ *
+ * Format: [[address, [storageKey1, storageKey2, ...]], ...]
+ *
+ * @param list - Access list to encode
+ * @returns RLP-encoded bytes
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const encoded = AccessList.toBytes(list)
+ * ```
+ */
+export const toBytes = (list: BrandedAccessList): Uint8Array =>
+  AccessList.toBytes(list);

package/src/primitives/AccessList/withAddress.ts

@@ -0,0 +1,27 @@
+/**
+ * @module withAddress
+ * @description Add address to access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type { AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Add address to access list
+ *
+ * Creates new entry if address doesn't exist, otherwise returns original list.
+ *
+ * @param list - Access list to add to
+ * @param address - Address to add
+ * @returns New access list with address added
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const newList = AccessList.withAddress(list, address)
+ * ```
+ */
+export const withAddress = (
+  list: BrandedAccessList,
+  address: AddressType,
+): BrandedAccessList => AccessList.withAddress(list, address);

package/src/primitives/AccessList/withStorageKey.ts

@@ -0,0 +1,30 @@
+/**
+ * @module withStorageKey
+ * @description Add storage key to access list for address
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type { AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Add storage key to access list for address
+ *
+ * Adds address if it doesn't exist, then adds storage key if not already present.
+ *
+ * @param list - Access list to add to
+ * @param address - Address to add key for
+ * @param storageKey - Storage key to add
+ * @returns New access list with storage key added
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const newList = AccessList.withStorageKey(list, address, key)
+ * ```
+ */
+export const withStorageKey = (
+  list: BrandedAccessList,
+  address: AddressType,
+  storageKey: HashType,
+): BrandedAccessList => AccessList.withStorageKey(list, address, storageKey);

package/src/primitives/Address/Address.test.ts

@@ -364,3 +364,149 @@ describe("edge cases", () => {
 		expect(short.includes("...")).toBe(true);
 	});
 });
+
+describe("Effect-wrapped constructors", () => {
+	it("from succeeds with valid hex", async () => {
+		const program = Address.from("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("from succeeds with bytes", async () => {
+		const bytes = new Uint8Array(20).fill(0xab);
+		const program = Address.from(bytes);
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("from fails with invalid hex", async () => {
+		const program = Address.from("invalid");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromHex succeeds with valid hex", async () => {
+		const program = Address.fromHex("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("fromHex fails on wrong length", async () => {
+		const program = Address.fromHex("0x742d35");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromBytes succeeds with 20 bytes", async () => {
+		const program = Address.fromBytes(new Uint8Array(20));
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+	});
+
+	it("fromBytes fails on wrong length", async () => {
+		const program = Address.fromBytes(new Uint8Array(19));
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("fromNumber creates address from bigint", async () => {
+		const program = Address.fromNumber(1n);
+		const addr = await Effect.runPromise(program);
+		expect(addr.length).toBe(20);
+		expect(addr[19]).toBe(1);
+	});
+
+	it("zero creates zero address", () => {
+		const addr = Address.zero();
+		expect(addr.length).toBe(20);
+		expect(Address.isZero(addr)).toBe(true);
+	});
+
+	it("toHex converts address to hex", () => {
+		const addr = S.decodeSync(Address.Hex)("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		const hex = Address.toHex(addr);
+		expect(hex).toBe("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+	});
+
+	it("is type guard works", () => {
+		const addr = S.decodeSync(Address.Hex)("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		expect(Address.is(addr)).toBe(true);
+		expect(Address.is("not an address")).toBe(false);
+		expect(Address.is(new Uint8Array(20))).toBe(true);
+		expect(Address.is(new Uint8Array(19))).toBe(false);
+	});
+
+	it("isAddress validates address format", () => {
+		expect(Address.isAddress("0x742d35cc6634c0532925a3b844bc9e7595f251e3")).toBe(true);
+		expect(Address.isAddress("invalid")).toBe(false);
+	});
+});
+
+describe("utility functions", () => {
+	it("sortAddresses sorts lexicographically", () => {
+		const addr1 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000001");
+		const addr2 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000002");
+		const addr3 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000003");
+
+		const sorted = Address.sortAddresses([addr3, addr1, addr2]);
+		expect(Address.equals(sorted[0], addr1)).toBe(true);
+		expect(Address.equals(sorted[1], addr2)).toBe(true);
+		expect(Address.equals(sorted[2], addr3)).toBe(true);
+	});
+
+	it("deduplicateAddresses removes duplicates", () => {
+		const addr1 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000001");
+		const addr2 = S.decodeSync(Address.Hex)("0x0000000000000000000000000000000000000002");
+
+		const deduped = Address.deduplicateAddresses([addr1, addr1, addr2, addr2]);
+		expect(deduped.length).toBe(2);
+	});
+});
+
+describe("assert functions", () => {
+	it("assert succeeds on valid address", async () => {
+		const program = Address.assert("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		await Effect.runPromise(program);
+	});
+
+	it("assert fails on invalid address", async () => {
+		const program = Address.assert("invalid");
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+
+	it("assert with strict mode validates checksum", async () => {
+		const program = Address.assert("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", { strict: true });
+		await Effect.runPromise(program);
+	});
+
+	it("assertBasic succeeds on valid format", async () => {
+		const program = Address.assertBasic("0x742d35cc6634c0532925a3b844bc9e7595f251e3");
+		await Effect.runPromise(program);
+	});
+});
+
+describe("toChecksummed", () => {
+	it("converts to checksummed format", async () => {
+		const addr = S.decodeSync(Address.Hex)("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed");
+		const program = Address.toChecksummed(addr).pipe(Effect.provide(KeccakLive));
+		const result = await Effect.runPromise(program);
+		expect(result).toBe("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed");
+	});
+});
+
+describe("calculateCreateAddress", () => {
+	it("calculates CREATE address", async () => {
+		const deployer = S.decodeSync(Address.Hex)("0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0");
+		const program = Address.calculateCreateAddress(deployer, 0n);
+		const result = await Effect.runPromise(program);
+		expect(result.length).toBe(20);
+	});
+
+	it("fails on negative nonce", async () => {
+		const deployer = S.decodeSync(Address.Hex)("0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0");
+		const program = Address.calculateCreateAddress(deployer, -1n);
+		const result = await Effect.runPromiseExit(program);
+		expect(result._tag).toBe("Failure");
+	});
+});

package/src/primitives/Address/assert.ts

@@ -0,0 +1,51 @@
+/**
+ * @module assert
+ * @description Assert value is valid address with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type InvalidAddressError, type InvalidChecksumError } from "@tevm/voltaire/Address";
+
+type AssertError =
+  | InvalidAddressError
+  | InvalidChecksumError;
+
+/**
+ * Assert value is valid address
+ *
+ * @param value - Value to validate
+ * @param options - Validation options
+ * @param options.strict - If true, validates EIP-55 checksum
+ * @returns Effect yielding void or failing with AssertError
+ * @example
+ * ```typescript
+ * // Basic validation
+ * const program = Address.assert('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ *
+ * // Strict checksum validation
+ * const strictProgram = Address.assert('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3', { strict: true })
+ * await Effect.runPromise(strictProgram)
+ * ```
+ */
+export const assert = (
+  value: string | Uint8Array,
+  options?: { strict?: boolean },
+): Effect.Effect<void, AssertError> =>
+  Effect.try({
+    try: () => { Address.assert(value, options); },
+    catch: (e) => e as AssertError,
+  });
+
+/**
+ * Assert value is valid address (non-strict, no checksum validation)
+ *
+ * @param value - Value to validate
+ * @returns Effect yielding void or failing with InvalidAddressError
+ */
+export const assertBasic = (
+  value: string | Uint8Array,
+): Effect.Effect<void, InvalidAddressError> =>
+  Effect.try({
+    try: () => { Address.assert(value, { strict: false }); },
+    catch: (e) => e as InvalidAddressError,
+  });

package/src/primitives/Address/calculateCreate2Address.ts

@@ -0,0 +1,33 @@
+/**
+ * @module calculateCreate2Address
+ * @description Calculate CREATE2 contract deployment address with Effect
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Calculate CREATE2 contract deployment address
+ *
+ * Formula: keccak256(0xff ++ sender ++ salt ++ keccak256(initCode))[12:32]
+ *
+ * @param address - Deployer address
+ * @param salt - 32-byte salt value
+ * @param initCode - Contract initialization bytecode (Uint8Array)
+ * @returns Effect yielding the contract address that would be created
+ * @example
+ * ```typescript
+ * const program = Address.calculateCreate2Address(deployerAddr, salt, initCode)
+ * const contractAddr = await Effect.runPromise(program)
+ * ```
+ */
+export const calculateCreate2Address = (
+  address: AddressType,
+  salt: HashType,
+  initCode: Uint8Array,
+): Effect.Effect<AddressType, Error> =>
+  Effect.try({
+    try: () => Address.calculateCreate2Address(address, salt, initCode as Parameters<typeof Address.calculateCreate2Address>[2]),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Address/calculateCreateAddress.ts

@@ -0,0 +1,30 @@
+/**
+ * @module calculateCreateAddress
+ * @description Calculate CREATE contract deployment address with Effect
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidValueError } from "@tevm/voltaire/Address";
+
+/**
+ * Calculate CREATE contract deployment address
+ *
+ * Formula: keccak256(rlp([sender, nonce]))[12:32]
+ *
+ * @param address - Deployer address
+ * @param nonce - Transaction nonce
+ * @returns Effect yielding the contract address that would be created
+ * @example
+ * ```typescript
+ * const program = Address.calculateCreateAddress(deployerAddr, 0n)
+ * const contractAddr = await Effect.runPromise(program)
+ * ```
+ */
+export const calculateCreateAddress = (
+  address: AddressType,
+  nonce: bigint,
+): Effect.Effect<AddressType, InvalidValueError> =>
+  Effect.try({
+    try: () => Address.calculateCreateAddress(address, nonce),
+    catch: (e) => e as InvalidValueError,
+  });

package/src/primitives/Address/deduplicateAddresses.ts

@@ -0,0 +1,20 @@
+/**
+ * @module deduplicateAddresses
+ * @description Remove duplicate addresses from array
+ * @since 0.1.0
+ */
+import { deduplicateAddresses as voltaireDeduplicateAddresses, type AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Remove duplicate addresses from array
+ *
+ * @param addresses - Array with potential duplicates
+ * @returns New array with duplicates removed
+ * @example
+ * ```typescript
+ * const unique = Address.deduplicateAddresses([addr1, addr1, addr2])
+ * // [addr1, addr2]
+ * ```
+ */
+export const deduplicateAddresses = (addresses: AddressType[]): AddressType[] =>
+  voltaireDeduplicateAddresses(addresses);

package/src/primitives/Address/from.ts

@@ -0,0 +1,41 @@
+/**
+ * @module from
+ * @description Create Address from various input types with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidAddressError,
+  InvalidHexFormatError,
+  InvalidAddressLengthError,
+  InvalidValueError,
+} from "@tevm/voltaire/Address";
+
+type AddressError =
+  | InvalidAddressError
+  | InvalidHexFormatError
+  | InvalidAddressLengthError
+  | InvalidValueError;
+
+/**
+ * Create Address from hex string, bytes, or number
+ *
+ * @param value - Hex string, Uint8Array, number, or bigint
+ * @returns Effect yielding AddressType or failing with AddressError
+ * @example
+ * ```typescript
+ * import * as Address from 'voltaire-effect/primitives/Address'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Address.from('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * const addr = await Effect.runPromise(program)
+ * ```
+ */
+export const from = (
+  value: string | Uint8Array | number | bigint,
+): Effect.Effect<AddressType, AddressError> =>
+  Effect.try({
+    try: () => Address.from(value),
+    catch: (e) => e as AddressError,
+  });

package/src/primitives/Address/fromAbiEncoded.ts

@@ -0,0 +1,35 @@
+/**
+ * @module fromAbiEncoded
+ * @description Create Address from ABI-encoded bytes with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidAddressLengthError,
+  InvalidAbiEncodedPaddingError,
+} from "@tevm/voltaire/Address";
+
+type AbiEncodedError =
+  | InvalidAddressLengthError
+  | InvalidAbiEncodedPaddingError;
+
+/**
+ * Create Address from ABI-encoded bytes (32 bytes, left-padded)
+ *
+ * @param value - 32-byte ABI-encoded address
+ * @returns Effect yielding AddressType or failing with error
+ * @example
+ * ```typescript
+ * const abiEncoded = new Uint8Array(32)
+ * abiEncoded.set(addressBytes, 12) // left-pad with 12 zeros
+ * const program = Address.fromAbiEncoded(abiEncoded)
+ * ```
+ */
+export const fromAbiEncoded = (
+  value: Uint8Array,
+): Effect.Effect<AddressType, AbiEncodedError> =>
+  Effect.try({
+    try: () => Address.fromAbiEncoded(value),
+    catch: (e) => e as AbiEncodedError,
+  });

package/src/primitives/Address/fromBase64.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromBase64
+ * @description Create Address from base64 string with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidAddressLengthError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from base64 encoded string
+ *
+ * @param value - Base64 string (must decode to 20 bytes)
+ * @returns Effect yielding AddressType or failing with InvalidAddressLengthError
+ * @example
+ * ```typescript
+ * const program = Address.fromBase64('dC01zGY0wFMpJaO4RLyeZV8lHuM=')
+ * ```
+ */
+export const fromBase64 = (
+  value: string,
+): Effect.Effect<AddressType, InvalidAddressLengthError> =>
+  Effect.try({
+    try: () => Address.fromBase64(value),
+    catch: (e) => e as InvalidAddressLengthError,
+  });

package/src/primitives/Address/fromBytes.ts

@@ -0,0 +1,25 @@
+/**
+ * @module fromBytes
+ * @description Create Address from Uint8Array with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType, type InvalidAddressLengthError } from "@tevm/voltaire/Address";
+
+/**
+ * Create Address from 20-byte Uint8Array
+ *
+ * @param value - 20-byte Uint8Array
+ * @returns Effect yielding AddressType or failing with InvalidAddressLengthError
+ * @example
+ * ```typescript
+ * const program = Address.fromBytes(new Uint8Array(20))
+ * ```
+ */
+export const fromBytes = (
+  value: Uint8Array,
+): Effect.Effect<AddressType, InvalidAddressLengthError> =>
+  Effect.try({
+    try: () => Address.fromBytes(value),
+    catch: (e) => e as InvalidAddressLengthError,
+  });

package/src/primitives/Address/fromHex.ts

@@ -0,0 +1,31 @@
+/**
+ * @module fromHex
+ * @description Create Address from hex string with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Address, type AddressType } from "@tevm/voltaire/Address";
+import type {
+  InvalidHexFormatError,
+  InvalidAddressLengthError,
+} from "@tevm/voltaire/Address";
+
+type AddressError =
+  | InvalidHexFormatError
+  | InvalidAddressLengthError;
+
+/**
+ * Create Address from hex string
+ *
+ * @param value - Hex string with 0x prefix
+ * @returns Effect yielding AddressType or failing with AddressError
+ * @example
+ * ```typescript
+ * const program = Address.fromHex('0x742d35cc6634c0532925a3b844bc9e7595f251e3')
+ * ```
+ */
+export const fromHex = (value: string): Effect.Effect<AddressType, AddressError> =>
+  Effect.try({
+    try: () => Address.fromHex(value),
+    catch: (e) => e as AddressError,
+  });