@ensforge/core 0.0.0

package/dist/names/dns.js

@@ -0,0 +1,66 @@
+import { defineSyncFunction } from "../internal/sync-function.js";
+import { normalizeName } from "./normalize.js";
+import { CodecError } from "../errors/codec-error.js";
+import { DnsEncodedName } from "../schemas/dns.js";
+import { Effect, Schema } from "effect";
+import { bytesToHex, bytesToString, hexToBytes, stringToBytes } from "viem";
+import { packetToBytes } from "viem/ens";
+
+//#region src/names/dns.ts
+const dnsEncodeName = defineSyncFunction(Effect.fn("dnsEncodeName")(function* (name) {
+	const normalizedName = yield* normalizeName.effect(name).pipe(Effect.mapError(() => new CodecError({
+		code: "INVALID_DNS_NAME",
+		message: `Unable to DNS-encode ENS name: ${name}`
+	})));
+	return yield* Effect.try({
+		try: () => Schema.decodeSync(DnsEncodedName)(bytesToHex(packetToBytes(normalizedName))),
+		catch: () => new CodecError({
+			code: "INVALID_DNS_NAME",
+			message: `Unable to DNS-encode ENS name: ${name}`
+		})
+	});
+}));
+const dnsDecodeName = (encodedName) => {
+	let bytes;
+	try {
+		const encoded = Schema.decodeSync(DnsEncodedName)(encodedName);
+		bytes = hexToBytes(encoded);
+	} catch {
+		throw new CodecError({
+			code: "MALFORMED_DNS_PACKET",
+			message: "Unable to decode malformed DNS name bytes"
+		});
+	}
+	const labels = [];
+	let offset = 0;
+	try {
+		while (bytes[offset] !== 0) {
+			const length = bytes[offset];
+			if (length === void 0) throw new Error("Missing DNS label length");
+			const start = offset + 1;
+			const end = start + length;
+			const labelBytes = bytes.subarray(start, end);
+			const label = bytesToString(labelBytes);
+			if (bytesToHex(stringToBytes(label)) !== bytesToHex(labelBytes)) throw new Error("Invalid UTF-8 label");
+			labels.push(label);
+			offset = end;
+		}
+		const name = labels.join(".");
+		const normalizedName = normalizeName(name);
+		if (normalizedName !== name) throw new CodecError({
+			code: "INVALID_DNS_NAME",
+			message: "DNS name bytes must contain an ENSIP-15 normalized name"
+		});
+		return normalizedName;
+	} catch (error) {
+		if (error instanceof CodecError) throw error;
+		throw new CodecError({
+			code: "INVALID_DNS_NAME",
+			message: "DNS name bytes do not contain a valid ENS name"
+		});
+	}
+};
+
+//#endregion
+export { dnsDecodeName, dnsEncodeName };
+//# sourceMappingURL=dns.js.map

package/dist/names/dns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.js","names":[],"sources":["../../src/names/dns.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport { bytesToHex, bytesToString, hexToBytes, stringToBytes } from \"viem\";\nimport { packetToBytes } from \"viem/ens\";\n\nimport { CodecError } from \"../errors/codec-error.js\";\nimport { defineSyncFunction } from \"../internal/sync-function.js\";\nimport { DnsEncodedName, type DnsEncodedName as DnsEncodedNameValue } from \"../schemas/dns.js\";\nimport type { NormalizedName as NormalizedNameValue } from \"../schemas/name.js\";\nimport { normalizeName } from \"./normalize.js\";\n\nexport const dnsEncodeName = defineSyncFunction(\n  Effect.fn(\"dnsEncodeName\")(function* (name: string | NormalizedNameValue) {\n    const normalizedName = yield* normalizeName.effect(name).pipe(\n      Effect.mapError(\n        () =>\n          new CodecError({\n            code: \"INVALID_DNS_NAME\",\n            message: `Unable to DNS-encode ENS name: ${name}`,\n          }),\n      ),\n    );\n\n    return yield* Effect.try({\n      try: () => Schema.decodeSync(DnsEncodedName)(bytesToHex(packetToBytes(normalizedName))),\n      catch: () =>\n        new CodecError({\n          code: \"INVALID_DNS_NAME\",\n          message: `Unable to DNS-encode ENS name: ${name}`,\n        }),\n    });\n  }),\n);\n\nexport const dnsDecodeName = (\n  encodedName: `0x${string}` | DnsEncodedNameValue,\n): NormalizedNameValue => {\n  let bytes: Uint8Array;\n\n  try {\n    const encoded = Schema.decodeSync(DnsEncodedName)(encodedName);\n    bytes = hexToBytes(encoded);\n  } catch {\n    throw new CodecError({\n      code: \"MALFORMED_DNS_PACKET\",\n      message: \"Unable to decode malformed DNS name bytes\",\n    });\n  }\n\n  const labels: Array<string> = [];\n  let offset = 0;\n\n  try {\n    while (bytes[offset] !== 0) {\n      const length = bytes[offset];\n      if (length === undefined) throw new Error(\"Missing DNS label length\");\n      const start = offset + 1;\n      const end = start + length;\n      const labelBytes = bytes.subarray(start, end);\n      const label = bytesToString(labelBytes);\n\n      if (bytesToHex(stringToBytes(label)) !== bytesToHex(labelBytes)) {\n        throw new Error(\"Invalid UTF-8 label\");\n      }\n\n      labels.push(label);\n      offset = end;\n    }\n\n    const name = labels.join(\".\");\n    const normalizedName = normalizeName(name);\n\n    if (normalizedName !== name) {\n      throw new CodecError({\n        code: \"INVALID_DNS_NAME\",\n        message: \"DNS name bytes must contain an ENSIP-15 normalized name\",\n      });\n    }\n\n    return normalizedName;\n  } catch (error) {\n    if (error instanceof CodecError) throw error;\n    throw new CodecError({\n      code: \"INVALID_DNS_NAME\",\n      message: \"DNS name bytes do not contain a valid ENS name\",\n    });\n  }\n};\n"],"mappings":";;;;;;;;;AAWA,MAAa,gBAAgB,mBAC3B,OAAO,GAAG,eAAe,CAAC,CAAC,WAAW,MAAoC;CACxE,MAAM,iBAAiB,OAAO,cAAc,OAAO,IAAI,CAAC,CAAC,KACvD,OAAO,eAEH,IAAI,WAAW;EACb,MAAM;EACN,SAAS,kCAAkC;CAC7C,CAAC,CACL,CACF;CAEA,OAAO,OAAO,OAAO,IAAI;EACvB,WAAW,OAAO,WAAW,cAAc,CAAC,CAAC,WAAW,cAAc,cAAc,CAAC,CAAC;EACtF,aACE,IAAI,WAAW;GACb,MAAM;GACN,SAAS,kCAAkC;EAC7C,CAAC;CACL,CAAC;AACH,CAAC,CACH;AAEA,MAAa,iBACX,gBACwB;CACxB,IAAI;CAEJ,IAAI;EACF,MAAM,UAAU,OAAO,WAAW,cAAc,CAAC,CAAC,WAAW;EAC7D,QAAQ,WAAW,OAAO;CAC5B,QAAQ;EACN,MAAM,IAAI,WAAW;GACnB,MAAM;GACN,SAAS;EACX,CAAC;CACH;CAEA,MAAM,SAAwB,CAAC;CAC/B,IAAI,SAAS;CAEb,IAAI;EACF,OAAO,MAAM,YAAY,GAAG;GAC1B,MAAM,SAAS,MAAM;GACrB,IAAI,WAAW,QAAW,MAAM,IAAI,MAAM,0BAA0B;GACpE,MAAM,QAAQ,SAAS;GACvB,MAAM,MAAM,QAAQ;GACpB,MAAM,aAAa,MAAM,SAAS,OAAO,GAAG;GAC5C,MAAM,QAAQ,cAAc,UAAU;GAEtC,IAAI,WAAW,cAAc,KAAK,CAAC,MAAM,WAAW,UAAU,GAC5D,MAAM,IAAI,MAAM,qBAAqB;GAGvC,OAAO,KAAK,KAAK;GACjB,SAAS;EACX;EAEA,MAAM,OAAO,OAAO,KAAK,GAAG;EAC5B,MAAM,iBAAiB,cAAc,IAAI;EAEzC,IAAI,mBAAmB,MACrB,MAAM,IAAI,WAAW;GACnB,MAAM;GACN,SAAS;EACX,CAAC;EAGH,OAAO;CACT,SAAS,OAAO;EACd,IAAI,iBAAiB,YAAY,MAAM;EACvC,MAAM,IAAI,WAAW;GACnB,MAAM;GACN,SAAS;EACX,CAAC;CACH;AACF"}

package/dist/names/hashes.d.ts

@@ -0,0 +1,8 @@
+import { Labelhash, Namehash } from "../schemas/hash.js";
+import { NormalizedLabel, NormalizedName } from "../schemas/name.js";
+//#region src/names/hashes.d.ts
+declare const namehash: (name: string | NormalizedName) => Namehash;
+declare const labelhash: (label: string | NormalizedLabel) => Labelhash;
+//#endregion
+export { labelhash, namehash };
+//# sourceMappingURL=hashes.d.ts.map

package/dist/names/hashes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.d.ts","names":[],"sources":["../../src/names/hashes.ts"],"mappings":";;;cAgBa,WAAY,eAAe,mBAAsB;cAGjD,YAAa,gBAAgB,oBAAuB"}

package/dist/names/hashes.js

@@ -0,0 +1,12 @@
+import { normalizeLabel, normalizeName } from "./normalize.js";
+import { Labelhash, Namehash } from "../schemas/hash.js";
+import { Schema } from "effect";
+import { labelhash, namehash } from "viem/ens";
+
+//#region src/names/hashes.ts
+const namehash$1 = (name) => Schema.decodeSync(Namehash)(namehash(normalizeName(name)));
+const labelhash$1 = (label) => Schema.decodeSync(Labelhash)(labelhash(normalizeLabel(label)));
+
+//#endregion
+export { labelhash$1 as labelhash, namehash$1 as namehash };
+//# sourceMappingURL=hashes.js.map

package/dist/names/hashes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.js","names":["namehash","viemNamehash","labelhash","viemLabelhash"],"sources":["../../src/names/hashes.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { labelhash as viemLabelhash, namehash as viemNamehash } from \"viem/ens\";\n\nimport {\n  Labelhash,\n  type Labelhash as LabelhashValue,\n  Namehash,\n  type Namehash as NamehashValue,\n} from \"../schemas/hash.js\";\nimport type {\n  NormalizedLabel as NormalizedLabelValue,\n  NormalizedName as NormalizedNameValue,\n} from \"../schemas/name.js\";\nimport { normalizeLabel, normalizeName } from \"./normalize.js\";\n\nexport const namehash = (name: string | NormalizedNameValue): NamehashValue =>\n  Schema.decodeSync(Namehash)(viemNamehash(normalizeName(name)));\n\nexport const labelhash = (label: string | NormalizedLabelValue): LabelhashValue =>\n  Schema.decodeSync(Labelhash)(viemLabelhash(normalizeLabel(label)));\n"],"mappings":";;;;;;AAgBA,MAAaA,cAAY,SACvB,OAAO,WAAW,QAAQ,CAAC,CAACC,SAAa,cAAc,IAAI,CAAC,CAAC;AAE/D,MAAaC,eAAa,UACxB,OAAO,WAAW,SAAS,CAAC,CAACC,UAAc,eAAe,KAAK,CAAC,CAAC"}

package/dist/names/index.d.ts

@@ -0,0 +1,8 @@
+import { DecodeAddressRecordParameters, EncodeAddressRecordParameters, decodeAddressRecord, encodeAddressRecord } from "./address-record.js";
+import { NameAnalysis, NameKind, analyzeName } from "./analyze.js";
+import { CoinTypeNamespace, fromCoinType, toCoinType } from "./coin-type.js";
+import { DecodedContentHash, EncodeContentHashParameters, decodeContentHash, encodeContentHash } from "./content-hash.js";
+import { dnsDecodeName, dnsEncodeName } from "./dns.js";
+import { labelhash, namehash } from "./hashes.js";
+import { normalizeLabel, normalizeName } from "./normalize.js";
+export { type CoinTypeNamespace, type DecodeAddressRecordParameters, type DecodedContentHash, type EncodeAddressRecordParameters, type EncodeContentHashParameters, type NameAnalysis, type NameKind, analyzeName, decodeAddressRecord, decodeContentHash, dnsDecodeName, dnsEncodeName, encodeAddressRecord, encodeContentHash, fromCoinType, labelhash, namehash, normalizeLabel, normalizeName, toCoinType };

package/dist/names/normalize.d.ts

@@ -0,0 +1,8 @@
+import { NameError } from "../errors/name-error.js";
+import { SyncFunction } from "../internal/sync-function.js";
+//#region src/names/normalize.d.ts
+declare const normalizeName: SyncFunction<[name: string], string & import("effect/Brand").Brand<"NormalizedName">, NameError>;
+declare const normalizeLabel: SyncFunction<[label: string], string & import("effect/Brand").Brand<"NormalizedLabel">, NameError>;
+//#endregion
+export { normalizeLabel, normalizeName };
+//# sourceMappingURL=normalize.d.ts.map

package/dist/names/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","names":[],"sources":["../../src/names/normalize.ts"],"mappings":";;;cAQa,eAAa,cAAA,+CAAA,yBAAA;cAab,gBAAc,cAAA,gDAAA,0BAAA"}

package/dist/names/normalize.js

@@ -0,0 +1,33 @@
+import { NameError } from "../errors/name-error.js";
+import { defineSyncFunction } from "../internal/sync-function.js";
+import { NormalizedLabel, NormalizedName } from "../schemas/name.js";
+import { Effect, Schema } from "effect";
+import { normalize } from "viem/ens";
+
+//#region src/names/normalize.ts
+const normalizeName = defineSyncFunction(Effect.fn("normalizeName")(function* (name) {
+	return yield* Effect.try({
+		try: () => Schema.decodeSync(NormalizedName)(name === "" ? "" : normalize(name)),
+		catch: () => new NameError({
+			code: "INVALID_NAME",
+			message: `Invalid ENS name: ${name}`
+		})
+	});
+}));
+const normalizeLabel = defineSyncFunction(Effect.fn("normalizeLabel")(function* (label) {
+	if (label.length === 0 || label.includes(".")) return yield* new NameError({
+		code: "INVALID_LABEL",
+		message: `Invalid ENS label: ${label}`
+	});
+	return yield* Effect.try({
+		try: () => Schema.decodeSync(NormalizedLabel)(normalize(label)),
+		catch: () => new NameError({
+			code: "INVALID_LABEL",
+			message: `Invalid ENS label: ${label}`
+		})
+	});
+}));
+
+//#endregion
+export { normalizeLabel, normalizeName };
+//# sourceMappingURL=normalize.js.map

package/dist/names/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","names":[],"sources":["../../src/names/normalize.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport { normalize } from \"viem/ens\";\n\nimport { NameError } from \"../errors/name-error.js\";\nimport { defineSyncFunction } from \"../internal/sync-function.js\";\nimport { NormalizedLabel, NormalizedName } from \"../schemas/name.js\";\n\nexport const normalizeName = defineSyncFunction(\n  Effect.fn(\"normalizeName\")(function* (name: string) {\n    return yield* Effect.try({\n      try: () => Schema.decodeSync(NormalizedName)(name === \"\" ? \"\" : normalize(name)),\n      catch: () =>\n        new NameError({\n          code: \"INVALID_NAME\",\n          message: `Invalid ENS name: ${name}`,\n        }),\n    });\n  }),\n);\n\nexport const normalizeLabel = defineSyncFunction(\n  Effect.fn(\"normalizeLabel\")(function* (label: string) {\n    if (label.length === 0 || label.includes(\".\")) {\n      return yield* new NameError({\n        code: \"INVALID_LABEL\",\n        message: `Invalid ENS label: ${label}`,\n      });\n    }\n\n    return yield* Effect.try({\n      try: () => Schema.decodeSync(NormalizedLabel)(normalize(label)),\n      catch: () =>\n        new NameError({\n          code: \"INVALID_LABEL\",\n          message: `Invalid ENS label: ${label}`,\n        }),\n    });\n  }),\n);\n"],"mappings":";;;;;;;AAQA,MAAa,gBAAgB,mBAC3B,OAAO,GAAG,eAAe,CAAC,CAAC,WAAW,MAAc;CAClD,OAAO,OAAO,OAAO,IAAI;EACvB,WAAW,OAAO,WAAW,cAAc,CAAC,CAAC,SAAS,KAAK,KAAK,UAAU,IAAI,CAAC;EAC/E,aACE,IAAI,UAAU;GACZ,MAAM;GACN,SAAS,qBAAqB;EAChC,CAAC;CACL,CAAC;AACH,CAAC,CACH;AAEA,MAAa,iBAAiB,mBAC5B,OAAO,GAAG,gBAAgB,CAAC,CAAC,WAAW,OAAe;CACpD,IAAI,MAAM,WAAW,KAAK,MAAM,SAAS,GAAG,GAC1C,OAAO,OAAO,IAAI,UAAU;EAC1B,MAAM;EACN,SAAS,sBAAsB;CACjC,CAAC;CAGH,OAAO,OAAO,OAAO,IAAI;EACvB,WAAW,OAAO,WAAW,eAAe,CAAC,CAAC,UAAU,KAAK,CAAC;EAC9D,aACE,IAAI,UAAU;GACZ,MAAM;GACN,SAAS,sBAAsB;EACjC,CAAC;CACL,CAAC;AACH,CAAC,CACH"}

package/dist/schemas/coin-type.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/schemas/coin-type.d.ts
+declare const CoinType: Schema.brand<Schema.BigInt, "CoinType">;
+type CoinType = typeof CoinType.Type;
+//#endregion
+export { CoinType };
+//# sourceMappingURL=coin-type.d.ts.map

package/dist/schemas/coin-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coin-type.d.ts","names":[],"sources":["../../src/schemas/coin-type.ts"],"mappings":";;cAMa,UAAQ,OAAA,MAAA,OAAA;KAET,kBAAkB,SAAS"}

package/dist/schemas/coin-type.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+//#region src/schemas/coin-type.ts
+const uint32 = Schema.makeFilter((value) => value >= 0n && value <= 4294967295n ? true : "Expected a uint32 coin type");
+const CoinType = Schema.BigInt.pipe(Schema.check(uint32), Schema.brand("CoinType"));
+
+//#endregion
+export { CoinType };
+//# sourceMappingURL=coin-type.js.map

package/dist/schemas/coin-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coin-type.js","names":[],"sources":["../../src/schemas/coin-type.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nconst uint32 = Schema.makeFilter<bigint>((value) =>\n  value >= 0n && value <= 0xffff_ffffn ? true : \"Expected a uint32 coin type\",\n);\n\nexport const CoinType = Schema.BigInt.pipe(Schema.check(uint32), Schema.brand(\"CoinType\"));\n\nexport type CoinType = typeof CoinType.Type;\n"],"mappings":";;;AAEA,MAAM,SAAS,OAAO,YAAoB,UACxC,SAAS,MAAM,SAAS,cAAe,OAAO,6BAChD;AAEA,MAAa,WAAW,OAAO,OAAO,KAAK,OAAO,MAAM,MAAM,GAAG,OAAO,MAAM,UAAU,CAAC"}

package/dist/schemas/dns.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/schemas/dns.d.ts
+declare const DnsEncodedName: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "DnsEncodedName">;
+type DnsEncodedName = typeof DnsEncodedName.Type;
+//#endregion
+export { DnsEncodedName };
+//# sourceMappingURL=dns.d.ts.map

package/dist/schemas/dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/schemas/dns.ts"],"mappings":";;cA8Ba,gBAAc,OAAA,MAAA,OAAA,gCAAA,OAAA;KAEf,wBAAwB,eAAe"}

package/dist/schemas/dns.js

@@ -0,0 +1,24 @@
+import { Hex as Hex$1 } from "./hex.js";
+import { Schema } from "effect";
+import { hexToBytes } from "viem";
+
+//#region src/schemas/dns.ts
+const isDnsWireName = Schema.makeFilter((value) => {
+	if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(value)) return "Expected a non-empty byte-aligned hexadecimal DNS name";
+	const bytes = hexToBytes(value);
+	let offset = 0;
+	while (offset < bytes.length) {
+		const length = bytes[offset];
+		if (length === void 0) return "Expected a complete DNS label";
+		offset += 1;
+		if (length === 0) return offset === bytes.length || "Expected no bytes after the DNS terminator";
+		if (offset + length > bytes.length) return "Expected a complete DNS label";
+		offset += length;
+	}
+	return "Expected a zero-terminated DNS name";
+});
+const DnsEncodedName = Hex$1.pipe(Schema.check(isDnsWireName), Schema.brand("DnsEncodedName"));
+
+//#endregion
+export { DnsEncodedName };
+//# sourceMappingURL=dns.js.map

package/dist/schemas/dns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.js","names":["Hex"],"sources":["../../src/schemas/dns.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { hexToBytes } from \"viem\";\n\nimport { Hex } from \"./hex.js\";\n\nconst isDnsWireName = Schema.makeFilter<`0x${string}`>((value) => {\n  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(value)) {\n    return \"Expected a non-empty byte-aligned hexadecimal DNS name\";\n  }\n\n  const bytes = hexToBytes(value);\n  let offset = 0;\n\n  while (offset < bytes.length) {\n    const length = bytes[offset];\n    if (length === undefined) return \"Expected a complete DNS label\";\n    offset += 1;\n\n    if (length === 0) {\n      return offset === bytes.length || \"Expected no bytes after the DNS terminator\";\n    }\n\n    if (offset + length > bytes.length) return \"Expected a complete DNS label\";\n    offset += length;\n  }\n\n  return \"Expected a zero-terminated DNS name\";\n});\n\nexport const DnsEncodedName = Hex.pipe(Schema.check(isDnsWireName), Schema.brand(\"DnsEncodedName\"));\n\nexport type DnsEncodedName = typeof DnsEncodedName.Type;\n"],"mappings":";;;;;AAMA,MAAM,gBAAgB,OAAO,YAA2B,UAAU;CAChE,IAAI,CAAC,0BAA0B,KAAK,KAAK,GACvC,OAAO;CAGT,MAAM,QAAQ,WAAW,KAAK;CAC9B,IAAI,SAAS;CAEb,OAAO,SAAS,MAAM,QAAQ;EAC5B,MAAM,SAAS,MAAM;EACrB,IAAI,WAAW,QAAW,OAAO;EACjC,UAAU;EAEV,IAAI,WAAW,GACb,OAAO,WAAW,MAAM,UAAU;EAGpC,IAAI,SAAS,SAAS,MAAM,QAAQ,OAAO;EAC3C,UAAU;CACZ;CAEA,OAAO;AACT,CAAC;AAED,MAAa,iBAAiBA,MAAI,KAAK,OAAO,MAAM,aAAa,GAAG,OAAO,MAAM,gBAAgB,CAAC"}

package/dist/schemas/hash.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+//#region src/schemas/hash.d.ts
+declare const Bytes32: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+type Bytes32 = typeof Bytes32.Type;
+declare const Namehash: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+type Namehash = typeof Namehash.Type;
+declare const Labelhash: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Labelhash">;
+type Labelhash = typeof Labelhash.Type;
+//#endregion
+export { Bytes32, Labelhash, Namehash };
+//# sourceMappingURL=hash.d.ts.map

package/dist/schemas/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../../src/schemas/hash.ts"],"mappings":";;cAIa,SAAO,OAAA,gCAAA,OAAA;KAQR,iBAAiB,QAAQ;cAExB,UAAQ,OAAA,MAAA,OAAA,gCAAA,OAAA;KAET,kBAAkB,SAAS;cAE1B,WAAS,OAAA,MAAA,OAAA,gCAAA,OAAA;KAEV,mBAAmB,UAAU"}

package/dist/schemas/hash.js

@@ -0,0 +1,11 @@
+import { Hex } from "./hex.js";
+import { Schema } from "effect";
+
+//#region src/schemas/hash.ts
+const Bytes32 = Hex.pipe(Schema.check(Schema.isPattern(/^0x[0-9a-fA-F]{64}$/, { message: "Expected a 32-byte hexadecimal value" })));
+const Namehash = Bytes32.pipe(Schema.brand("Namehash"));
+const Labelhash = Bytes32.pipe(Schema.brand("Labelhash"));
+
+//#endregion
+export { Bytes32, Labelhash, Namehash };
+//# sourceMappingURL=hash.js.map

package/dist/schemas/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":[],"sources":["../../src/schemas/hash.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { Hex } from \"./hex.js\";\n\nexport const Bytes32 = Hex.pipe(\n  Schema.check(\n    Schema.isPattern(/^0x[0-9a-fA-F]{64}$/, {\n      message: \"Expected a 32-byte hexadecimal value\",\n    }),\n  ),\n);\n\nexport type Bytes32 = typeof Bytes32.Type;\n\nexport const Namehash = Bytes32.pipe(Schema.brand(\"Namehash\"));\n\nexport type Namehash = typeof Namehash.Type;\n\nexport const Labelhash = Bytes32.pipe(Schema.brand(\"Labelhash\"));\n\nexport type Labelhash = typeof Labelhash.Type;\n"],"mappings":";;;;AAIA,MAAa,UAAU,IAAI,KACzB,OAAO,MACL,OAAO,UAAU,uBAAuB,EACtC,SAAS,uCACX,CAAC,CACH,CACF;AAIA,MAAa,WAAW,QAAQ,KAAK,OAAO,MAAM,UAAU,CAAC;AAI7D,MAAa,YAAY,QAAQ,KAAK,OAAO,MAAM,WAAW,CAAC"}

package/dist/schemas/hex.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/schemas/hex.d.ts
+declare const Hex: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+type Hex = typeof Hex.Type;
+//#endregion
+export { Hex };
+//# sourceMappingURL=hex.d.ts.map

package/dist/schemas/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","names":[],"sources":["../../src/schemas/hex.ts"],"mappings":";;cAEa,KAAG,OAAA,gCAAA,OAAA;KAQJ,aAAa,IAAI"}

package/dist/schemas/hex.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+
+//#region src/schemas/hex.ts
+const Hex = Schema.TemplateLiteral(["0x", Schema.String]).pipe(Schema.check(Schema.isPattern(/^0x(?:[0-9a-fA-F]{2})*$/, { message: "Expected byte-aligned hexadecimal data" })));
+
+//#endregion
+export { Hex };
+//# sourceMappingURL=hex.js.map

package/dist/schemas/hex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.js","names":[],"sources":["../../src/schemas/hex.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const Hex = Schema.TemplateLiteral([\"0x\", Schema.String]).pipe(\n  Schema.check(\n    Schema.isPattern(/^0x(?:[0-9a-fA-F]{2})*$/, {\n      message: \"Expected byte-aligned hexadecimal data\",\n    }),\n  ),\n);\n\nexport type Hex = typeof Hex.Type;\n"],"mappings":";;;AAEA,MAAa,MAAM,OAAO,gBAAgB,CAAC,MAAM,OAAO,MAAM,CAAC,CAAC,CAAC,KAC/D,OAAO,MACL,OAAO,UAAU,2BAA2B,EAC1C,SAAS,yCACX,CAAC,CACH,CACF"}

package/dist/schemas/identity.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+//#region src/schemas/identity.d.ts
+declare const EthereumAddress: Schema.declare<`0x${string}`, `0x${string}`>;
+type EthereumAddress = typeof EthereumAddress.Type;
+declare const RegistryResource: Schema.brand<Schema.BigInt, "RegistryResource">;
+type RegistryResource = typeof RegistryResource.Type;
+declare const CanonicalNameIdentity: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly namehash: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+  readonly chainId: Schema.Int;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly resource: Schema.optional<Schema.brand<Schema.BigInt, "RegistryResource">>;
+}>;
+type CanonicalNameIdentity = typeof CanonicalNameIdentity.Type;
+//#endregion
+export { CanonicalNameIdentity, EthereumAddress, RegistryResource };
+//# sourceMappingURL=identity.d.ts.map

package/dist/schemas/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","names":[],"sources":["../../src/schemas/identity.ts"],"mappings":";;cAQa,iBAAe,OAAA;KAQhB,yBAAyB,gBAAgB;cAMxC,kBAAgB,OAAA,MAAA,OAAA;KAKjB,0BAA0B,iBAAiB;cAE1C,uBAAqB,OAAA;;;;;;;;KAWtB,+BAA+B,sBAAsB"}

package/dist/schemas/identity.js

@@ -0,0 +1,25 @@
+import { NormalizedName } from "./name.js";
+import { Namehash } from "./hash.js";
+import { EnsProtocol } from "./protocol.js";
+import { Schema } from "effect";
+import { isAddress } from "viem";
+
+//#region src/schemas/identity.ts
+const EthereumAddress = Schema.declare((value) => typeof value === "string" && isAddress(value), {
+	identifier: "EthereumAddress",
+	description: "A valid Ethereum address"
+});
+const uint256 = Schema.makeFilter((value) => value >= 0n && value < 1n << 256n ? true : "Expected a uint256 registry resource");
+const RegistryResource = Schema.BigInt.pipe(Schema.check(uint256), Schema.brand("RegistryResource"));
+const CanonicalNameIdentity = Schema.Struct({
+	name: NormalizedName,
+	namehash: Namehash,
+	chainId: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0, { message: "Expected a non-negative chain ID" }))),
+	registry: EthereumAddress,
+	protocol: EnsProtocol,
+	resource: Schema.optional(RegistryResource)
+});
+
+//#endregion
+export { CanonicalNameIdentity, EthereumAddress, RegistryResource };
+//# sourceMappingURL=identity.js.map

package/dist/schemas/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","names":[],"sources":["../../src/schemas/identity.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { isAddress, type Address } from \"viem\";\n\nimport { Namehash } from \"./hash.js\";\nimport { NormalizedName } from \"./name.js\";\nimport { EnsProtocol } from \"./protocol.js\";\n\nexport const EthereumAddress = Schema.declare<Address>(\n  (value): value is Address => typeof value === \"string\" && isAddress(value),\n  {\n    identifier: \"EthereumAddress\",\n    description: \"A valid Ethereum address\",\n  },\n);\n\nexport type EthereumAddress = typeof EthereumAddress.Type;\n\nconst uint256 = Schema.makeFilter<bigint>((value) =>\n  value >= 0n && value < 1n << 256n ? true : \"Expected a uint256 registry resource\",\n);\n\nexport const RegistryResource = Schema.BigInt.pipe(\n  Schema.check(uint256),\n  Schema.brand(\"RegistryResource\"),\n);\n\nexport type RegistryResource = typeof RegistryResource.Type;\n\nexport const CanonicalNameIdentity = Schema.Struct({\n  name: NormalizedName,\n  namehash: Namehash,\n  chainId: Schema.Int.pipe(\n    Schema.check(Schema.isGreaterThanOrEqualTo(0, { message: \"Expected a non-negative chain ID\" })),\n  ),\n  registry: EthereumAddress,\n  protocol: EnsProtocol,\n  resource: Schema.optional(RegistryResource),\n});\n\nexport type CanonicalNameIdentity = typeof CanonicalNameIdentity.Type;\n"],"mappings":";;;;;;;AAQA,MAAa,kBAAkB,OAAO,SACnC,UAA4B,OAAO,UAAU,YAAY,UAAU,KAAK,GACzE;CACE,YAAY;CACZ,aAAa;AACf,CACF;AAIA,MAAM,UAAU,OAAO,YAAoB,UACzC,SAAS,MAAM,QAAQ,MAAM,OAAO,OAAO,sCAC7C;AAEA,MAAa,mBAAmB,OAAO,OAAO,KAC5C,OAAO,MAAM,OAAO,GACpB,OAAO,MAAM,kBAAkB,CACjC;AAIA,MAAa,wBAAwB,OAAO,OAAO;CACjD,MAAM;CACN,UAAU;CACV,SAAS,OAAO,IAAI,KAClB,OAAO,MAAM,OAAO,uBAAuB,GAAG,EAAE,SAAS,mCAAmC,CAAC,CAAC,CAChG;CACA,UAAU;CACV,UAAU;CACV,UAAU,OAAO,SAAS,gBAAgB;AAC5C,CAAC"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,9 @@
+import { EnsProtocol } from "./protocol.js";
+import { CanonicalNameIdentity, EthereumAddress, RegistryResource } from "./identity.js";
+import { Bytes32, Labelhash, Namehash } from "./hash.js";
+import { NormalizedLabel, NormalizedName } from "./name.js";
+import { Hex } from "./hex.js";
+import { Abi, AbiContentType, AbiRecordData, AddressRecordData, ContentHash, ContentHashProtocol, InterfaceId } from "./records.js";
+import { CoinType } from "./coin-type.js";
+import { DnsEncodedName } from "./dns.js";
+export { Abi, AbiContentType, AbiRecordData, AddressRecordData, Bytes32, CanonicalNameIdentity, CoinType, ContentHash, ContentHashProtocol, DnsEncodedName, EnsProtocol, EthereumAddress, Hex, InterfaceId, Labelhash, Namehash, NormalizedLabel, NormalizedName, RegistryResource };

package/dist/schemas/name.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+//#region src/schemas/name.d.ts
+declare const NormalizedName: Schema.brand<Schema.String, "NormalizedName">;
+type NormalizedName = typeof NormalizedName.Type;
+declare const NormalizedLabel: Schema.brand<Schema.String, "NormalizedLabel">;
+type NormalizedLabel = typeof NormalizedLabel.Type;
+//#endregion
+export { NormalizedLabel, NormalizedName };
+//# sourceMappingURL=name.d.ts.map

package/dist/schemas/name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","names":[],"sources":["../../src/schemas/name.ts"],"mappings":";;cA4Ba,gBAAc,OAAA,MAAA,OAAA;KAKf,wBAAwB,eAAe;cAEtC,iBAAe,OAAA,MAAA,OAAA;KAKhB,yBAAyB,gBAAgB"}

package/dist/schemas/name.js

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { normalize } from "viem/ens";
+
+//#region src/schemas/name.ts
+const isCanonicalName = Schema.makeFilter((value) => {
+	if (value === "") return true;
+	if (value.startsWith(".") || value.endsWith(".") || value.includes("..")) return "Expected an ENS name without empty labels";
+	try {
+		return normalize(value) === value || "Expected an ENSIP-15 normalized name";
+	} catch {
+		return "Expected a valid ENS name";
+	}
+});
+const isCanonicalLabel = Schema.makeFilter((value) => {
+	if (value.length === 0) return "Expected a non-empty ENS label";
+	if (value.includes(".")) return "Expected one ENS label without dots";
+	try {
+		return normalize(value) === value || "Expected an ENSIP-15 normalized label";
+	} catch {
+		return "Expected a valid ENS label";
+	}
+});
+const NormalizedName = Schema.String.pipe(Schema.check(isCanonicalName), Schema.brand("NormalizedName"));
+const NormalizedLabel = Schema.String.pipe(Schema.check(isCanonicalLabel), Schema.brand("NormalizedLabel"));
+
+//#endregion
+export { NormalizedLabel, NormalizedName };
+//# sourceMappingURL=name.js.map

package/dist/schemas/name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.js","names":[],"sources":["../../src/schemas/name.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { normalize } from \"viem/ens\";\n\nconst isCanonicalName = Schema.makeFilter<string>((value) => {\n  if (value === \"\") return true;\n  if (value.startsWith(\".\") || value.endsWith(\".\") || value.includes(\"..\")) {\n    return \"Expected an ENS name without empty labels\";\n  }\n\n  try {\n    return normalize(value) === value || \"Expected an ENSIP-15 normalized name\";\n  } catch {\n    return \"Expected a valid ENS name\";\n  }\n});\n\nconst isCanonicalLabel = Schema.makeFilter<string>((value) => {\n  if (value.length === 0) return \"Expected a non-empty ENS label\";\n  if (value.includes(\".\")) return \"Expected one ENS label without dots\";\n\n  try {\n    return normalize(value) === value || \"Expected an ENSIP-15 normalized label\";\n  } catch {\n    return \"Expected a valid ENS label\";\n  }\n});\n\nexport const NormalizedName = Schema.String.pipe(\n  Schema.check(isCanonicalName),\n  Schema.brand(\"NormalizedName\"),\n);\n\nexport type NormalizedName = typeof NormalizedName.Type;\n\nexport const NormalizedLabel = Schema.String.pipe(\n  Schema.check(isCanonicalLabel),\n  Schema.brand(\"NormalizedLabel\"),\n);\n\nexport type NormalizedLabel = typeof NormalizedLabel.Type;\n"],"mappings":";;;;AAIA,MAAM,kBAAkB,OAAO,YAAoB,UAAU;CAC3D,IAAI,UAAU,IAAI,OAAO;CACzB,IAAI,MAAM,WAAW,GAAG,KAAK,MAAM,SAAS,GAAG,KAAK,MAAM,SAAS,IAAI,GACrE,OAAO;CAGT,IAAI;EACF,OAAO,UAAU,KAAK,MAAM,SAAS;CACvC,QAAQ;EACN,OAAO;CACT;AACF,CAAC;AAED,MAAM,mBAAmB,OAAO,YAAoB,UAAU;CAC5D,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,IAAI,MAAM,SAAS,GAAG,GAAG,OAAO;CAEhC,IAAI;EACF,OAAO,UAAU,KAAK,MAAM,SAAS;CACvC,QAAQ;EACN,OAAO;CACT;AACF,CAAC;AAED,MAAa,iBAAiB,OAAO,OAAO,KAC1C,OAAO,MAAM,eAAe,GAC5B,OAAO,MAAM,gBAAgB,CAC/B;AAIA,MAAa,kBAAkB,OAAO,OAAO,KAC3C,OAAO,MAAM,gBAAgB,GAC7B,OAAO,MAAM,iBAAiB,CAChC"}

package/dist/schemas/protocol.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/schemas/protocol.d.ts
+declare const EnsProtocol: Schema.Literals<readonly ["v1", "v2"]>;
+type EnsProtocol = typeof EnsProtocol.Type;
+//#endregion
+export { EnsProtocol };
+//# sourceMappingURL=protocol.d.ts.map

package/dist/schemas/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","names":[],"sources":["../../src/schemas/protocol.ts"],"mappings":";;cAEa,aAAW,OAAA;KAEZ,qBAAqB,YAAY"}

package/dist/schemas/protocol.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+
+//#region src/schemas/protocol.ts
+const EnsProtocol = Schema.Literals(["v1", "v2"]);
+
+//#endregion
+export { EnsProtocol };
+//# sourceMappingURL=protocol.js.map

package/dist/schemas/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","names":[],"sources":["../../src/schemas/protocol.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const EnsProtocol = Schema.Literals([\"v1\", \"v2\"]);\n\nexport type EnsProtocol = typeof EnsProtocol.Type;\n"],"mappings":";;;AAEA,MAAa,cAAc,OAAO,SAAS,CAAC,MAAM,IAAI,CAAC"}

package/dist/schemas/records.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+import { Abi } from "viem";
+//#region src/schemas/records.d.ts
+declare const AddressRecordData: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "AddressRecordData">;
+type AddressRecordData = typeof AddressRecordData.Type;
+declare const AbiRecordData: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "AbiRecordData">;
+type AbiRecordData = typeof AbiRecordData.Type;
+declare const AbiContentType: Schema.Literals<readonly ["json", "zlib-json", "cbor", "uri"]>;
+type AbiContentType = typeof AbiContentType.Type;
+declare const Abi$1: Schema.declare<Abi, Abi>;
+type Abi$1 = typeof Abi$1.Type;
+declare const InterfaceId: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">;
+type InterfaceId = typeof InterfaceId.Type;
+declare const ContentHash: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "ContentHash">;
+type ContentHash = typeof ContentHash.Type;
+declare const ContentHashProtocol: Schema.Literals<readonly ["ipfs", "ipns", "swarm", "onion", "onion3", "skynet", "arweave", "adnl"]>;
+type ContentHashProtocol = typeof ContentHashProtocol.Type;
+//#endregion
+export { Abi$1 as Abi, AbiContentType, AbiRecordData, AddressRecordData, ContentHash, ContentHashProtocol, InterfaceId };
+//# sourceMappingURL=records.d.ts.map

package/dist/schemas/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","names":[],"sources":["../../src/schemas/records.ts"],"mappings":";;;cAMa,mBAAiB,OAAA,MAAA,OAAA,gCAAA,OAAA;KAElB,2BAA2B,kBAAkB;cAE5C,eAAa,OAAA,MAAA,OAAA,gCAAA,OAAA;KAEd,uBAAuB,cAAc;cAEpC,gBAAc,OAAA;KAEf,wBAAwB,eAAe;cAEtC,OAAG,OAAA,QAAA,KAAA;KAeJ,eAAa,MAAI;cAEhB,aAAW,OAAA,MAAA,OAAA,gCAAA,OAAA;KASZ,qBAAqB,YAAY;cAEhC,aAAW,OAAA,MAAA,OAAA,gCAAA,OAAA;KAEZ,qBAAqB,YAAY;cAEhC,qBAAmB,OAAA;KAWpB,6BAA6B,oBAAoB"}

package/dist/schemas/records.js

@@ -0,0 +1,32 @@
+import { Hex } from "./hex.js";
+import { Predicate, Schema } from "effect";
+
+//#region src/schemas/records.ts
+const AddressRecordData = Hex.pipe(Schema.brand("AddressRecordData"));
+const AbiRecordData = Hex.pipe(Schema.brand("AbiRecordData"));
+const AbiContentType = Schema.Literals([
+	"json",
+	"zlib-json",
+	"cbor",
+	"uri"
+]);
+const Abi = Schema.declare((value) => Array.isArray(value) && value.every((entry) => Predicate.isObject(entry) && Predicate.hasProperty(entry, "type") && Predicate.isString(entry.type)), {
+	identifier: "Abi",
+	description: "An Ethereum JSON ABI"
+});
+const InterfaceId = Hex.pipe(Schema.check(Schema.isPattern(/^0x[0-9a-fA-F]{8}$/, { message: "Expected a 4-byte interface ID" })), Schema.brand("InterfaceId"));
+const ContentHash = Hex.pipe(Schema.brand("ContentHash"));
+const ContentHashProtocol = Schema.Literals([
+	"ipfs",
+	"ipns",
+	"swarm",
+	"onion",
+	"onion3",
+	"skynet",
+	"arweave",
+	"adnl"
+]);
+
+//#endregion
+export { Abi, AbiContentType, AbiRecordData, AddressRecordData, ContentHash, ContentHashProtocol, InterfaceId };
+//# sourceMappingURL=records.js.map

package/dist/schemas/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","names":[],"sources":["../../src/schemas/records.ts"],"sourcesContent":["import { Predicate, Schema } from \"effect\";\n\nimport type { Abi as ViemAbi } from \"viem\";\n\nimport { Hex } from \"./hex.js\";\n\nexport const AddressRecordData = Hex.pipe(Schema.brand(\"AddressRecordData\"));\n\nexport type AddressRecordData = typeof AddressRecordData.Type;\n\nexport const AbiRecordData = Hex.pipe(Schema.brand(\"AbiRecordData\"));\n\nexport type AbiRecordData = typeof AbiRecordData.Type;\n\nexport const AbiContentType = Schema.Literals([\"json\", \"zlib-json\", \"cbor\", \"uri\"]);\n\nexport type AbiContentType = typeof AbiContentType.Type;\n\nexport const Abi = Schema.declare<ViemAbi>(\n  (value): value is ViemAbi =>\n    Array.isArray(value) &&\n    value.every(\n      (entry) =>\n        Predicate.isObject(entry) &&\n        Predicate.hasProperty(entry, \"type\") &&\n        Predicate.isString(entry.type),\n    ),\n  {\n    identifier: \"Abi\",\n    description: \"An Ethereum JSON ABI\",\n  },\n);\n\nexport type Abi = typeof Abi.Type;\n\nexport const InterfaceId = Hex.pipe(\n  Schema.check(\n    Schema.isPattern(/^0x[0-9a-fA-F]{8}$/, {\n      message: \"Expected a 4-byte interface ID\",\n    }),\n  ),\n  Schema.brand(\"InterfaceId\"),\n);\n\nexport type InterfaceId = typeof InterfaceId.Type;\n\nexport const ContentHash = Hex.pipe(Schema.brand(\"ContentHash\"));\n\nexport type ContentHash = typeof ContentHash.Type;\n\nexport const ContentHashProtocol = Schema.Literals([\n  \"ipfs\",\n  \"ipns\",\n  \"swarm\",\n  \"onion\",\n  \"onion3\",\n  \"skynet\",\n  \"arweave\",\n  \"adnl\",\n]);\n\nexport type ContentHashProtocol = typeof ContentHashProtocol.Type;\n"],"mappings":";;;;AAMA,MAAa,oBAAoB,IAAI,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAI3E,MAAa,gBAAgB,IAAI,KAAK,OAAO,MAAM,eAAe,CAAC;AAInE,MAAa,iBAAiB,OAAO,SAAS;CAAC;CAAQ;CAAa;CAAQ;AAAK,CAAC;AAIlF,MAAa,MAAM,OAAO,SACvB,UACC,MAAM,QAAQ,KAAK,KACnB,MAAM,OACH,UACC,UAAU,SAAS,KAAK,KACxB,UAAU,YAAY,OAAO,MAAM,KACnC,UAAU,SAAS,MAAM,IAAI,CACjC,GACF;CACE,YAAY;CACZ,aAAa;AACf,CACF;AAIA,MAAa,cAAc,IAAI,KAC7B,OAAO,MACL,OAAO,UAAU,sBAAsB,EACrC,SAAS,iCACX,CAAC,CACH,GACA,OAAO,MAAM,aAAa,CAC5B;AAIA,MAAa,cAAc,IAAI,KAAK,OAAO,MAAM,aAAa,CAAC;AAI/D,MAAa,sBAAsB,OAAO,SAAS;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC"}

package/dist/testing/create-test-config.d.ts

@@ -0,0 +1,19 @@
+import { GatewayOptions } from "../config/gateway-options.js";
+import { ReadOptions } from "../config/read-options.js";
+import { WriteOptions } from "../config/write-options.js";
+import { EnsDeploymentProfile, EnsforgeConfig } from "../config/config.js";
+import { PublicClient, WalletClient } from "viem";
+//#region src/testing/create-test-config.d.ts
+declare const ensTestChainId: 31337;
+interface CreateTestConfigParameters {
+  readonly deployments: EnsDeploymentProfile;
+  readonly publicClient: PublicClient;
+  readonly walletClient?: WalletClient;
+  readonly reads?: ReadOptions;
+  readonly writes?: WriteOptions;
+  readonly gateways?: GatewayOptions;
+}
+declare const createTestConfig: (parameters: CreateTestConfigParameters) => EnsforgeConfig;
+//#endregion
+export { CreateTestConfigParameters, createTestConfig, ensTestChainId };
+//# sourceMappingURL=create-test-config.d.ts.map

package/dist/testing/create-test-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-config.d.ts","names":[],"sources":["../../src/testing/create-test-config.ts"],"mappings":";;;;;;cAca;UAEI;WACN,aAAa;WACb,cAAc;WACd,eAAe;WACf,QAAQ;WACR,SAAS;WACT,WAAW;;cAGT,mBAAoB,YAAY,+BAA6B"}

package/dist/testing/create-test-config.js

@@ -0,0 +1,37 @@
+import { attachConfigContext } from "../internal/config/context.js";
+import { resolveReadOptions } from "../config/read-options.js";
+import { validateClientChain, validateDeployments } from "../internal/config/validation.js";
+import { makeServicesContext } from "../internal/services/context.js";
+import { EnsforgeConfigTypeId } from "../config/config.js";
+import { resolveGatewayOptions } from "../config/gateway-options.js";
+import { resolveWriteOptions } from "../config/write-options.js";
+
+//#region src/testing/create-test-config.ts
+const ensTestChainId = 31337;
+const createTestConfig = (parameters) => {
+	validateClientChain(parameters.publicClient, "public", "devnet", ensTestChainId);
+	if (parameters.walletClient !== void 0) validateClientChain(parameters.walletClient, "wallet", "devnet", ensTestChainId);
+	validateDeployments(parameters.deployments, ensTestChainId);
+	const reads = resolveReadOptions(parameters.reads);
+	const writes = resolveWriteOptions(parameters.writes);
+	const gateways = resolveGatewayOptions(parameters.gateways);
+	const serviceValues = {
+		network: "devnet",
+		chainId: ensTestChainId,
+		publicClient: parameters.publicClient,
+		reads,
+		gateways,
+		deployments: parameters.deployments,
+		...parameters.walletClient === void 0 ? {} : { walletClient: parameters.walletClient }
+	};
+	return Object.freeze(attachConfigContext({
+		[EnsforgeConfigTypeId]: EnsforgeConfigTypeId,
+		...serviceValues,
+		writes,
+		gateways
+	}, makeServicesContext(serviceValues)));
+};
+
+//#endregion
+export { createTestConfig, ensTestChainId };
+//# sourceMappingURL=create-test-config.js.map

package/dist/testing/create-test-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-config.js","names":[],"sources":["../../src/testing/create-test-config.ts"],"sourcesContent":["import type { PublicClient, WalletClient } from \"viem\";\n\nimport type { EnsDeploymentProfile, EnsforgeConfig } from \"../config/config.js\";\nimport { EnsforgeConfigTypeId } from \"../config/config.js\";\nimport type { GatewayOptions } from \"../config/gateway-options.js\";\nimport { resolveGatewayOptions } from \"../config/gateway-options.js\";\nimport type { ReadOptions } from \"../config/read-options.js\";\nimport { resolveReadOptions } from \"../config/read-options.js\";\nimport type { WriteOptions } from \"../config/write-options.js\";\nimport { resolveWriteOptions } from \"../config/write-options.js\";\nimport { attachConfigContext } from \"../internal/config/context.js\";\nimport { validateClientChain, validateDeployments } from \"../internal/config/validation.js\";\nimport { makeServicesContext } from \"../internal/services/context.js\";\n\nexport const ensTestChainId = 31337 as const;\n\nexport interface CreateTestConfigParameters {\n  readonly deployments: EnsDeploymentProfile;\n  readonly publicClient: PublicClient;\n  readonly walletClient?: WalletClient;\n  readonly reads?: ReadOptions;\n  readonly writes?: WriteOptions;\n  readonly gateways?: GatewayOptions;\n}\n\nexport const createTestConfig = (parameters: CreateTestConfigParameters): EnsforgeConfig => {\n  validateClientChain(parameters.publicClient, \"public\", \"devnet\", ensTestChainId);\n\n  if (parameters.walletClient !== undefined) {\n    validateClientChain(parameters.walletClient, \"wallet\", \"devnet\", ensTestChainId);\n  }\n\n  validateDeployments(parameters.deployments, ensTestChainId);\n  const reads = resolveReadOptions(parameters.reads);\n  const writes = resolveWriteOptions(parameters.writes);\n  const gateways = resolveGatewayOptions(parameters.gateways);\n\n  const serviceValues = {\n    network: \"devnet\",\n    chainId: ensTestChainId,\n    publicClient: parameters.publicClient,\n    reads,\n    gateways,\n    deployments: parameters.deployments,\n    ...(parameters.walletClient === undefined ? {} : { walletClient: parameters.walletClient }),\n  } as const;\n\n  return Object.freeze(\n    attachConfigContext(\n      // The public config type intentionally excludes local networks. This cast remains confined to\n      // the unpublished testing entry point while runtime services retain the real devnet values.\n      {\n        [EnsforgeConfigTypeId]: EnsforgeConfigTypeId,\n        ...serviceValues,\n        writes,\n        gateways,\n      } as unknown as EnsforgeConfig,\n      makeServicesContext(serviceValues),\n    ),\n  );\n};\n"],"mappings":";;;;;;;;;AAcA,MAAa,iBAAiB;AAW9B,MAAa,oBAAoB,eAA2D;CAC1F,oBAAoB,WAAW,cAAc,UAAU,UAAU,cAAc;CAE/E,IAAI,WAAW,iBAAiB,QAC9B,oBAAoB,WAAW,cAAc,UAAU,UAAU,cAAc;CAGjF,oBAAoB,WAAW,aAAa,cAAc;CAC1D,MAAM,QAAQ,mBAAmB,WAAW,KAAK;CACjD,MAAM,SAAS,oBAAoB,WAAW,MAAM;CACpD,MAAM,WAAW,sBAAsB,WAAW,QAAQ;CAE1D,MAAM,gBAAgB;EACpB,SAAS;EACT,SAAS;EACT,cAAc,WAAW;EACzB;EACA;EACA,aAAa,WAAW;EACxB,GAAI,WAAW,iBAAiB,SAAY,CAAC,IAAI,EAAE,cAAc,WAAW,aAAa;CAC3F;CAEA,OAAO,OAAO,OACZ,oBAGE;GACG,uBAAuB;EACxB,GAAG;EACH;EACA;CACF,GACA,oBAAoB,aAAa,CACnC,CACF;AACF"}

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+import { CreateTestConfigParameters, createTestConfig, ensTestChainId } from "./testing/create-test-config.js";
+export { type CreateTestConfigParameters, createTestConfig, ensTestChainId };

package/dist/testing.js

@@ -0,0 +1,3 @@
+import { createTestConfig, ensTestChainId } from "./testing/create-test-config.js";
+
+export { createTestConfig, ensTestChainId };

package/dist/write/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfirmationPolicy, SimulationPolicy } from "../config/write-options.js";
+import { CallEstimate, CallExecutionResult, CallsStatusResult, EstimateCallsParameters, EstimateCallsResult, ExecuteWritePlanParameters, FeeEstimate, GetCallsStatusParameters, GetWalletCapabilitiesParameters, NativeBatchResult, PrepareCallsParameters, PreparedWriteCall, ResumeCallsParameters, SendCallsParameters, SendCallsResult, SequentialCallsResult, SimulateCallsParameters, SimulatedWriteCall, WalletCapabilitiesResult, WalletOverrides, WriteAtomicity, WriteError, WriteMode, WritePlan, WritePlanProgress, WriteReceipt, WriteStage, WriteStageResult, WriteWaitCondition } from "./types.js";
+export { type CallEstimate, type CallExecutionResult, type CallsStatusResult, type EstimateCallsParameters, type EstimateCallsResult, type ExecuteWritePlanParameters, type FeeEstimate, type GetCallsStatusParameters, type GetWalletCapabilitiesParameters, type NativeBatchResult, type PrepareCallsParameters, type PreparedWriteCall, type ResumeCallsParameters, type SendCallsParameters, type SendCallsResult, type SequentialCallsResult, type SimulateCallsParameters, type SimulatedWriteCall, type WalletCapabilitiesResult, type WalletOverrides, WriteAtomicity, type WriteError, WriteMode, type WritePlan, type WritePlanProgress, type WriteReceipt, type WriteStage, type WriteStageResult, type WriteWaitCondition };