@ensforge/core 0.0.0

package/dist/actions/name/get-name-state/types.d.ts

@@ -0,0 +1,240 @@
+import { BlockParameters } from "../../../action/block.js";
+import { CodecError } from "../../../errors/codec-error.js";
+import { ContractError } from "../../../errors/contract-error.js";
+import { NameError } from "../../../errors/name-error.js";
+import { RpcError } from "../../../errors/rpc-error.js";
+import { Schema } from "effect";
+//#region src/actions/name/get-name-state/types.d.ts
+declare const NameStatus: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+type NameStatus = typeof NameStatus.Type;
+declare const AvailableNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"available">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly wrapped: Schema.Literal<false>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const V1UnwrappedNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"v1-unwrapped">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Literal<false>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const V1WrappedNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"v1-wrapped">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Literal<true>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const V2NativeNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-native">;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const V2MigratedNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-migrated">;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<true>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const V2ReservedNameState: Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-reserved">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>;
+declare const NameState: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"available">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly wrapped: Schema.Literal<false>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"v1-unwrapped">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Literal<false>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"v1-wrapped">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Literal<true>;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-native">;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-migrated">;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<true>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"v2-reserved">;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapped: Schema.Boolean;
+  readonly migrated: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly status: Schema.Literals<readonly ["available", "active", "grace", "expired", "reserved"]>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly manager: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly expiry: Schema.NullOr<Schema.BigInt>;
+  readonly gracePeriodEnd: Schema.NullOr<Schema.BigInt>;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly available: Schema.Boolean;
+  readonly renewable: Schema.Boolean;
+}>]>;
+type NameState = typeof NameState.Type;
+type GetNameStateParameters = {
+  readonly name: string;
+} & BlockParameters;
+type GetNameStateError = CodecError | ContractError | NameError | RpcError;
+//#endregion
+export { AvailableNameState, GetNameStateError, GetNameStateParameters, NameState, NameStatus, V1UnwrappedNameState, V1WrappedNameState, V2MigratedNameState, V2NativeNameState, V2ReservedNameState };
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/name/get-name-state/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/actions/name/get-name-state/types.ts"],"mappings":";;;;;;;cAUa,YAAU,OAAA;KAEX,oBAAoB,WAAW;cAqB9B,oBAAkB,OAAA;;;;;;;;;;;;;;;;;;;cAQlB,sBAAoB,OAAA;;;;;;;;;;;;;;;;;;;cAQpB,oBAAkB,OAAA;;;;;;;;;;;;;;;;;;;cAQlB,mBAAiB,OAAA;;;;;;;;;;;;;;;;;;;cAQjB,qBAAmB,OAAA;;;;;;;;;;;;;;;;;;;cAQnB,qBAAmB,OAAA;;;;;;;;;;;;;;;;;;;cAQnB,WAAS,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASV,mBAAmB,UAAU;KAE7B;WAAoC;IAAiB;KAErD,oBAAoB,aAAa,gBAAgB,YAAY"}

package/dist/actions/name/get-name-state/types.js

@@ -0,0 +1,83 @@
+import { NormalizedName } from "../../../schemas/name.js";
+import { EthereumAddress } from "../../../schemas/identity.js";
+import { Schema } from "effect";
+
+//#region src/actions/name/get-name-state/types.ts
+const NameStatus = Schema.Literals([
+	"available",
+	"active",
+	"grace",
+	"expired",
+	"reserved"
+]);
+const nullableAddress = Schema.NullOr(EthereumAddress);
+const nullableBigInt = Schema.NullOr(Schema.BigInt);
+const sharedFields = {
+	name: NormalizedName,
+	status: NameStatus,
+	owner: nullableAddress,
+	manager: nullableAddress,
+	registrant: nullableAddress,
+	registry: EthereumAddress,
+	resolver: nullableAddress,
+	expiry: nullableBigInt,
+	gracePeriodEnd: nullableBigInt,
+	tokenId: nullableBigInt,
+	resource: nullableBigInt,
+	available: Schema.Boolean,
+	renewable: Schema.Boolean
+};
+const AvailableNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("available"),
+	protocol: Schema.Literals(["v1", "v2"]),
+	wrapped: Schema.Literal(false),
+	migrated: Schema.Literal(false)
+});
+const V1UnwrappedNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("v1-unwrapped"),
+	protocol: Schema.Literal("v1"),
+	wrapped: Schema.Literal(false),
+	migrated: Schema.Literal(false)
+});
+const V1WrappedNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("v1-wrapped"),
+	protocol: Schema.Literal("v1"),
+	wrapped: Schema.Literal(true),
+	migrated: Schema.Literal(false)
+});
+const V2NativeNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("v2-native"),
+	protocol: Schema.Literal("v2"),
+	wrapped: Schema.Boolean,
+	migrated: Schema.Literal(false)
+});
+const V2MigratedNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("v2-migrated"),
+	protocol: Schema.Literal("v2"),
+	wrapped: Schema.Boolean,
+	migrated: Schema.Literal(true)
+});
+const V2ReservedNameState = Schema.Struct({
+	...sharedFields,
+	kind: Schema.Literal("v2-reserved"),
+	protocol: Schema.Literal("v1"),
+	wrapped: Schema.Boolean,
+	migrated: Schema.Literal(false)
+});
+const NameState = Schema.Union([
+	AvailableNameState,
+	V1UnwrappedNameState,
+	V1WrappedNameState,
+	V2NativeNameState,
+	V2MigratedNameState,
+	V2ReservedNameState
+]);
+
+//#endregion
+export { AvailableNameState, NameState, NameStatus, V1UnwrappedNameState, V1WrappedNameState, V2MigratedNameState, V2NativeNameState, V2ReservedNameState };
+//# sourceMappingURL=types.js.map

package/dist/actions/name/get-name-state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../src/actions/name/get-name-state/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport type { BlockParameters } from \"../../../action/block.js\";\nimport type { CodecError } from \"../../../errors/codec-error.js\";\nimport type { ContractError } from \"../../../errors/contract-error.js\";\nimport type { NameError } from \"../../../errors/name-error.js\";\nimport type { RpcError } from \"../../../errors/rpc-error.js\";\nimport { EthereumAddress } from \"../../../schemas/identity.js\";\nimport { NormalizedName } from \"../../../schemas/name.js\";\n\nexport const NameStatus = Schema.Literals([\"available\", \"active\", \"grace\", \"expired\", \"reserved\"]);\n\nexport type NameStatus = typeof NameStatus.Type;\n\nconst nullableAddress = Schema.NullOr(EthereumAddress);\nconst nullableBigInt = Schema.NullOr(Schema.BigInt);\n\nconst sharedFields = {\n  name: NormalizedName,\n  status: NameStatus,\n  owner: nullableAddress,\n  manager: nullableAddress,\n  registrant: nullableAddress,\n  registry: EthereumAddress,\n  resolver: nullableAddress,\n  expiry: nullableBigInt,\n  gracePeriodEnd: nullableBigInt,\n  tokenId: nullableBigInt,\n  resource: nullableBigInt,\n  available: Schema.Boolean,\n  renewable: Schema.Boolean,\n};\n\nexport const AvailableNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"available\"),\n  protocol: Schema.Literals([\"v1\", \"v2\"]),\n  wrapped: Schema.Literal(false),\n  migrated: Schema.Literal(false),\n});\n\nexport const V1UnwrappedNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"v1-unwrapped\"),\n  protocol: Schema.Literal(\"v1\"),\n  wrapped: Schema.Literal(false),\n  migrated: Schema.Literal(false),\n});\n\nexport const V1WrappedNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"v1-wrapped\"),\n  protocol: Schema.Literal(\"v1\"),\n  wrapped: Schema.Literal(true),\n  migrated: Schema.Literal(false),\n});\n\nexport const V2NativeNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"v2-native\"),\n  protocol: Schema.Literal(\"v2\"),\n  wrapped: Schema.Boolean,\n  migrated: Schema.Literal(false),\n});\n\nexport const V2MigratedNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"v2-migrated\"),\n  protocol: Schema.Literal(\"v2\"),\n  wrapped: Schema.Boolean,\n  migrated: Schema.Literal(true),\n});\n\nexport const V2ReservedNameState = Schema.Struct({\n  ...sharedFields,\n  kind: Schema.Literal(\"v2-reserved\"),\n  protocol: Schema.Literal(\"v1\"),\n  wrapped: Schema.Boolean,\n  migrated: Schema.Literal(false),\n});\n\nexport const NameState = Schema.Union([\n  AvailableNameState,\n  V1UnwrappedNameState,\n  V1WrappedNameState,\n  V2NativeNameState,\n  V2MigratedNameState,\n  V2ReservedNameState,\n]);\n\nexport type NameState = typeof NameState.Type;\n\nexport type GetNameStateParameters = { readonly name: string } & BlockParameters;\n\nexport type GetNameStateError = CodecError | ContractError | NameError | RpcError;\n"],"mappings":";;;;;AAUA,MAAa,aAAa,OAAO,SAAS;CAAC;CAAa;CAAU;CAAS;CAAW;AAAU,CAAC;AAIjG,MAAM,kBAAkB,OAAO,OAAO,eAAe;AACrD,MAAM,iBAAiB,OAAO,OAAO,OAAO,MAAM;AAElD,MAAM,eAAe;CACnB,MAAM;CACN,QAAQ;CACR,OAAO;CACP,SAAS;CACT,YAAY;CACZ,UAAU;CACV,UAAU;CACV,QAAQ;CACR,gBAAgB;CAChB,SAAS;CACT,UAAU;CACV,WAAW,OAAO;CAClB,WAAW,OAAO;AACpB;AAEA,MAAa,qBAAqB,OAAO,OAAO;CAC9C,GAAG;CACH,MAAM,OAAO,QAAQ,WAAW;CAChC,UAAU,OAAO,SAAS,CAAC,MAAM,IAAI,CAAC;CACtC,SAAS,OAAO,QAAQ,KAAK;CAC7B,UAAU,OAAO,QAAQ,KAAK;AAChC,CAAC;AAED,MAAa,uBAAuB,OAAO,OAAO;CAChD,GAAG;CACH,MAAM,OAAO,QAAQ,cAAc;CACnC,UAAU,OAAO,QAAQ,IAAI;CAC7B,SAAS,OAAO,QAAQ,KAAK;CAC7B,UAAU,OAAO,QAAQ,KAAK;AAChC,CAAC;AAED,MAAa,qBAAqB,OAAO,OAAO;CAC9C,GAAG;CACH,MAAM,OAAO,QAAQ,YAAY;CACjC,UAAU,OAAO,QAAQ,IAAI;CAC7B,SAAS,OAAO,QAAQ,IAAI;CAC5B,UAAU,OAAO,QAAQ,KAAK;AAChC,CAAC;AAED,MAAa,oBAAoB,OAAO,OAAO;CAC7C,GAAG;CACH,MAAM,OAAO,QAAQ,WAAW;CAChC,UAAU,OAAO,QAAQ,IAAI;CAC7B,SAAS,OAAO;CAChB,UAAU,OAAO,QAAQ,KAAK;AAChC,CAAC;AAED,MAAa,sBAAsB,OAAO,OAAO;CAC/C,GAAG;CACH,MAAM,OAAO,QAAQ,aAAa;CAClC,UAAU,OAAO,QAAQ,IAAI;CAC7B,SAAS,OAAO;CAChB,UAAU,OAAO,QAAQ,IAAI;AAC/B,CAAC;AAED,MAAa,sBAAsB,OAAO,OAAO;CAC/C,GAAG;CACH,MAAM,OAAO,QAAQ,aAAa;CAClC,UAAU,OAAO,QAAQ,IAAI;CAC7B,SAAS,OAAO;CAChB,UAAU,OAAO,QAAQ,KAAK;AAChC,CAAC;AAED,MAAa,YAAY,OAAO,MAAM;CACpC;CACA;CACA;CACA;CACA;CACA;AACF,CAAC"}

package/dist/actions/name/get-name-status/index.d.ts

@@ -0,0 +1,8 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { GetNameStateError, GetNameStateParameters, NameStatus } from "../get-name-state/types.js";
+import "../../../index.js";
+//#region src/actions/name/get-name-status/index.d.ts
+declare const getNameStatus: EnsReadAction<GetNameStateParameters, "available" | "reserved" | "active" | "grace" | "expired", GetNameStateError>;
+//#endregion
+export { type GetNameStateError as GetNameStatusError, type GetNameStateParameters as GetNameStatusParameters, type NameStatus as GetNameStatusResult, getNameStatus };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/name/get-name-status/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/name/get-name-status/index.ts"],"mappings":";;;;cA2Da,eAAa,cAAA,mFAAA"}

package/dist/actions/name/get-name-status/index.js

@@ -0,0 +1,41 @@
+import { defineReadAction } from "../../../action/read-request.js";
+import { executeRead } from "../../../internal/read/execute-read.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { EthereumClient } from "../../../internal/client/ethereum-client.js";
+import { analyzeName } from "../../../names/analyze.js";
+import { readNameRoute } from "../../../internal/name/name-route.js";
+import { readBlockTimestamp } from "../../../internal/read/block-timestamp.js";
+import { getExpiry } from "../get-expiry/index.js";
+import { getOwner } from "../get-owner/index.js";
+import { Effect } from "effect";
+import { ethRegistrarV2IsRenewableAbi } from "@ensforge/contracts/v2";
+
+//#region src/actions/name/get-name-status/index.ts
+const getNameStatusEffect = Effect.fn("ensforge.getNameStatus")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, Effect.gen(function* () {
+		const route = yield* readNameRoute(name);
+		if (route.kind === "reserved") return route.state.status === 1 ? "reserved" : "grace";
+		if (route.kind === "available" && route.state.expiry === 0n) return "available";
+		if (route.kind === "v2") {
+			if (route.state.status === 2) return "active";
+			if (analyzeName(name).ethSecondLevelLabel === void 0) return route.state.status === 0 ? "available" : "expired";
+			return (yield* (yield* EthereumClient).readContract({
+				address: route.deployment.contracts.ethRegistrar,
+				abi: ethRegistrarV2IsRenewableAbi,
+				functionName: "isRenewable",
+				args: [route.label]
+			})) ? "grace" : "expired";
+		}
+		const expiry = yield* getExpiry.effect(config, parameters);
+		if (expiry === null) return (yield* getOwner.effect(config, parameters)) === null ? "available" : "active";
+		const timestamp = yield* readBlockTimestamp();
+		if (timestamp <= expiry.expiry) return "active";
+		return timestamp <= expiry.gracePeriodEnd ? "grace" : "expired";
+	}));
+});
+const getNameStatus = defineReadAction(getNameStatusEffect);
+
+//#endregion
+export { getNameStatus };
+//# sourceMappingURL=index.js.map

package/dist/actions/name/get-name-status/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/name/get-name-status/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { ethRegistrarV2IsRenewableAbi } from \"@ensforge/contracts/v2\";\n\nimport { defineReadAction } from \"../../../action/read-request.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { EthereumClient } from \"../../../internal/client/ethereum-client.js\";\nimport { readNameRoute } from \"../../../internal/name/name-route.js\";\nimport { readBlockTimestamp } from \"../../../internal/read/block-timestamp.js\";\nimport { executeRead } from \"../../../internal/read/execute-read.js\";\nimport { analyzeName } from \"../../../names/analyze.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport { getExpiry } from \"../get-expiry/index.js\";\nimport type {\n  GetNameStateError,\n  GetNameStateParameters,\n  NameStatus,\n} from \"../get-name-state/types.js\";\nimport { getOwner } from \"../get-owner/index.js\";\n\nconst getNameStatusEffect = Effect.fn(\"ensforge.getNameStatus\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetNameStateParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n  return yield* executeRead(\n    config,\n    parameters,\n    Effect.gen(function* () {\n      const route = yield* readNameRoute(name);\n      if (route.kind === \"reserved\") return route.state.status === 1 ? \"reserved\" : \"grace\";\n      if (route.kind === \"available\" && route.state.expiry === 0n) return \"available\";\n\n      if (route.kind === \"v2\") {\n        if (route.state.status === 2) return \"active\";\n        if (analyzeName(name).ethSecondLevelLabel === undefined) {\n          return route.state.status === 0 ? \"available\" : \"expired\";\n        }\n        const renewable = yield* (yield* EthereumClient).readContract({\n          address: route.deployment.contracts.ethRegistrar,\n          abi: ethRegistrarV2IsRenewableAbi,\n          functionName: \"isRenewable\",\n          args: [route.label],\n        });\n        return renewable ? \"grace\" : \"expired\";\n      }\n\n      const expiry = yield* getExpiry.effect(config, parameters);\n      if (expiry === null) {\n        const owner = yield* getOwner.effect(config, parameters);\n        return owner === null ? \"available\" : \"active\";\n      }\n      const timestamp = yield* readBlockTimestamp();\n      if (timestamp <= expiry.expiry) return \"active\";\n      return timestamp <= expiry.gracePeriodEnd ? \"grace\" : \"expired\";\n    }),\n  );\n});\n\nexport const getNameStatus = defineReadAction<\n  GetNameStateParameters,\n  NameStatus,\n  GetNameStateError\n>(getNameStatusEffect);\n\nexport type {\n  GetNameStateError as GetNameStatusError,\n  GetNameStateParameters as GetNameStatusParameters,\n  NameStatus as GetNameStatusResult,\n} from \"../get-name-state/types.js\";\n"],"mappings":";;;;;;;;;;;;;AAoBA,MAAM,sBAAsB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAC9D,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,OAAO,OAAO,YACZ,QACA,YACA,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,cAAc,IAAI;EACvC,IAAI,MAAM,SAAS,YAAY,OAAO,MAAM,MAAM,WAAW,IAAI,aAAa;EAC9E,IAAI,MAAM,SAAS,eAAe,MAAM,MAAM,WAAW,IAAI,OAAO;EAEpE,IAAI,MAAM,SAAS,MAAM;GACvB,IAAI,MAAM,MAAM,WAAW,GAAG,OAAO;GACrC,IAAI,YAAY,IAAI,CAAC,CAAC,wBAAwB,QAC5C,OAAO,MAAM,MAAM,WAAW,IAAI,cAAc;GAQlD,QAAO,QANmB,OAAO,eAAc,CAAE,aAAa;IAC5D,SAAS,MAAM,WAAW,UAAU;IACpC,KAAK;IACL,cAAc;IACd,MAAM,CAAC,MAAM,KAAK;GACpB,CAAC,KACkB,UAAU;EAC/B;EAEA,MAAM,SAAS,OAAO,UAAU,OAAO,QAAQ,UAAU;EACzD,IAAI,WAAW,MAEb,QAAO,OADc,SAAS,OAAO,QAAQ,UAAU,OACtC,OAAO,cAAc;EAExC,MAAM,YAAY,OAAO,mBAAmB;EAC5C,IAAI,aAAa,OAAO,QAAQ,OAAO;EACvC,OAAO,aAAa,OAAO,iBAAiB,UAAU;CACxD,CAAC,CACH;AACF,CAAC;AAED,MAAa,gBAAgB,iBAI3B,mBAAmB"}

package/dist/actions/name/get-owner/index.d.ts

@@ -0,0 +1,14 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { GetOwnerError, GetOwnerParameters, OwnerResult, OwnershipLevel } from "./types.js";
+import "../../../index.js";
+//#region src/actions/name/get-owner/index.d.ts
+declare const getOwner: EnsReadAction<GetOwnerParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly ownershipLevel: "registry" | "registrar" | "nameWrapper";
+} | null, GetOwnerError>;
+//#endregion
+export { type GetOwnerError, type GetOwnerParameters, OwnerResult, OwnershipLevel, getOwner };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/name/get-owner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/name/get-owner/index.ts"],"mappings":";;;;cA2Ca,UAEZ,cAFoB;;;;;;UAEpB"}

package/dist/actions/name/get-owner/index.js

@@ -0,0 +1,34 @@
+import { defineReadAction } from "../../../action/read-request.js";
+import { executeRead } from "../../../internal/read/execute-read.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { DeploymentService } from "../../../internal/services/deployment.js";
+import { getOwnerV1 } from "./v1.js";
+import { routeOwner } from "./route.js";
+import { getOwnerV2 } from "./v2.js";
+import { OwnerResult, OwnershipLevel } from "./types.js";
+import { Effect } from "effect";
+
+//#region src/actions/name/get-owner/index.ts
+const getOwnerWithServices = Effect.fn("getOwnerWithServices")(function* (name) {
+	const deployment = yield* DeploymentService;
+	yield* Effect.annotateCurrentSpan({
+		"ens.name": name,
+		"ens.deployment.protocol": deployment.profile.protocol
+	});
+	switch (deployment.profile.protocol) {
+		case "v1": return yield* getOwnerV1(name, deployment.profile.v1);
+		case "v2": {
+			const v1 = deployment.profile.v1;
+			return v1 === void 0 ? yield* getOwnerV2(name, deployment.profile.v2) : yield* routeOwner(name, v1, deployment.profile.v2);
+		}
+	}
+});
+const getOwnerEffect = Effect.fn("ensforge.getOwner")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, getOwnerWithServices(name));
+});
+const getOwner = defineReadAction(getOwnerEffect);
+
+//#endregion
+export { OwnerResult, OwnershipLevel, getOwner };
+//# sourceMappingURL=index.js.map

package/dist/actions/name/get-owner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/name/get-owner/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { defineReadAction } from \"../../../action/read-request.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { executeRead } from \"../../../internal/read/execute-read.js\";\nimport { DeploymentService } from \"../../../internal/services/deployment.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport { routeOwner } from \"./route.js\";\nimport type { GetOwnerError, GetOwnerParameters, OwnerResult } from \"./types.js\";\nimport { getOwnerV1 } from \"./v1.js\";\nimport { getOwnerV2 } from \"./v2.js\";\n\nconst getOwnerWithServices = Effect.fn(\"getOwnerWithServices\")(function* (\n  name: ReturnType<typeof normalizeName>,\n) {\n  const deployment = yield* DeploymentService;\n\n  yield* Effect.annotateCurrentSpan({\n    \"ens.name\": name,\n    \"ens.deployment.protocol\": deployment.profile.protocol,\n  });\n\n  switch (deployment.profile.protocol) {\n    case \"v1\":\n      return yield* getOwnerV1(name, deployment.profile.v1);\n    case \"v2\": {\n      const v1 = deployment.profile.v1;\n      return v1 === undefined\n        ? yield* getOwnerV2(name, deployment.profile.v2)\n        : yield* routeOwner(name, v1, deployment.profile.v2);\n    }\n  }\n});\n\nconst getOwnerEffect = Effect.fn(\"ensforge.getOwner\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetOwnerParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n\n  return yield* executeRead(config, parameters, getOwnerWithServices(name));\n});\n\nexport const getOwner = defineReadAction<GetOwnerParameters, OwnerResult | null, GetOwnerError>(\n  getOwnerEffect,\n);\n\nexport {\n  OwnerResult,\n  OwnershipLevel,\n  type GetOwnerError,\n  type GetOwnerParameters,\n} from \"./types.js\";\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,uBAAuB,OAAO,GAAG,sBAAsB,CAAC,CAAC,WAC7D,MACA;CACA,MAAM,aAAa,OAAO;CAE1B,OAAO,OAAO,oBAAoB;EAChC,YAAY;EACZ,2BAA2B,WAAW,QAAQ;CAChD,CAAC;CAED,QAAQ,WAAW,QAAQ,UAA3B;EACE,KAAK,MACH,OAAO,OAAO,WAAW,MAAM,WAAW,QAAQ,EAAE;EACtD,KAAK,MAAM;GACT,MAAM,KAAK,WAAW,QAAQ;GAC9B,OAAO,OAAO,SACV,OAAO,WAAW,MAAM,WAAW,QAAQ,EAAE,IAC7C,OAAO,WAAW,MAAM,IAAI,WAAW,QAAQ,EAAE;EACvD;CACF;AACF,CAAC;AAED,MAAM,iBAAiB,OAAO,GAAG,mBAAmB,CAAC,CAAC,WACpD,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CAExD,OAAO,OAAO,YAAY,QAAQ,YAAY,qBAAqB,IAAI,CAAC;AAC1E,CAAC;AAED,MAAa,WAAW,iBACtB,cACF"}

package/dist/actions/name/get-owner/route.js

@@ -0,0 +1,105 @@
+import { ContractError } from "../../../errors/contract-error.js";
+import { EthereumClient } from "../../../internal/client/ethereum-client.js";
+import { labelhash } from "../../../names/hashes.js";
+import { analyzeName } from "../../../names/analyze.js";
+import { dnsEncodeName } from "../../../names/dns.js";
+import { interpretV1Owner, readV1Owner } from "./v1.js";
+import { Effect, Result } from "effect";
+import { isAddressEqual, zeroAddress } from "viem";
+import { ethRegistryV2GetStateAbi, ethRenewerV1IsRenewableAbi, universalResolverV2FindOwnerAbi, universalResolverV2FindParentRegistryAbi, universalResolverV2FindResolverAbi } from "@ensforge/contracts/v2";
+
+//#region src/actions/name/get-owner/route.ts
+const routeEthOwner = Effect.fn("routeEthOwner")(function* (name, label, v1, v2) {
+	const ethereum = yield* EthereumClient;
+	const dnsName = yield* dnsEncodeName.effect(name);
+	const ownerId = BigInt(labelhash(label));
+	const [ownerResult, stateResult, renewableResult, v1Results] = yield* Effect.all([
+		Effect.result(ethereum.readContract({
+			address: v2.contracts.universalResolver,
+			abi: universalResolverV2FindOwnerAbi,
+			functionName: "findOwner",
+			args: [dnsName]
+		})),
+		Effect.result(ethereum.readContract({
+			address: v2.contracts.ethRegistry,
+			abi: ethRegistryV2GetStateAbi,
+			functionName: "getState",
+			args: [ownerId]
+		})),
+		Effect.result(ethereum.readContract({
+			address: v2.migration.ethRenewerV1,
+			abi: ethRenewerV1IsRenewableAbi,
+			functionName: "isRenewable",
+			args: [label]
+		})),
+		readV1Owner(name, v1)
+	], { concurrency: "unbounded" });
+	if (Result.isFailure(ownerResult)) return yield* ownerResult.failure;
+	if (!isAddressEqual(ownerResult.success, zeroAddress)) return {
+		name,
+		owner: ownerResult.success,
+		registrant: null,
+		protocol: "v2",
+		ownershipLevel: "registry"
+	};
+	if (Result.isFailure(stateResult)) return yield* stateResult.failure;
+	if (Result.isFailure(renewableResult)) return yield* renewableResult.failure;
+	const state = stateResult.success;
+	const renewable = renewableResult.success;
+	if (state.status === 2 || !isAddressEqual(state.latestOwner, zeroAddress)) return null;
+	if (state.status !== 1 && state.status !== 0) return yield* new ContractError({
+		code: "DECODE_FAILED",
+		message: "Unknown ENSv2 ETH registry status",
+		cause: state
+	});
+	if (state.status === 0 && !renewable) return null;
+	return yield* interpretV1Owner(name, v1, v1Results);
+});
+const routeOtherOwner = Effect.fn("routeOtherOwner")(function* (name, v1, v2) {
+	const ethereum = yield* EthereumClient;
+	const dnsName = yield* dnsEncodeName.effect(name);
+	const [ownerResult, parentResult, resolverResult, v1Results] = yield* Effect.all([
+		Effect.result(ethereum.readContract({
+			address: v2.contracts.universalResolver,
+			abi: universalResolverV2FindOwnerAbi,
+			functionName: "findOwner",
+			args: [dnsName]
+		})),
+		Effect.result(ethereum.readContract({
+			address: v2.contracts.universalResolver,
+			abi: universalResolverV2FindParentRegistryAbi,
+			functionName: "findParentRegistry",
+			args: [dnsName]
+		})),
+		Effect.result(ethereum.readContract({
+			address: v2.contracts.universalResolver,
+			abi: universalResolverV2FindResolverAbi,
+			functionName: "findResolver",
+			args: [dnsName]
+		})),
+		readV1Owner(name, v1)
+	], { concurrency: "unbounded" });
+	if (Result.isFailure(ownerResult)) return yield* ownerResult.failure;
+	if (!isAddressEqual(ownerResult.success, zeroAddress)) return {
+		name,
+		owner: ownerResult.success,
+		registrant: null,
+		protocol: "v2",
+		ownershipLevel: "registry"
+	};
+	if (Result.isFailure(parentResult)) return yield* parentResult.failure;
+	if (Result.isFailure(resolverResult)) return yield* resolverResult.failure;
+	const [resolver] = resolverResult.success;
+	const usesV1Mirror = isAddressEqual(resolver, v2.migration.ensV1Resolver);
+	const hasV2ParentRegistry = !isAddressEqual(parentResult.success, zeroAddress);
+	if (!usesV1Mirror && hasV2ParentRegistry) return null;
+	return yield* interpretV1Owner(name, v1, v1Results);
+});
+const routeOwner = Effect.fn("routeOwner")(function* (name, v1, v2) {
+	const secondLevelLabel = analyzeName(name).ethSecondLevelLabel;
+	return secondLevelLabel === void 0 ? yield* routeOtherOwner(name, v1, v2) : yield* routeEthOwner(name, secondLevelLabel, v1, v2);
+});
+
+//#endregion
+export { routeOwner };
+//# sourceMappingURL=route.js.map

package/dist/actions/name/get-owner/route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","names":[],"sources":["../../../../src/actions/name/get-owner/route.ts"],"sourcesContent":["import { Effect, Result } from \"effect\";\n\nimport type { EnsV1Deployment, EnsV2Deployment } from \"@ensforge/contracts/deployments\";\nimport {\n  ethRegistryV2GetStateAbi,\n  ethRenewerV1IsRenewableAbi,\n  universalResolverV2FindOwnerAbi,\n  universalResolverV2FindParentRegistryAbi,\n  universalResolverV2FindResolverAbi,\n} from \"@ensforge/contracts/v2\";\nimport { isAddressEqual, zeroAddress } from \"viem\";\n\nimport type { CodecError } from \"../../../errors/codec-error.js\";\nimport { ContractError } from \"../../../errors/contract-error.js\";\nimport { EthereumClient } from \"../../../internal/client/ethereum-client.js\";\nimport type { ViemError } from \"../../../internal/errors/viem-error.js\";\nimport type { ReadContext } from \"../../../internal/read/execution-context.js\";\nimport { analyzeName } from \"../../../names/analyze.js\";\nimport { dnsEncodeName } from \"../../../names/dns.js\";\nimport { labelhash } from \"../../../names/hashes.js\";\nimport type { NormalizedName } from \"../../../schemas/name.js\";\nimport type { OwnerResult } from \"./types.js\";\nimport { interpretV1Owner, readV1Owner } from \"./v1.js\";\n\nconst routeEthOwner = Effect.fn(\"routeEthOwner\")(function* (\n  name: NormalizedName,\n  label: string,\n  v1: EnsV1Deployment,\n  v2: EnsV2Deployment,\n): Effect.fn.Return<\n  OwnerResult | null,\n  CodecError | ContractError | ViemError,\n  EthereumClient | ReadContext\n> {\n  const ethereum = yield* EthereumClient;\n  const dnsName = yield* dnsEncodeName.effect(name);\n  const ownerId = BigInt(labelhash(label));\n  const [ownerResult, stateResult, renewableResult, v1Results] = yield* Effect.all(\n    [\n      Effect.result(\n        ethereum.readContract({\n          address: v2.contracts.universalResolver,\n          abi: universalResolverV2FindOwnerAbi,\n          functionName: \"findOwner\",\n          args: [dnsName],\n        }),\n      ),\n      Effect.result(\n        ethereum.readContract({\n          address: v2.contracts.ethRegistry,\n          abi: ethRegistryV2GetStateAbi,\n          functionName: \"getState\",\n          args: [ownerId],\n        }),\n      ),\n      Effect.result(\n        ethereum.readContract({\n          address: v2.migration.ethRenewerV1,\n          abi: ethRenewerV1IsRenewableAbi,\n          functionName: \"isRenewable\",\n          args: [label],\n        }),\n      ),\n      readV1Owner(name, v1),\n    ] as const,\n    { concurrency: \"unbounded\" },\n  );\n\n  if (Result.isFailure(ownerResult)) return yield* ownerResult.failure;\n  if (!isAddressEqual(ownerResult.success, zeroAddress)) {\n    return {\n      name,\n      owner: ownerResult.success,\n      registrant: null,\n      protocol: \"v2\",\n      ownershipLevel: \"registry\",\n    };\n  }\n\n  if (Result.isFailure(stateResult)) return yield* stateResult.failure;\n  if (Result.isFailure(renewableResult)) return yield* renewableResult.failure;\n\n  const state = stateResult.success;\n  const renewable = renewableResult.success;\n\n  if (state.status === 2 || !isAddressEqual(state.latestOwner, zeroAddress)) return null;\n\n  if (state.status !== 1 && state.status !== 0) {\n    return yield* new ContractError({\n      code: \"DECODE_FAILED\",\n      message: \"Unknown ENSv2 ETH registry status\",\n      cause: state,\n    });\n  }\n\n  if (state.status === 0 && !renewable) return null;\n\n  return yield* interpretV1Owner(name, v1, v1Results);\n});\n\nconst routeOtherOwner = Effect.fn(\"routeOtherOwner\")(function* (\n  name: NormalizedName,\n  v1: EnsV1Deployment,\n  v2: EnsV2Deployment,\n): Effect.fn.Return<\n  OwnerResult | null,\n  CodecError | ContractError | ViemError,\n  EthereumClient | ReadContext\n> {\n  const ethereum = yield* EthereumClient;\n  const dnsName = yield* dnsEncodeName.effect(name);\n  const [ownerResult, parentResult, resolverResult, v1Results] = yield* Effect.all(\n    [\n      Effect.result(\n        ethereum.readContract({\n          address: v2.contracts.universalResolver,\n          abi: universalResolverV2FindOwnerAbi,\n          functionName: \"findOwner\",\n          args: [dnsName],\n        }),\n      ),\n      Effect.result(\n        ethereum.readContract({\n          address: v2.contracts.universalResolver,\n          abi: universalResolverV2FindParentRegistryAbi,\n          functionName: \"findParentRegistry\",\n          args: [dnsName],\n        }),\n      ),\n      Effect.result(\n        ethereum.readContract({\n          address: v2.contracts.universalResolver,\n          abi: universalResolverV2FindResolverAbi,\n          functionName: \"findResolver\",\n          args: [dnsName],\n        }),\n      ),\n      readV1Owner(name, v1),\n    ] as const,\n    { concurrency: \"unbounded\" },\n  );\n\n  if (Result.isFailure(ownerResult)) return yield* ownerResult.failure;\n  if (!isAddressEqual(ownerResult.success, zeroAddress)) {\n    return {\n      name,\n      owner: ownerResult.success,\n      registrant: null,\n      protocol: \"v2\",\n      ownershipLevel: \"registry\",\n    };\n  }\n\n  if (Result.isFailure(parentResult)) return yield* parentResult.failure;\n  if (Result.isFailure(resolverResult)) return yield* resolverResult.failure;\n\n  const [resolver] = resolverResult.success;\n  const usesV1Mirror = isAddressEqual(resolver, v2.migration.ensV1Resolver);\n  const hasV2ParentRegistry = !isAddressEqual(parentResult.success, zeroAddress);\n\n  if (!usesV1Mirror && hasV2ParentRegistry) return null;\n\n  return yield* interpretV1Owner(name, v1, v1Results);\n});\n\nexport const routeOwner = Effect.fn(\"routeOwner\")(function* (\n  name: NormalizedName,\n  v1: EnsV1Deployment,\n  v2: EnsV2Deployment,\n): Effect.fn.Return<\n  OwnerResult | null,\n  CodecError | ContractError | ViemError,\n  EthereumClient | ReadContext\n> {\n  const secondLevelLabel = analyzeName(name).ethSecondLevelLabel;\n\n  return secondLevelLabel === undefined\n    ? yield* routeOtherOwner(name, v1, v2)\n    : yield* routeEthOwner(name, secondLevelLabel, v1, v2);\n});\n"],"mappings":"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"}

package/dist/actions/name/get-owner/types.d.ts

@@ -0,0 +1,25 @@
+import { BlockParameters } from "../../../action/block.js";
+import { CodecError } from "../../../errors/codec-error.js";
+import { ContractError } from "../../../errors/contract-error.js";
+import { NameError } from "../../../errors/name-error.js";
+import { RpcError } from "../../../errors/rpc-error.js";
+import { Schema } from "effect";
+//#region src/actions/name/get-owner/types.d.ts
+declare const OwnershipLevel: Schema.Literals<readonly ["registry", "registrar", "nameWrapper"]>;
+type OwnershipLevel = typeof OwnershipLevel.Type;
+declare const OwnerResult: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly registrant: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly ownershipLevel: Schema.Literals<readonly ["registry", "registrar", "nameWrapper"]>;
+}>;
+type OwnerResult = typeof OwnerResult.Type;
+interface GetOwnerBaseParameters {
+  readonly name: string;
+}
+type GetOwnerParameters = GetOwnerBaseParameters & BlockParameters;
+type GetOwnerError = CodecError | ContractError | NameError | RpcError;
+//#endregion
+export { GetOwnerError, GetOwnerParameters, OwnerResult, OwnershipLevel };
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/name/get-owner/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/actions/name/get-owner/types.ts"],"mappings":";;;;;;;cAWa,gBAAc,OAAA;KAEf,wBAAwB,eAAe;cAEtC,aAAW,OAAA;;;;;;;KAQZ,qBAAqB,YAAY;UAEnC;WACC;;KAGC,qBAAqB,yBAAyB;KAE9C,gBAAgB,aAAa,gBAAgB,YAAY"}