@ensforge/core 0.0.0

package/dist/actions/migration/types.d.ts

@@ -0,0 +1,267 @@
+import { ConfirmationPolicy } from "../../config/write-options.js";
+import { EnsAction } from "../../action/action.js";
+import { BlockParameters } from "../../action/block.js";
+import { CallExecutionResult, WriteError, WriteMode, WritePlanProgress } from "../../write/types.js";
+import { EnsWriteIntent } from "../../action/write-intent.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { GetNameStateError, NameState } from "../name/get-name-state/types.js";
+import { Schema } from "effect";
+import { Account, Address, WalletClient } from "viem";
+//#region src/actions/migration/types.d.ts
+type MigrationReadError = GetNameStateError;
+type MigrationNameParameters = {
+  readonly name: string;
+} & BlockParameters;
+declare const MigrationUnsupportedReason: Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED"]>;
+type MigrationUnsupportedReason = typeof MigrationUnsupportedReason.Type;
+declare const MigrationStatus: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"not-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literals<readonly ["V2_NATIVE", "AVAILABLE"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"reserved-unwrapped">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"locked-child-pending-parent">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly parent: Schema.brand<Schema.String, "NormalizedName">;
+  readonly fuses: Schema.Int;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"reserved-wrapped-unlocked">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly fuses: Schema.Int;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"reserved-wrapped-locked">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly fuses: Schema.Int;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"mirrored-child">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly parentRegistry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly fuses: Schema.Int;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"migrated-unlocked">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"migrated-locked">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+}>]>;
+type MigrationStatus = typeof MigrationStatus.Type;
+declare const MigrationTarget: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literals<readonly ["MIGRATION_UNSUPPORTED", "MIGRATION_NOT_REQUIRED", "PARENT_NOT_MIGRATED"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly route: Schema.Literals<readonly ["unwrapped", "wrapped-unlocked", "wrapped-locked", "locked-child"]>;
+  readonly tokenContract: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly tokenId: Schema.BigInt;
+  readonly tokenStandard: Schema.Literals<readonly ["erc721", "erc1155"]>;
+  readonly receiver: Schema.declare<`0x${string}`, `0x${string}`>;
+}>]>;
+type MigrationTarget = typeof MigrationTarget.Type;
+declare const MigrationBlocker: Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED", "NAME_ALREADY_MIGRATED", "NAME_AVAILABLE", "ACCOUNT_NOT_OWNER_OR_OPERATOR", "PARENT_NOT_MIGRATED", "INVALID_WRAPPER_STATE", "FROZEN_TOKEN_APPROVAL", "TRANSFER_DISABLED"]>;
+type MigrationBlocker = typeof MigrationBlocker.Type;
+declare const MigrationEligibility: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly eligible: Schema.Boolean;
+  readonly status: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"unsupported">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly reason: Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"not-required">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly reason: Schema.Literals<readonly ["V2_NATIVE", "AVAILABLE"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"reserved-unwrapped">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"locked-child-pending-parent">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly parent: Schema.brand<Schema.String, "NormalizedName">;
+    readonly fuses: Schema.Int;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"reserved-wrapped-unlocked">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly fuses: Schema.Int;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"reserved-wrapped-locked">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly fuses: Schema.Int;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"mirrored-child">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly parentRegistry: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly fuses: Schema.Int;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"migrated-unlocked">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"migrated-locked">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>]>;
+  readonly target: Schema.Union<readonly [Schema.Struct<{
+    readonly supported: Schema.Literal<false>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly reason: Schema.Literals<readonly ["MIGRATION_UNSUPPORTED", "MIGRATION_NOT_REQUIRED", "PARENT_NOT_MIGRATED"]>;
+  }>, Schema.Struct<{
+    readonly supported: Schema.Literal<true>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly route: Schema.Literals<readonly ["unwrapped", "wrapped-unlocked", "wrapped-locked", "locked-child"]>;
+    readonly tokenContract: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly tokenId: Schema.BigInt;
+    readonly tokenStandard: Schema.Literals<readonly ["erc721", "erc1155"]>;
+    readonly receiver: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>]>;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly owner: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly authorized: Schema.Boolean;
+  readonly blockers: Schema.$Array<Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED", "NAME_ALREADY_MIGRATED", "NAME_AVAILABLE", "ACCOUNT_NOT_OWNER_OR_OPERATOR", "PARENT_NOT_MIGRATED", "INVALID_WRAPPER_STATE", "FROZEN_TOKEN_APPROVAL", "TRANSFER_DISABLED"]>>;
+}>;
+type MigrationEligibility = typeof MigrationEligibility.Type;
+declare const MigrationPlan: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly blockers: Schema.$Array<Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED", "NAME_ALREADY_MIGRATED", "NAME_AVAILABLE", "ACCOUNT_NOT_OWNER_OR_OPERATOR", "PARENT_NOT_MIGRATED", "INVALID_WRAPPER_STATE", "FROZEN_TOKEN_APPROVAL", "TRANSFER_DISABLED"]>>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"not-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literals<readonly ["V2_NATIVE", "AVAILABLE", "ALREADY_MIGRATED"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"blocked">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly blockers: Schema.$Array<Schema.Literals<readonly ["ENSV2_NOT_ACTIVE", "NOT_ETH_NAME", "NAME_NOT_RESERVED", "NAME_ALREADY_MIGRATED", "NAME_AVAILABLE", "ACCOUNT_NOT_OWNER_OR_OPERATOR", "PARENT_NOT_MIGRATED", "INVALID_WRAPPER_STATE", "FROZEN_TOKEN_APPROVAL", "TRANSFER_DISABLED"]>>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"authorization-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly target: Schema.Union<readonly [Schema.Struct<{
+    readonly supported: Schema.Literal<false>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly reason: Schema.Literals<readonly ["MIGRATION_UNSUPPORTED", "MIGRATION_NOT_REQUIRED", "PARENT_NOT_MIGRATED"]>;
+  }>, Schema.Struct<{
+    readonly supported: Schema.Literal<true>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly route: Schema.Literals<readonly ["unwrapped", "wrapped-unlocked", "wrapped-locked", "locked-child"]>;
+    readonly tokenContract: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly tokenId: Schema.BigInt;
+    readonly tokenStandard: Schema.Literals<readonly ["erc721", "erc1155"]>;
+    readonly receiver: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"ready">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly target: Schema.Union<readonly [Schema.Struct<{
+    readonly supported: Schema.Literal<false>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly reason: Schema.Literals<readonly ["MIGRATION_UNSUPPORTED", "MIGRATION_NOT_REQUIRED", "PARENT_NOT_MIGRATED"]>;
+  }>, Schema.Struct<{
+    readonly supported: Schema.Literal<true>;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly route: Schema.Literals<readonly ["unwrapped", "wrapped-unlocked", "wrapped-locked", "locked-child"]>;
+    readonly tokenContract: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly tokenId: Schema.BigInt;
+    readonly tokenStandard: Schema.Literals<readonly ["erc721", "erc1155"]>;
+    readonly receiver: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>]>;
+  readonly migration: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly resolver: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly subregistry: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>;
+  readonly warnings: Schema.$Array<Schema.Literals<readonly ["SUBREGISTRY_IGNORED_FOR_LOCKED_NAME", "RESOLVER_MAY_BE_PRESERVED"]>>;
+}>]>;
+type MigrationPlan = typeof MigrationPlan.Type;
+interface MigrationValues {
+  readonly owner?: EthereumAddress;
+  readonly resolver?: EthereumAddress;
+  readonly subregistry?: EthereumAddress;
+}
+interface ApproveMigrationParameters {
+  readonly name: string;
+  readonly approved?: boolean;
+}
+interface MigrateNameCallParameters extends MigrationValues {
+  readonly name: string;
+}
+interface MigrationWalletParameters {
+  readonly walletClient?: WalletClient;
+  readonly account?: Account | Address;
+  readonly mode?: WriteMode;
+  readonly confirmation?: ConfirmationPolicy;
+}
+interface MigrationNameProgress {
+  readonly status: "completed" | "partial";
+  readonly name: string;
+  readonly route: Extract<MigrationTarget, {
+    readonly supported: true;
+  }>["route"];
+  readonly steps: ReadonlyArray<{
+    readonly name: string;
+    readonly route: Extract<MigrationTarget, {
+      readonly supported: true;
+    }>["route"];
+  }>;
+  readonly write: WritePlanProgress;
+  readonly finalState: NameState | null;
+}
+type MigrateNameResult = MigrationNameProgress | {
+  readonly status: "not-required";
+  readonly name: string;
+  readonly reason: "V2_NATIVE" | "AVAILABLE" | "ALREADY_MIGRATED";
+  readonly write: null;
+  readonly finalState: NameState;
+};
+interface MigrateNameParameters extends MigrateNameCallParameters, MigrationWalletParameters {
+  readonly migrateParent?: boolean;
+  readonly resume?: MigrationNameProgress;
+}
+interface MigrateNameAction extends EnsAction<MigrateNameParameters, MigrateNameResult, WriteError> {
+  readonly call: (parameters: MigrateNameCallParameters) => EnsWriteIntent<CallExecutionResult, WriteError>;
+}
+interface MigrationBatchApproval {
+  readonly token: EthereumAddress;
+  readonly owner: EthereumAddress;
+  readonly operator: EthereumAddress;
+  readonly required: boolean;
+}
+interface MigrationBatchEntry {
+  readonly name: string;
+  readonly status: "completed" | "partial" | "not-required";
+  readonly route: Extract<MigrationTarget, {
+    readonly supported: true;
+  }>["route"] | null;
+  readonly finalState: NameState | null;
+}
+interface MigrationBatchProgress {
+  readonly status: "completed" | "partial";
+  readonly strategy: "helper" | "sequential";
+  readonly migrations: ReadonlyArray<MigrationBatchEntry>;
+  readonly approvals: ReadonlyArray<MigrationBatchApproval>;
+  readonly steps: ReadonlyArray<{
+    readonly name: string;
+    readonly route: Extract<MigrationTarget, {
+      readonly supported: true;
+    }>["route"];
+  }>;
+  readonly write: WritePlanProgress;
+}
+interface MigrateNamesParameters extends MigrationWalletParameters {
+  readonly migrations: ReadonlyArray<MigrateNameCallParameters>;
+  readonly resume?: MigrationBatchProgress;
+}
+type ApproveMigrationResult = CallExecutionResult;
+type MigrationWriteError = WriteError;
+//#endregion
+export { ApproveMigrationParameters, ApproveMigrationResult, MigrateNameAction, MigrateNameCallParameters, MigrateNameParameters, MigrateNameResult, MigrateNamesParameters, MigrationBatchApproval, MigrationBatchEntry, MigrationBatchProgress, MigrationBlocker, MigrationEligibility, MigrationNameParameters, MigrationNameProgress, MigrationPlan, MigrationReadError, MigrationStatus, MigrationTarget, MigrationUnsupportedReason, MigrationValues, MigrationWalletParameters, MigrationWriteError };
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/migration/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/actions/migration/types.ts"],"mappings":";;;;;;;;;;KAmBY,qBAAqB;KACrB;WAAqC;IAAiB;cAErD,4BAA0B,OAAA;KAK3B,oCAAoC,2BAA2B;cAE9D,iBAAe,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyChB,yBAAyB,gBAAgB;cAExC,iBAAe,OAAA,gBAAA,OAAA;;;;;;;;;;;;;KAoBhB,yBAAyB,gBAAgB;cAExC,kBAAgB,OAAA;KAYjB,0BAA0B,iBAAiB;cAE1C,sBAAoB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUrB,8BAA8B,qBAAqB;cAElD,eAAa,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCd,uBAAuB,cAAc;UAEhC;WACN,QAAQ;WACR,WAAW;WACX,cAAc;;UAGR;WACN;WACA;;UAGM,kCAAkC;WACxC;;UAGM;WACN,eAAe;WACf,UAAU,UAAU;WACpB,OAAO;WACP,eAAe;;UAGT;WACN;WACA;WACA,OAAO,QAAQ;aAA4B;;WAC3C,OAAO;aACL;aACA,OAAO,QAAQ;eAA4B;;;WAE7C,OAAO;WACP,YAAY;;KAGX,oBACR;WAEW;WACA;WACA;WACA;WACA,YAAY;;UAGV,8BACP,2BAA2B;WAC1B;WACA,SAAS;;UAGH,0BAA0B,UACzC,uBACA,mBACA;WAES,OACP,YAAY,8BACT,eAAe,qBAAqB;;UAG1B;WACN,OAAO;WACP,OAAO;WACP,UAAU;WACV;;UAGM;WACN;WACA;WACA,OAAO,QAAQ;aAA4B;;WAC3C,YAAY;;UAGN;WACN;WACA;WACA,YAAY,cAAc;WAC1B,WAAW,cAAc;WACzB,OAAO;aACL;aACA,OAAO,QAAQ;eAA4B;;;WAE7C,OAAO;;UAGD,+BAA+B;WACrC,YAAY,cAAc;WAC1B,SAAS;;KAGR,yBAAyB;KACzB,sBAAsB"}

package/dist/actions/migration/types.js

@@ -0,0 +1,145 @@
+import { NormalizedName } from "../../schemas/name.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { Schema } from "effect";
+
+//#region src/actions/migration/types.ts
+const MigrationUnsupportedReason = Schema.Literals([
+	"ENSV2_NOT_ACTIVE",
+	"NOT_ETH_NAME",
+	"NAME_NOT_RESERVED"
+]);
+const MigrationStatus = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("unsupported"),
+		name: NormalizedName,
+		reason: MigrationUnsupportedReason
+	}),
+	Schema.Struct({
+		status: Schema.Literal("not-required"),
+		name: NormalizedName,
+		reason: Schema.Literals(["V2_NATIVE", "AVAILABLE"])
+	}),
+	Schema.Struct({
+		status: Schema.Literal("reserved-unwrapped"),
+		name: NormalizedName
+	}),
+	Schema.Struct({
+		status: Schema.Literal("locked-child-pending-parent"),
+		name: NormalizedName,
+		parent: NormalizedName,
+		fuses: Schema.Int
+	}),
+	Schema.Struct({
+		status: Schema.Literal("reserved-wrapped-unlocked"),
+		name: NormalizedName,
+		fuses: Schema.Int
+	}),
+	Schema.Struct({
+		status: Schema.Literal("reserved-wrapped-locked"),
+		name: NormalizedName,
+		fuses: Schema.Int
+	}),
+	Schema.Struct({
+		status: Schema.Literal("mirrored-child"),
+		name: NormalizedName,
+		parentRegistry: EthereumAddress,
+		fuses: Schema.Int
+	}),
+	Schema.Struct({
+		status: Schema.Literal("migrated-unlocked"),
+		name: NormalizedName
+	}),
+	Schema.Struct({
+		status: Schema.Literal("migrated-locked"),
+		name: NormalizedName,
+		registry: EthereumAddress
+	})
+]);
+const MigrationTarget = Schema.Union([Schema.Struct({
+	supported: Schema.Literal(false),
+	name: NormalizedName,
+	reason: Schema.Literals([
+		"MIGRATION_UNSUPPORTED",
+		"MIGRATION_NOT_REQUIRED",
+		"PARENT_NOT_MIGRATED"
+	])
+}), Schema.Struct({
+	supported: Schema.Literal(true),
+	name: NormalizedName,
+	route: Schema.Literals([
+		"unwrapped",
+		"wrapped-unlocked",
+		"wrapped-locked",
+		"locked-child"
+	]),
+	tokenContract: EthereumAddress,
+	tokenId: Schema.BigInt,
+	tokenStandard: Schema.Literals(["erc721", "erc1155"]),
+	receiver: EthereumAddress
+})]);
+const MigrationBlocker = Schema.Literals([
+	"ENSV2_NOT_ACTIVE",
+	"NOT_ETH_NAME",
+	"NAME_NOT_RESERVED",
+	"NAME_ALREADY_MIGRATED",
+	"NAME_AVAILABLE",
+	"ACCOUNT_NOT_OWNER_OR_OPERATOR",
+	"PARENT_NOT_MIGRATED",
+	"INVALID_WRAPPER_STATE",
+	"FROZEN_TOKEN_APPROVAL",
+	"TRANSFER_DISABLED"
+]);
+const MigrationEligibility = Schema.Struct({
+	name: NormalizedName,
+	eligible: Schema.Boolean,
+	status: MigrationStatus,
+	target: MigrationTarget,
+	account: EthereumAddress,
+	owner: Schema.NullOr(EthereumAddress),
+	authorized: Schema.Boolean,
+	blockers: Schema.Array(MigrationBlocker)
+});
+const MigrationPlan = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("unsupported"),
+		name: NormalizedName,
+		blockers: Schema.Array(MigrationBlocker)
+	}),
+	Schema.Struct({
+		status: Schema.Literal("not-required"),
+		name: NormalizedName,
+		reason: Schema.Literals([
+			"V2_NATIVE",
+			"AVAILABLE",
+			"ALREADY_MIGRATED"
+		])
+	}),
+	Schema.Struct({
+		status: Schema.Literal("blocked"),
+		name: NormalizedName,
+		blockers: Schema.Array(MigrationBlocker)
+	}),
+	Schema.Struct({
+		status: Schema.Literal("authorization-required"),
+		name: NormalizedName,
+		account: EthereumAddress,
+		owner: EthereumAddress,
+		target: MigrationTarget
+	}),
+	Schema.Struct({
+		status: Schema.Literal("ready"),
+		name: NormalizedName,
+		target: MigrationTarget,
+		migration: Schema.Struct({
+			label: Schema.String,
+			owner: EthereumAddress,
+			resolver: EthereumAddress,
+			subregistry: EthereumAddress
+		}),
+		warnings: Schema.Array(Schema.Literals(["SUBREGISTRY_IGNORED_FOR_LOCKED_NAME", "RESOLVER_MAY_BE_PRESERVED"]))
+	})
+]);
+
+//#endregion
+export { MigrationBlocker, MigrationEligibility, MigrationPlan, MigrationStatus, MigrationTarget, MigrationUnsupportedReason };
+//# sourceMappingURL=types.js.map

package/dist/actions/migration/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/actions/migration/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport type { Account, Address, WalletClient } from \"viem\";\n\nimport type { EnsAction } from \"../../action/action.js\";\nimport type { BlockParameters } from \"../../action/block.js\";\nimport type { EnsWriteIntent } from \"../../action/write-intent.js\";\nimport { EthereumAddress } from \"../../schemas/identity.js\";\nimport { NormalizedName } from \"../../schemas/name.js\";\nimport type {\n  CallExecutionResult,\n  ConfirmationPolicy,\n  WriteError,\n  WriteMode,\n  WritePlanProgress,\n} from \"../../write/types.js\";\nimport type { GetNameStateError } from \"../name/get-name-state/types.js\";\nimport type { NameState } from \"../name/get-name-state/types.js\";\n\nexport type MigrationReadError = GetNameStateError;\nexport type MigrationNameParameters = { readonly name: string } & BlockParameters;\n\nexport const MigrationUnsupportedReason = Schema.Literals([\n  \"ENSV2_NOT_ACTIVE\",\n  \"NOT_ETH_NAME\",\n  \"NAME_NOT_RESERVED\",\n]);\nexport type MigrationUnsupportedReason = typeof MigrationUnsupportedReason.Type;\n\nexport const MigrationStatus = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"unsupported\"),\n    name: NormalizedName,\n    reason: MigrationUnsupportedReason,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"not-required\"),\n    name: NormalizedName,\n    reason: Schema.Literals([\"V2_NATIVE\", \"AVAILABLE\"]),\n  }),\n  Schema.Struct({ status: Schema.Literal(\"reserved-unwrapped\"), name: NormalizedName }),\n  Schema.Struct({\n    status: Schema.Literal(\"locked-child-pending-parent\"),\n    name: NormalizedName,\n    parent: NormalizedName,\n    fuses: Schema.Int,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"reserved-wrapped-unlocked\"),\n    name: NormalizedName,\n    fuses: Schema.Int,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"reserved-wrapped-locked\"),\n    name: NormalizedName,\n    fuses: Schema.Int,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"mirrored-child\"),\n    name: NormalizedName,\n    parentRegistry: EthereumAddress,\n    fuses: Schema.Int,\n  }),\n  Schema.Struct({ status: Schema.Literal(\"migrated-unlocked\"), name: NormalizedName }),\n  Schema.Struct({\n    status: Schema.Literal(\"migrated-locked\"),\n    name: NormalizedName,\n    registry: EthereumAddress,\n  }),\n]);\nexport type MigrationStatus = typeof MigrationStatus.Type;\n\nexport const MigrationTarget = Schema.Union([\n  Schema.Struct({\n    supported: Schema.Literal(false),\n    name: NormalizedName,\n    reason: Schema.Literals([\n      \"MIGRATION_UNSUPPORTED\",\n      \"MIGRATION_NOT_REQUIRED\",\n      \"PARENT_NOT_MIGRATED\",\n    ]),\n  }),\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    name: NormalizedName,\n    route: Schema.Literals([\"unwrapped\", \"wrapped-unlocked\", \"wrapped-locked\", \"locked-child\"]),\n    tokenContract: EthereumAddress,\n    tokenId: Schema.BigInt,\n    tokenStandard: Schema.Literals([\"erc721\", \"erc1155\"]),\n    receiver: EthereumAddress,\n  }),\n]);\nexport type MigrationTarget = typeof MigrationTarget.Type;\n\nexport const MigrationBlocker = Schema.Literals([\n  \"ENSV2_NOT_ACTIVE\",\n  \"NOT_ETH_NAME\",\n  \"NAME_NOT_RESERVED\",\n  \"NAME_ALREADY_MIGRATED\",\n  \"NAME_AVAILABLE\",\n  \"ACCOUNT_NOT_OWNER_OR_OPERATOR\",\n  \"PARENT_NOT_MIGRATED\",\n  \"INVALID_WRAPPER_STATE\",\n  \"FROZEN_TOKEN_APPROVAL\",\n  \"TRANSFER_DISABLED\",\n]);\nexport type MigrationBlocker = typeof MigrationBlocker.Type;\n\nexport const MigrationEligibility = Schema.Struct({\n  name: NormalizedName,\n  eligible: Schema.Boolean,\n  status: MigrationStatus,\n  target: MigrationTarget,\n  account: EthereumAddress,\n  owner: Schema.NullOr(EthereumAddress),\n  authorized: Schema.Boolean,\n  blockers: Schema.Array(MigrationBlocker),\n});\nexport type MigrationEligibility = typeof MigrationEligibility.Type;\n\nexport const MigrationPlan = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"unsupported\"),\n    name: NormalizedName,\n    blockers: Schema.Array(MigrationBlocker),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"not-required\"),\n    name: NormalizedName,\n    reason: Schema.Literals([\"V2_NATIVE\", \"AVAILABLE\", \"ALREADY_MIGRATED\"]),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"blocked\"),\n    name: NormalizedName,\n    blockers: Schema.Array(MigrationBlocker),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"authorization-required\"),\n    name: NormalizedName,\n    account: EthereumAddress,\n    owner: EthereumAddress,\n    target: MigrationTarget,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"ready\"),\n    name: NormalizedName,\n    target: MigrationTarget,\n    migration: Schema.Struct({\n      label: Schema.String,\n      owner: EthereumAddress,\n      resolver: EthereumAddress,\n      subregistry: EthereumAddress,\n    }),\n    warnings: Schema.Array(\n      Schema.Literals([\"SUBREGISTRY_IGNORED_FOR_LOCKED_NAME\", \"RESOLVER_MAY_BE_PRESERVED\"]),\n    ),\n  }),\n]);\nexport type MigrationPlan = typeof MigrationPlan.Type;\n\nexport interface MigrationValues {\n  readonly owner?: EthereumAddress;\n  readonly resolver?: EthereumAddress;\n  readonly subregistry?: EthereumAddress;\n}\n\nexport interface ApproveMigrationParameters {\n  readonly name: string;\n  readonly approved?: boolean;\n}\n\nexport interface MigrateNameCallParameters extends MigrationValues {\n  readonly name: string;\n}\n\nexport interface MigrationWalletParameters {\n  readonly walletClient?: WalletClient;\n  readonly account?: Account | Address;\n  readonly mode?: WriteMode;\n  readonly confirmation?: ConfirmationPolicy;\n}\n\nexport interface MigrationNameProgress {\n  readonly status: \"completed\" | \"partial\";\n  readonly name: string;\n  readonly route: Extract<MigrationTarget, { readonly supported: true }>[\"route\"];\n  readonly steps: ReadonlyArray<{\n    readonly name: string;\n    readonly route: Extract<MigrationTarget, { readonly supported: true }>[\"route\"];\n  }>;\n  readonly write: WritePlanProgress;\n  readonly finalState: NameState | null;\n}\n\nexport type MigrateNameResult =\n  | MigrationNameProgress\n  | {\n      readonly status: \"not-required\";\n      readonly name: string;\n      readonly reason: \"V2_NATIVE\" | \"AVAILABLE\" | \"ALREADY_MIGRATED\";\n      readonly write: null;\n      readonly finalState: NameState;\n    };\n\nexport interface MigrateNameParameters\n  extends MigrateNameCallParameters, MigrationWalletParameters {\n  readonly migrateParent?: boolean;\n  readonly resume?: MigrationNameProgress;\n}\n\nexport interface MigrateNameAction extends EnsAction<\n  MigrateNameParameters,\n  MigrateNameResult,\n  WriteError\n> {\n  readonly call: (\n    parameters: MigrateNameCallParameters,\n  ) => EnsWriteIntent<CallExecutionResult, WriteError>;\n}\n\nexport interface MigrationBatchApproval {\n  readonly token: EthereumAddress;\n  readonly owner: EthereumAddress;\n  readonly operator: EthereumAddress;\n  readonly required: boolean;\n}\n\nexport interface MigrationBatchEntry {\n  readonly name: string;\n  readonly status: \"completed\" | \"partial\" | \"not-required\";\n  readonly route: Extract<MigrationTarget, { readonly supported: true }>[\"route\"] | null;\n  readonly finalState: NameState | null;\n}\n\nexport interface MigrationBatchProgress {\n  readonly status: \"completed\" | \"partial\";\n  readonly strategy: \"helper\" | \"sequential\";\n  readonly migrations: ReadonlyArray<MigrationBatchEntry>;\n  readonly approvals: ReadonlyArray<MigrationBatchApproval>;\n  readonly steps: ReadonlyArray<{\n    readonly name: string;\n    readonly route: Extract<MigrationTarget, { readonly supported: true }>[\"route\"];\n  }>;\n  readonly write: WritePlanProgress;\n}\n\nexport interface MigrateNamesParameters extends MigrationWalletParameters {\n  readonly migrations: ReadonlyArray<MigrateNameCallParameters>;\n  readonly resume?: MigrationBatchProgress;\n}\n\nexport type ApproveMigrationResult = CallExecutionResult;\nexport type MigrationWriteError = WriteError;\n"],"mappings":"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"}

package/dist/actions/name/get-canonical-resource/index.d.ts

@@ -0,0 +1,9 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { GetNameStateError, GetNameStateParameters } from "../get-name-state/types.js";
+import "../../../index.js";
+//#region src/actions/name/get-canonical-resource/index.d.ts
+declare const getCanonicalResource: EnsReadAction<GetNameStateParameters, bigint | null, GetNameStateError>;
+type GetCanonicalResourceResult = bigint | null;
+//#endregion
+export { type GetNameStateError as GetCanonicalResourceError, type GetNameStateParameters as GetCanonicalResourceParameters, GetCanonicalResourceResult, getCanonicalResource };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/name/get-canonical-resource/index.ts"],"mappings":";;;;cA2Ba,sBAAoB,cAAA,uCAAA;KAUrB"}

package/dist/actions/name/get-canonical-resource/index.js

@@ -0,0 +1,20 @@
+import { defineReadAction } from "../../../action/read-request.js";
+import { executeRead } from "../../../internal/read/execute-read.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { readNameRoute } from "../../../internal/name/name-route.js";
+import { Effect } from "effect";
+
+//#region src/actions/name/get-canonical-resource/index.ts
+const getCanonicalResourceEffect = Effect.fn("ensforge.getCanonicalResource")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, readNameRoute(name).pipe(Effect.map((route) => {
+		if (route.kind === "v1") return null;
+		if (route.kind === "available" && route.state.expiry === 0n) return null;
+		return route.state.resource;
+	})));
+});
+const getCanonicalResource = defineReadAction(getCanonicalResourceEffect);
+
+//#endregion
+export { getCanonicalResource };
+//# sourceMappingURL=index.js.map

package/dist/actions/name/get-canonical-resource/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/name/get-canonical-resource/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { defineReadAction } from \"../../../action/read-request.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { readNameRoute } from \"../../../internal/name/name-route.js\";\nimport { executeRead } from \"../../../internal/read/execute-read.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { GetNameStateError, GetNameStateParameters } from \"../get-name-state/types.js\";\n\nconst getCanonicalResourceEffect = Effect.fn(\"ensforge.getCanonicalResource\")(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    readNameRoute(name).pipe(\n      Effect.map((route) => {\n        if (route.kind === \"v1\") return null;\n        if (route.kind === \"available\" && route.state.expiry === 0n) return null;\n        return route.state.resource;\n      }),\n    ),\n  );\n});\n\nexport const getCanonicalResource = defineReadAction<\n  GetNameStateParameters,\n  bigint | null,\n  GetNameStateError\n>(getCanonicalResourceEffect);\n\nexport type {\n  GetNameStateError as GetCanonicalResourceError,\n  GetNameStateParameters as GetCanonicalResourceParameters,\n} from \"../get-name-state/types.js\";\nexport type GetCanonicalResourceResult = bigint | null;\n"],"mappings":";;;;;;;AASA,MAAM,6BAA6B,OAAO,GAAG,+BAA+B,CAAC,CAAC,WAC5E,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,OAAO,OAAO,YACZ,QACA,YACA,cAAc,IAAI,CAAC,CAAC,KAClB,OAAO,KAAK,UAAU;EACpB,IAAI,MAAM,SAAS,MAAM,OAAO;EAChC,IAAI,MAAM,SAAS,eAAe,MAAM,MAAM,WAAW,IAAI,OAAO;EACpE,OAAO,MAAM,MAAM;CACrB,CAAC,CACH,CACF;AACF,CAAC;AAED,MAAa,uBAAuB,iBAIlC,0BAA0B"}

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

@@ -0,0 +1,15 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { ExpiryResult, ExpirySource, GetExpiryError, GetExpiryParameters } from "./types.js";
+import "../../../index.js";
+//#region src/actions/name/get-expiry/index.d.ts
+declare const getExpiry: EnsReadAction<GetExpiryParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly expiry: bigint;
+  readonly gracePeriod: bigint;
+  readonly gracePeriodEnd: bigint;
+  readonly protocol: "v1" | "v2";
+  readonly source: "registry" | "nameWrapper" | "baseRegistrar";
+} | null, GetExpiryError>;
+//#endregion
+export { ExpiryResult, ExpirySource, type GetExpiryError, type GetExpiryParameters, getExpiry };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/name/get-expiry/index.ts"],"mappings":";;;;cA0Ca,WAEZ,cAFqB;;;;;;;UAErB"}

package/dist/actions/name/get-expiry/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 { getExpiryV1 } from "./v1.js";
+import { routeExpiry } from "./route.js";
+import { getExpiryV2 } from "./v2.js";
+import { ExpiryResult, ExpirySource } from "./types.js";
+import { Effect } from "effect";
+
+//#region src/actions/name/get-expiry/index.ts
+const getExpiryWithServices = Effect.fn("getExpiryWithServices")(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* getExpiryV1(name, deployment.profile.v1);
+		case "v2": {
+			const v1 = deployment.profile.v1;
+			return v1 === void 0 ? yield* getExpiryV2(name, deployment.profile.v2) : yield* routeExpiry(name, v1, deployment.profile.v2);
+		}
+	}
+});
+const getExpiryEffect = Effect.fn("ensforge.getExpiry")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, getExpiryWithServices(name));
+});
+const getExpiry = defineReadAction(getExpiryEffect);
+
+//#endregion
+export { ExpiryResult, ExpirySource, getExpiry };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/name/get-expiry/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 { routeExpiry } from \"./route.js\";\nimport type { ExpiryResult, GetExpiryError, GetExpiryParameters } from \"./types.js\";\nimport { getExpiryV1 } from \"./v1.js\";\nimport { getExpiryV2 } from \"./v2.js\";\n\nconst getExpiryWithServices = Effect.fn(\"getExpiryWithServices\")(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* getExpiryV1(name, deployment.profile.v1);\n    case \"v2\": {\n      const v1 = deployment.profile.v1;\n      return v1 === undefined\n        ? yield* getExpiryV2(name, deployment.profile.v2)\n        : yield* routeExpiry(name, v1, deployment.profile.v2);\n    }\n  }\n});\n\nconst getExpiryEffect = Effect.fn(\"ensforge.getExpiry\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetExpiryParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n  return yield* executeRead(config, parameters, getExpiryWithServices(name));\n});\n\nexport const getExpiry = defineReadAction<GetExpiryParameters, ExpiryResult | null, GetExpiryError>(\n  getExpiryEffect,\n);\n\nexport {\n  ExpiryResult,\n  ExpirySource,\n  type GetExpiryError,\n  type GetExpiryParameters,\n} from \"./types.js\";\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,wBAAwB,OAAO,GAAG,uBAAuB,CAAC,CAAC,WAC/D,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,YAAY,MAAM,WAAW,QAAQ,EAAE;EACvD,KAAK,MAAM;GACT,MAAM,KAAK,WAAW,QAAQ;GAC9B,OAAO,OAAO,SACV,OAAO,YAAY,MAAM,WAAW,QAAQ,EAAE,IAC9C,OAAO,YAAY,MAAM,IAAI,WAAW,QAAQ,EAAE;EACxD;CACF;AACF,CAAC;AAED,MAAM,kBAAkB,OAAO,GAAG,oBAAoB,CAAC,CAAC,WACtD,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,OAAO,OAAO,YAAY,QAAQ,YAAY,sBAAsB,IAAI,CAAC;AAC3E,CAAC;AAED,MAAa,YAAY,iBACvB,eACF"}