@ensforge/core 0.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/actions/capabilities/types.ts"],"mappings":";;;;;KASY,kBAAkB;KAElB;WAAsC;IAAiB;KACvD,8BAA8B;WAC/B,SAAS;;cAGP,sBAAoB,OAAA;;;;;;;;;;;;;;;KAerB,8BAA8B,qBAAqB;cAElD,kBAAgB,OAAA;;;;;;;;;;;;KAYjB,0BAA0B,iBAAiB;cAE1C,sBAAoB,OAAA;;;;;;;;;;;;;;;;;;;;KASrB,8BAA8B,qBAAqB;cAQlD,qBAAmB,OAAA,gBAAA,OAAA;;;;;;;;;;;;KAWpB,6BAA6B,oBAAoB;cAEhD,wBAAsB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;KAYvB,gCAAgC,uBAAuB;cAEtD,qBAAmB,OAAA,gBAAA,OAAA;;;;;;;;;;;;KAWpB,6BAA6B,oBAAoB;cAEhD,wBAAsB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;KAYvB,gCAAgC,uBAAuB;cAEtD,iBAAe,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAchB,yBAAyB,gBAAgB;cAExC,mBAAiB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;KAQlB,2BAA2B,kBAAkB;cAE5C,gBAAc,OAAA,gBAAA,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACf,wBAAwB,eAAe;cAEtC,wBAAsB,OAAA;;;;;;KAMvB,gCAAgC,uBAAuB;cAEtD,wBAAsB,OAAA;;;;;;;;;;KAKvB,gCAAgC,uBAAuB;cAEtD,qBAAmB,OAAA,gBAAA,OAAA;;;;;;;;;;;;KAepB,6BAA6B,oBAAoB;cAEhD,gCAA8B,OAAA,gBAAA,OAAA;;;;;;;;;;;;KAe/B,wCAAwC,+BAA+B;cAEtE,0BAAwB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoCzB,kCAAkC,yBAAyB;cAE1D,0BAAwB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;KAmBzB,kCAAkC,yBAAyB;cAE1D,qBAAmB,OAAA;KASpB,6BAA6B,oBAAoB;cAEhD,uBAAqB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KActB,+BAA+B,sBAAsB;cAEpD,kBAAgB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOjB,0BAA0B,iBAAiB;cAE1C,yBAAuB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMxB,iCAAiC,wBAAwB;cAoBxD,aAAW,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACZ,qBAAqB,YAAY;cAUhC,6BAA2B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO5B,qCAAqC,4BAA4B;cAEhE,kBAAgB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAcjB,0BAA0B,iBAAiB"}

package/dist/actions/capabilities/types.js

@@ -0,0 +1,320 @@
+import { NormalizedName } from "../../schemas/name.js";
+import { Namehash } from "../../schemas/hash.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { InterfaceId } from "../../schemas/records.js";
+import { Schema } from "effect";
+
+//#region src/actions/capabilities/types.ts
+const RegistryCapabilities = Schema.Struct({
+	address: EthereumAddress,
+	protocol: Schema.Literals(["v1", "v2"]),
+	kind: Schema.Literals([
+		"registry",
+		"name-wrapper",
+		"permissioned-registry",
+		"wrapper-registry"
+	]),
+	owned: Schema.Boolean,
+	permissioned: Schema.Boolean,
+	temporal: Schema.Boolean,
+	tokenized: Schema.Boolean,
+	wrapped: Schema.Boolean,
+	setOwner: Schema.Boolean,
+	setResolver: Schema.Boolean,
+	createSubname: Schema.Boolean,
+	transfer: Schema.Boolean,
+	setExpiry: Schema.Boolean
+});
+const ResolverProfiles = Schema.Struct({
+	address: Schema.Boolean,
+	text: Schema.Boolean,
+	contentHash: Schema.Boolean,
+	abi: Schema.Boolean,
+	pubkey: Schema.Boolean,
+	interface: Schema.Boolean,
+	name: Schema.Boolean,
+	data: Schema.Boolean,
+	dnsRecord: Schema.Boolean,
+	dnsZone: Schema.Boolean
+});
+const ResolverCapabilities = Schema.Struct({
+	address: Schema.NullOr(EthereumAddress),
+	node: Namehash,
+	inherited: Schema.Boolean,
+	extended: Schema.Boolean,
+	permissioned: Schema.Boolean,
+	authorization: Schema.Literals([
+		"none",
+		"owner-delegate",
+		"role",
+		"unknown"
+	]),
+	profiles: ResolverProfiles
+});
+const UnsupportedRolesResult = Schema.Struct({
+	supported: Schema.Literal(false),
+	protocol: Schema.Literals(["v1", "v2"]),
+	reason: Schema.Literals(["ROLE_BASED_PERMISSIONS_UNSUPPORTED", "RESOLVER_NOT_FOUND"])
+});
+const RegistryRolesResult = Schema.Union([UnsupportedRolesResult, Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literal("v2"),
+	registry: EthereumAddress,
+	resource: Schema.BigInt,
+	account: EthereumAddress,
+	roles: Schema.BigInt
+})]);
+const HasRegistryRolesResult = Schema.Union([UnsupportedRolesResult, Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literal("v2"),
+	registry: EthereumAddress,
+	resource: Schema.BigInt,
+	account: EthereumAddress,
+	roles: Schema.BigInt,
+	authorized: Schema.Boolean
+})]);
+const ResolverRolesResult = Schema.Union([UnsupportedRolesResult, Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literal("v2"),
+	resolver: EthereumAddress,
+	resource: Schema.BigInt,
+	account: EthereumAddress,
+	roles: Schema.BigInt
+})]);
+const HasResolverRolesResult = Schema.Union([UnsupportedRolesResult, Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literal("v2"),
+	resolver: EthereumAddress,
+	resource: Schema.BigInt,
+	account: EthereumAddress,
+	roles: Schema.BigInt,
+	authorized: Schema.Boolean
+})]);
+const RecordOperation = Schema.Union([
+	Schema.Struct({
+		type: Schema.Literal("address"),
+		coinType: Schema.BigInt
+	}),
+	Schema.Struct({
+		type: Schema.Literal("text"),
+		key: Schema.String
+	}),
+	Schema.Struct({ type: Schema.Literal("contentHash") }),
+	Schema.Struct({ type: Schema.Literal("pubkey") }),
+	Schema.Struct({
+		type: Schema.Literal("abi"),
+		contentType: Schema.optional(Schema.BigInt)
+	}),
+	Schema.Struct({
+		type: Schema.Literal("interface"),
+		interfaceId: Schema.optional(InterfaceId)
+	}),
+	Schema.Struct({ type: Schema.Literal("name") }),
+	Schema.Struct({
+		type: Schema.Literal("data"),
+		key: Schema.String
+	}),
+	Schema.Struct({ type: Schema.Literal("alias") }),
+	Schema.Struct({ type: Schema.Literal("dnsRecord") }),
+	Schema.Struct({ type: Schema.Literal("dnsZone") }),
+	Schema.Struct({ type: Schema.Literal("clear") })
+]);
+const RegistryOperation = Schema.Union([
+	Schema.Struct({ type: Schema.Literal("setOwner") }),
+	Schema.Struct({ type: Schema.Literal("setTtl") }),
+	Schema.Struct({ type: Schema.Literal("setResolver") }),
+	Schema.Struct({ type: Schema.Literal("createSubname") }),
+	Schema.Struct({ type: Schema.Literal("transfer") }),
+	Schema.Struct({ type: Schema.Literal("setExpiry") })
+]);
+const WriteOperation = Schema.Union([RecordOperation, RegistryOperation]);
+const OperatorApprovalTarget = Schema.Struct({
+	kind: Schema.Literals([
+		"registry",
+		"registrar",
+		"wrapper",
+		"resolver"
+	]),
+	address: EthereumAddress,
+	supported: Schema.Boolean,
+	approved: Schema.Boolean
+});
+const OperatorApprovalResult = Schema.Struct({
+	owner: EthereumAddress,
+	operator: EthereumAddress,
+	targets: Schema.Array(OperatorApprovalTarget)
+});
+const TokenApprovalResult = Schema.Union([Schema.Struct({
+	supported: Schema.Literal(false),
+	protocol: Schema.Literals(["v1", "v2"]),
+	reason: Schema.Literals(["PER_TOKEN_APPROVAL_UNSUPPORTED", "NAME_NOT_TOKENIZED"])
+}), Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literal("v1"),
+	kind: Schema.Literals(["registrar", "name-wrapper"]),
+	contract: EthereumAddress,
+	tokenId: Schema.BigInt,
+	approved: Schema.NullOr(EthereumAddress)
+})]);
+const ResolverDelegateApprovalResult = Schema.Union([Schema.Struct({
+	supported: Schema.Literal(false),
+	protocol: Schema.Literals(["v1", "v2"]),
+	reason: Schema.Literals(["RESOLVER_NOT_FOUND", "DELEGATE_APPROVAL_UNSUPPORTED"])
+}), Schema.Struct({
+	supported: Schema.Literal(true),
+	protocol: Schema.Literals(["v1", "v2"]),
+	resolver: EthereumAddress,
+	owner: EthereumAddress,
+	delegate: EthereumAddress,
+	approved: Schema.Boolean
+})]);
+const WrapperPermissionsResult = Schema.Union([
+	Schema.Struct({
+		supported: Schema.Literal(false),
+		protocol: Schema.Literals(["v1", "v2"]),
+		reason: Schema.Literal("NAME_NOT_WRAPPED")
+	}),
+	Schema.Struct({
+		supported: Schema.Literal(true),
+		protocol: Schema.Literal("v1"),
+		wrapper: EthereumAddress,
+		account: EthereumAddress,
+		owner: EthereumAddress,
+		tokenId: Schema.BigInt,
+		fuses: Schema.Number,
+		expiry: Schema.BigInt,
+		approved: Schema.NullOr(EthereumAddress),
+		operatorApproved: Schema.Boolean,
+		canModify: Schema.Boolean,
+		canExtendSubnames: Schema.Boolean,
+		canUnwrap: Schema.Boolean,
+		canTransfer: Schema.Boolean,
+		canSetResolver: Schema.Boolean,
+		canSetTtl: Schema.Boolean,
+		canCreateSubname: Schema.Boolean,
+		canApprove: Schema.Boolean
+	}),
+	Schema.Struct({
+		supported: Schema.Literal(true),
+		protocol: Schema.Literal("v2"),
+		wrapper: EthereumAddress,
+		account: EthereumAddress,
+		resource: Schema.BigInt,
+		roles: Schema.BigInt,
+		operatorApproved: Schema.Boolean
+	})
+]);
+const AuthorizationRequirement = Schema.Union([
+	Schema.Struct({ kind: Schema.Literal("none") }),
+	Schema.Struct({ kind: Schema.Literal("owner") }),
+	Schema.Struct({ kind: Schema.Literal("operator-approval") }),
+	Schema.Struct({ kind: Schema.Literal("token-approval") }),
+	Schema.Struct({ kind: Schema.Literal("resolver-delegate") }),
+	Schema.Struct({
+		kind: Schema.Literal("registry-role"),
+		roles: Schema.BigInt,
+		resource: Schema.BigInt
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("resolver-role"),
+		roles: Schema.BigInt,
+		resource: Schema.BigInt
+	}),
+	Schema.Struct({ kind: Schema.Literal("wrapper-permission") }),
+	Schema.Struct({ kind: Schema.Literal("unsupported") })
+]);
+const AuthorizationSource = Schema.Literals([
+	"owner",
+	"operator-approval",
+	"token-approval",
+	"resolver-delegate",
+	"registry-role",
+	"resolver-role",
+	"wrapper-permission"
+]);
+const AuthorizationDecision = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("authorized"),
+		source: AuthorizationSource
+	}),
+	Schema.Struct({
+		status: Schema.Literal("unauthorized"),
+		requirement: AuthorizationRequirement
+	}),
+	Schema.Struct({
+		status: Schema.Literal("unknown"),
+		reason: Schema.Literal("CUSTOM_RESOLVER")
+	})
+]);
+const RecordPermission = Schema.Struct({
+	record: RecordOperation,
+	supported: Schema.Boolean,
+	authorization: AuthorizationDecision,
+	requiredRole: Schema.BigInt,
+	resource: Schema.NullOr(Schema.BigInt)
+});
+const RecordPermissionsResult = Schema.Struct({
+	resolver: Schema.NullOr(EthereumAddress),
+	inherited: Schema.Boolean,
+	account: EthereumAddress,
+	records: Schema.Array(RecordPermission)
+});
+const UnavailableWriteTarget = Schema.Struct({
+	available: Schema.Literal(false),
+	protocol: Schema.Literals(["v1", "v2"]),
+	reason: Schema.Literals([
+		"NAME_NOT_REGISTERED",
+		"RESOLVER_NOT_FOUND",
+		"OPERATION_UNSUPPORTED"
+	])
+});
+const AvailableWriteTarget = Schema.Struct({
+	available: Schema.Literal(true),
+	protocol: Schema.Literals(["v1", "v2"]),
+	kind: Schema.Literals([
+		"registry",
+		"registrar",
+		"name-wrapper",
+		"wrapper-registry",
+		"resolver"
+	]),
+	address: EthereumAddress,
+	operation: WriteOperation,
+	node: Namehash,
+	tokenId: Schema.NullOr(Schema.BigInt),
+	resource: Schema.NullOr(Schema.BigInt),
+	inheritedResolver: Schema.Boolean
+});
+const WriteTarget = Schema.Union([UnavailableWriteTarget, AvailableWriteTarget]);
+const AuthorizationBlocker = Schema.Literals([
+	"NAME_NOT_REGISTERED",
+	"RESOLVER_NOT_FOUND",
+	"OPERATION_UNSUPPORTED",
+	"WRAPPER_FUSE",
+	"TRANSFER_ROLE"
+]);
+const RequiredAuthorizationResult = Schema.Struct({
+	account: EthereumAddress,
+	operation: WriteOperation,
+	target: WriteTarget,
+	authorization: AuthorizationDecision,
+	blockers: Schema.Array(AuthorizationBlocker)
+});
+const NameCapabilities = Schema.Struct({
+	name: NormalizedName,
+	account: EthereumAddress,
+	registry: RegistryCapabilities,
+	resolver: ResolverCapabilities,
+	records: Schema.Array(RecordPermission),
+	ownership: Schema.Struct({
+		setOwner: Schema.Boolean,
+		setResolver: Schema.Boolean,
+		createSubname: Schema.Boolean,
+		transfer: Schema.Boolean,
+		setExpiry: Schema.Boolean
+	})
+});
+
+//#endregion
+export { AuthorizationDecision, AuthorizationRequirement, AuthorizationSource, HasRegistryRolesResult, HasResolverRolesResult, NameCapabilities, OperatorApprovalResult, OperatorApprovalTarget, RecordOperation, RecordPermission, RecordPermissionsResult, RegistryCapabilities, RegistryOperation, RegistryRolesResult, RequiredAuthorizationResult, ResolverCapabilities, ResolverDelegateApprovalResult, ResolverProfiles, ResolverRolesResult, TokenApprovalResult, WrapperPermissionsResult, WriteOperation, WriteTarget };
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/actions/capabilities/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport type { BlockParameters } from \"../../action/block.js\";\nimport { Namehash } from \"../../schemas/hash.js\";\nimport { EthereumAddress } from \"../../schemas/identity.js\";\nimport { NormalizedName } from \"../../schemas/name.js\";\nimport { InterfaceId } from \"../../schemas/records.js\";\nimport type { GetNameStateError } from \"../name/get-name-state/types.js\";\n\nexport type CapabilityError = GetNameStateError;\n\nexport type NameCapabilityParameters = { readonly name: string } & BlockParameters;\nexport type AccountCapabilityParameters = NameCapabilityParameters & {\n  readonly account: EthereumAddress;\n};\n\nexport const RegistryCapabilities = Schema.Struct({\n  address: EthereumAddress,\n  protocol: Schema.Literals([\"v1\", \"v2\"]),\n  kind: Schema.Literals([\"registry\", \"name-wrapper\", \"permissioned-registry\", \"wrapper-registry\"]),\n  owned: Schema.Boolean,\n  permissioned: Schema.Boolean,\n  temporal: Schema.Boolean,\n  tokenized: Schema.Boolean,\n  wrapped: Schema.Boolean,\n  setOwner: Schema.Boolean,\n  setResolver: Schema.Boolean,\n  createSubname: Schema.Boolean,\n  transfer: Schema.Boolean,\n  setExpiry: Schema.Boolean,\n});\nexport type RegistryCapabilities = typeof RegistryCapabilities.Type;\n\nexport const ResolverProfiles = Schema.Struct({\n  address: Schema.Boolean,\n  text: Schema.Boolean,\n  contentHash: Schema.Boolean,\n  abi: Schema.Boolean,\n  pubkey: Schema.Boolean,\n  interface: Schema.Boolean,\n  name: Schema.Boolean,\n  data: Schema.Boolean,\n  dnsRecord: Schema.Boolean,\n  dnsZone: Schema.Boolean,\n});\nexport type ResolverProfiles = typeof ResolverProfiles.Type;\n\nexport const ResolverCapabilities = Schema.Struct({\n  address: Schema.NullOr(EthereumAddress),\n  node: Namehash,\n  inherited: Schema.Boolean,\n  extended: Schema.Boolean,\n  permissioned: Schema.Boolean,\n  authorization: Schema.Literals([\"none\", \"owner-delegate\", \"role\", \"unknown\"]),\n  profiles: ResolverProfiles,\n});\nexport type ResolverCapabilities = typeof ResolverCapabilities.Type;\n\nconst UnsupportedRolesResult = Schema.Struct({\n  supported: Schema.Literal(false),\n  protocol: Schema.Literals([\"v1\", \"v2\"]),\n  reason: Schema.Literals([\"ROLE_BASED_PERMISSIONS_UNSUPPORTED\", \"RESOLVER_NOT_FOUND\"]),\n});\n\nexport const RegistryRolesResult = Schema.Union([\n  UnsupportedRolesResult,\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v2\"),\n    registry: EthereumAddress,\n    resource: Schema.BigInt,\n    account: EthereumAddress,\n    roles: Schema.BigInt,\n  }),\n]);\nexport type RegistryRolesResult = typeof RegistryRolesResult.Type;\n\nexport const HasRegistryRolesResult = Schema.Union([\n  UnsupportedRolesResult,\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v2\"),\n    registry: EthereumAddress,\n    resource: Schema.BigInt,\n    account: EthereumAddress,\n    roles: Schema.BigInt,\n    authorized: Schema.Boolean,\n  }),\n]);\nexport type HasRegistryRolesResult = typeof HasRegistryRolesResult.Type;\n\nexport const ResolverRolesResult = Schema.Union([\n  UnsupportedRolesResult,\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v2\"),\n    resolver: EthereumAddress,\n    resource: Schema.BigInt,\n    account: EthereumAddress,\n    roles: Schema.BigInt,\n  }),\n]);\nexport type ResolverRolesResult = typeof ResolverRolesResult.Type;\n\nexport const HasResolverRolesResult = Schema.Union([\n  UnsupportedRolesResult,\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v2\"),\n    resolver: EthereumAddress,\n    resource: Schema.BigInt,\n    account: EthereumAddress,\n    roles: Schema.BigInt,\n    authorized: Schema.Boolean,\n  }),\n]);\nexport type HasResolverRolesResult = typeof HasResolverRolesResult.Type;\n\nexport const RecordOperation = Schema.Union([\n  Schema.Struct({ type: Schema.Literal(\"address\"), coinType: Schema.BigInt }),\n  Schema.Struct({ type: Schema.Literal(\"text\"), key: Schema.String }),\n  Schema.Struct({ type: Schema.Literal(\"contentHash\") }),\n  Schema.Struct({ type: Schema.Literal(\"pubkey\") }),\n  Schema.Struct({ type: Schema.Literal(\"abi\"), contentType: Schema.optional(Schema.BigInt) }),\n  Schema.Struct({ type: Schema.Literal(\"interface\"), interfaceId: Schema.optional(InterfaceId) }),\n  Schema.Struct({ type: Schema.Literal(\"name\") }),\n  Schema.Struct({ type: Schema.Literal(\"data\"), key: Schema.String }),\n  Schema.Struct({ type: Schema.Literal(\"alias\") }),\n  Schema.Struct({ type: Schema.Literal(\"dnsRecord\") }),\n  Schema.Struct({ type: Schema.Literal(\"dnsZone\") }),\n  Schema.Struct({ type: Schema.Literal(\"clear\") }),\n]);\nexport type RecordOperation = typeof RecordOperation.Type;\n\nexport const RegistryOperation = Schema.Union([\n  Schema.Struct({ type: Schema.Literal(\"setOwner\") }),\n  Schema.Struct({ type: Schema.Literal(\"setTtl\") }),\n  Schema.Struct({ type: Schema.Literal(\"setResolver\") }),\n  Schema.Struct({ type: Schema.Literal(\"createSubname\") }),\n  Schema.Struct({ type: Schema.Literal(\"transfer\") }),\n  Schema.Struct({ type: Schema.Literal(\"setExpiry\") }),\n]);\nexport type RegistryOperation = typeof RegistryOperation.Type;\n\nexport const WriteOperation = Schema.Union([RecordOperation, RegistryOperation]);\nexport type WriteOperation = typeof WriteOperation.Type;\n\nexport const OperatorApprovalTarget = Schema.Struct({\n  kind: Schema.Literals([\"registry\", \"registrar\", \"wrapper\", \"resolver\"]),\n  address: EthereumAddress,\n  supported: Schema.Boolean,\n  approved: Schema.Boolean,\n});\nexport type OperatorApprovalTarget = typeof OperatorApprovalTarget.Type;\n\nexport const OperatorApprovalResult = Schema.Struct({\n  owner: EthereumAddress,\n  operator: EthereumAddress,\n  targets: Schema.Array(OperatorApprovalTarget),\n});\nexport type OperatorApprovalResult = typeof OperatorApprovalResult.Type;\n\nexport const TokenApprovalResult = Schema.Union([\n  Schema.Struct({\n    supported: Schema.Literal(false),\n    protocol: Schema.Literals([\"v1\", \"v2\"]),\n    reason: Schema.Literals([\"PER_TOKEN_APPROVAL_UNSUPPORTED\", \"NAME_NOT_TOKENIZED\"]),\n  }),\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v1\"),\n    kind: Schema.Literals([\"registrar\", \"name-wrapper\"]),\n    contract: EthereumAddress,\n    tokenId: Schema.BigInt,\n    approved: Schema.NullOr(EthereumAddress),\n  }),\n]);\nexport type TokenApprovalResult = typeof TokenApprovalResult.Type;\n\nexport const ResolverDelegateApprovalResult = Schema.Union([\n  Schema.Struct({\n    supported: Schema.Literal(false),\n    protocol: Schema.Literals([\"v1\", \"v2\"]),\n    reason: Schema.Literals([\"RESOLVER_NOT_FOUND\", \"DELEGATE_APPROVAL_UNSUPPORTED\"]),\n  }),\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literals([\"v1\", \"v2\"]),\n    resolver: EthereumAddress,\n    owner: EthereumAddress,\n    delegate: EthereumAddress,\n    approved: Schema.Boolean,\n  }),\n]);\nexport type ResolverDelegateApprovalResult = typeof ResolverDelegateApprovalResult.Type;\n\nexport const WrapperPermissionsResult = Schema.Union([\n  Schema.Struct({\n    supported: Schema.Literal(false),\n    protocol: Schema.Literals([\"v1\", \"v2\"]),\n    reason: Schema.Literal(\"NAME_NOT_WRAPPED\"),\n  }),\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v1\"),\n    wrapper: EthereumAddress,\n    account: EthereumAddress,\n    owner: EthereumAddress,\n    tokenId: Schema.BigInt,\n    fuses: Schema.Number,\n    expiry: Schema.BigInt,\n    approved: Schema.NullOr(EthereumAddress),\n    operatorApproved: Schema.Boolean,\n    canModify: Schema.Boolean,\n    canExtendSubnames: Schema.Boolean,\n    canUnwrap: Schema.Boolean,\n    canTransfer: Schema.Boolean,\n    canSetResolver: Schema.Boolean,\n    canSetTtl: Schema.Boolean,\n    canCreateSubname: Schema.Boolean,\n    canApprove: Schema.Boolean,\n  }),\n  Schema.Struct({\n    supported: Schema.Literal(true),\n    protocol: Schema.Literal(\"v2\"),\n    wrapper: EthereumAddress,\n    account: EthereumAddress,\n    resource: Schema.BigInt,\n    roles: Schema.BigInt,\n    operatorApproved: Schema.Boolean,\n  }),\n]);\nexport type WrapperPermissionsResult = typeof WrapperPermissionsResult.Type;\n\nexport const AuthorizationRequirement = Schema.Union([\n  Schema.Struct({ kind: Schema.Literal(\"none\") }),\n  Schema.Struct({ kind: Schema.Literal(\"owner\") }),\n  Schema.Struct({ kind: Schema.Literal(\"operator-approval\") }),\n  Schema.Struct({ kind: Schema.Literal(\"token-approval\") }),\n  Schema.Struct({ kind: Schema.Literal(\"resolver-delegate\") }),\n  Schema.Struct({\n    kind: Schema.Literal(\"registry-role\"),\n    roles: Schema.BigInt,\n    resource: Schema.BigInt,\n  }),\n  Schema.Struct({\n    kind: Schema.Literal(\"resolver-role\"),\n    roles: Schema.BigInt,\n    resource: Schema.BigInt,\n  }),\n  Schema.Struct({ kind: Schema.Literal(\"wrapper-permission\") }),\n  Schema.Struct({ kind: Schema.Literal(\"unsupported\") }),\n]);\nexport type AuthorizationRequirement = typeof AuthorizationRequirement.Type;\n\nexport const AuthorizationSource = Schema.Literals([\n  \"owner\",\n  \"operator-approval\",\n  \"token-approval\",\n  \"resolver-delegate\",\n  \"registry-role\",\n  \"resolver-role\",\n  \"wrapper-permission\",\n]);\nexport type AuthorizationSource = typeof AuthorizationSource.Type;\n\nexport const AuthorizationDecision = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"authorized\"),\n    source: AuthorizationSource,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"unauthorized\"),\n    requirement: AuthorizationRequirement,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"unknown\"),\n    reason: Schema.Literal(\"CUSTOM_RESOLVER\"),\n  }),\n]);\nexport type AuthorizationDecision = typeof AuthorizationDecision.Type;\n\nexport const RecordPermission = Schema.Struct({\n  record: RecordOperation,\n  supported: Schema.Boolean,\n  authorization: AuthorizationDecision,\n  requiredRole: Schema.BigInt,\n  resource: Schema.NullOr(Schema.BigInt),\n});\nexport type RecordPermission = typeof RecordPermission.Type;\n\nexport const RecordPermissionsResult = Schema.Struct({\n  resolver: Schema.NullOr(EthereumAddress),\n  inherited: Schema.Boolean,\n  account: EthereumAddress,\n  records: Schema.Array(RecordPermission),\n});\nexport type RecordPermissionsResult = typeof RecordPermissionsResult.Type;\n\nconst UnavailableWriteTarget = Schema.Struct({\n  available: Schema.Literal(false),\n  protocol: Schema.Literals([\"v1\", \"v2\"]),\n  reason: Schema.Literals([\"NAME_NOT_REGISTERED\", \"RESOLVER_NOT_FOUND\", \"OPERATION_UNSUPPORTED\"]),\n});\n\nconst AvailableWriteTarget = Schema.Struct({\n  available: Schema.Literal(true),\n  protocol: Schema.Literals([\"v1\", \"v2\"]),\n  kind: Schema.Literals([\"registry\", \"registrar\", \"name-wrapper\", \"wrapper-registry\", \"resolver\"]),\n  address: EthereumAddress,\n  operation: WriteOperation,\n  node: Namehash,\n  tokenId: Schema.NullOr(Schema.BigInt),\n  resource: Schema.NullOr(Schema.BigInt),\n  inheritedResolver: Schema.Boolean,\n});\n\nexport const WriteTarget = Schema.Union([UnavailableWriteTarget, AvailableWriteTarget]);\nexport type WriteTarget = typeof WriteTarget.Type;\n\nconst AuthorizationBlocker = Schema.Literals([\n  \"NAME_NOT_REGISTERED\",\n  \"RESOLVER_NOT_FOUND\",\n  \"OPERATION_UNSUPPORTED\",\n  \"WRAPPER_FUSE\",\n  \"TRANSFER_ROLE\",\n]);\n\nexport const RequiredAuthorizationResult = Schema.Struct({\n  account: EthereumAddress,\n  operation: WriteOperation,\n  target: WriteTarget,\n  authorization: AuthorizationDecision,\n  blockers: Schema.Array(AuthorizationBlocker),\n});\nexport type RequiredAuthorizationResult = typeof RequiredAuthorizationResult.Type;\n\nexport const NameCapabilities = Schema.Struct({\n  name: NormalizedName,\n  account: EthereumAddress,\n  registry: RegistryCapabilities,\n  resolver: ResolverCapabilities,\n  records: Schema.Array(RecordPermission),\n  ownership: Schema.Struct({\n    setOwner: Schema.Boolean,\n    setResolver: Schema.Boolean,\n    createSubname: Schema.Boolean,\n    transfer: Schema.Boolean,\n    setExpiry: Schema.Boolean,\n  }),\n});\nexport type NameCapabilities = typeof NameCapabilities.Type;\n"],"mappings":"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"}

package/dist/actions/dns/claim-dns-name/index.d.ts

@@ -0,0 +1,9 @@
+import { CallExecutionResult, WriteError } from "../../../write/types.js";
+import { EnsWriteAction } from "../../../action/write-intent.js";
+import { ClaimDnsNameError, ClaimDnsNameIntent, ClaimDnsNameParameters, ClaimDnsNameResult } from "../types.js";
+import "../../../index.js";
+//#region src/actions/dns/claim-dns-name/index.d.ts
+declare const claimDnsName: EnsWriteAction<ClaimDnsNameParameters, CallExecutionResult, WriteError>;
+//#endregion
+export { type ClaimDnsNameError, type ClaimDnsNameIntent, type ClaimDnsNameParameters, type ClaimDnsNameResult, claimDnsName };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/dns/claim-dns-name/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/dns/claim-dns-name/index.ts"],"mappings":";;;;;cAmFa,cAAY,eAAA,wBAAA,qBAAA"}

package/dist/actions/dns/claim-dns-name/index.js

@@ -0,0 +1,63 @@
+import { ContractError } from "../../../errors/contract-error.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { dnsEncodeName } from "../../../names/dns.js";
+import { DnsImportError } from "../../../errors/dns-import-error.js";
+import { makeSingleWriteAction } from "../../../internal/write/single-write-action.js";
+import { decodeOwnershipAddress } from "../../ownership/address.js";
+import { DnssecProofChain } from "../types.js";
+import { Effect, Schema } from "effect";
+import { encodeFunctionData, zeroAddress } from "viem";
+import { dnsRegistrarV1ProveAndClaimAbi, dnsRegistrarV1ProveAndClaimWithResolverAbi } from "@ensforge/contracts/v1";
+
+//#region src/actions/dns/claim-dns-name/index.ts
+const prepare = Effect.fn("ensforge.claimDnsName.prepare")(function* (config, parameters) {
+	const v1 = config.deployments.v1;
+	if (v1 === void 0) return yield* new DnsImportError({
+		code: "DNS_REGISTRAR_UNAVAILABLE",
+		message: "The active deployment does not provide the ENS DNS Registrar"
+	});
+	const name = yield* normalizeName.effect(parameters.name);
+	const proof = yield* Schema.decodeUnknownEffect(DnssecProofChain)(parameters.proof).pipe(Effect.mapError(() => new DnsImportError({
+		code: "INVALID_PROOF",
+		message: `A non-empty, hex-encoded DNSSEC proof chain is required for ${name}`
+	})));
+	if (parameters.address !== void 0 && parameters.resolver === void 0) return yield* new DnsImportError({
+		code: "RESOLVER_REQUIRED",
+		message: `A resolver is required when setting an address for ${name}`
+	});
+	const resolver = parameters.resolver === void 0 ? null : yield* decodeOwnershipAddress(parameters.resolver, "resolver");
+	const address = parameters.address === void 0 ? zeroAddress : yield* decodeOwnershipAddress(parameters.address, "DNS address record");
+	const dnsName = yield* dnsEncodeName.effect(name);
+	const data = yield* Effect.try({
+		try: () => resolver === null ? encodeFunctionData({
+			abi: dnsRegistrarV1ProveAndClaimAbi,
+			functionName: "proveAndClaim",
+			args: [dnsName, proof]
+		}) : encodeFunctionData({
+			abi: dnsRegistrarV1ProveAndClaimWithResolverAbi,
+			functionName: "proveAndClaimWithResolver",
+			args: [
+				dnsName,
+				proof,
+				resolver,
+				address
+			]
+		}),
+		catch: (cause) => new ContractError({
+			code: "ENCODE_FAILED",
+			message: `Unable to encode the DNSSEC claim for ${name}`,
+			cause
+		})
+	});
+	return {
+		to: v1.contracts.dnsRegistrar,
+		data,
+		value: 0n,
+		protocol: "v1"
+	};
+});
+const claimDnsName = makeSingleWriteAction("claimDnsName", prepare);
+
+//#endregion
+export { claimDnsName };
+//# sourceMappingURL=index.js.map

package/dist/actions/dns/claim-dns-name/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/dns/claim-dns-name/index.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport {\n  dnsRegistrarV1ProveAndClaimAbi,\n  dnsRegistrarV1ProveAndClaimWithResolverAbi,\n} from \"@ensforge/contracts/v1\";\nimport { encodeFunctionData, zeroAddress } from \"viem\";\n\nimport type { EnsWriteIntentPreparer } from \"../../../action/write-intent.js\";\nimport { ContractError } from \"../../../errors/contract-error.js\";\nimport { DnsImportError } from \"../../../errors/dns-import-error.js\";\nimport { makeSingleWriteAction } from \"../../../internal/write/single-write-action.js\";\nimport { dnsEncodeName } from \"../../../names/dns.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { WriteError } from \"../../../write/types.js\";\nimport { decodeOwnershipAddress } from \"../../ownership/address.js\";\nimport type { ClaimDnsNameParameters } from \"../types.js\";\nimport { DnssecProofChain } from \"../types.js\";\n\nconst prepare: EnsWriteIntentPreparer<ClaimDnsNameParameters, WriteError> = Effect.fn(\n  \"ensforge.claimDnsName.prepare\",\n)(function* (config, parameters) {\n  const v1 = config.deployments.v1;\n  if (v1 === undefined) {\n    return yield* new DnsImportError({\n      code: \"DNS_REGISTRAR_UNAVAILABLE\",\n      message: \"The active deployment does not provide the ENS DNS Registrar\",\n    });\n  }\n  const name = yield* normalizeName.effect(parameters.name);\n  const proof = yield* Schema.decodeUnknownEffect(DnssecProofChain)(parameters.proof).pipe(\n    Effect.mapError(\n      () =>\n        new DnsImportError({\n          code: \"INVALID_PROOF\",\n          message: `A non-empty, hex-encoded DNSSEC proof chain is required for ${name}`,\n        }),\n    ),\n  );\n  if (parameters.address !== undefined && parameters.resolver === undefined) {\n    return yield* new DnsImportError({\n      code: \"RESOLVER_REQUIRED\",\n      message: `A resolver is required when setting an address for ${name}`,\n    });\n  }\n  const resolver =\n    parameters.resolver === undefined\n      ? null\n      : yield* decodeOwnershipAddress(parameters.resolver, \"resolver\");\n  const address =\n    parameters.address === undefined\n      ? zeroAddress\n      : yield* decodeOwnershipAddress(parameters.address, \"DNS address record\");\n  const dnsName = yield* dnsEncodeName.effect(name);\n\n  const data = yield* Effect.try({\n    try: () =>\n      resolver === null\n        ? encodeFunctionData({\n            abi: dnsRegistrarV1ProveAndClaimAbi,\n            functionName: \"proveAndClaim\",\n            args: [dnsName, proof],\n          })\n        : encodeFunctionData({\n            abi: dnsRegistrarV1ProveAndClaimWithResolverAbi,\n            functionName: \"proveAndClaimWithResolver\",\n            args: [dnsName, proof, resolver, address],\n          }),\n    catch: (cause) =>\n      new ContractError({\n        code: \"ENCODE_FAILED\",\n        message: `Unable to encode the DNSSEC claim for ${name}`,\n        cause,\n      }),\n  });\n  return {\n    to: v1.contracts.dnsRegistrar,\n    data,\n    value: 0n,\n    protocol: \"v1\" as const,\n  };\n});\n\nexport const claimDnsName = makeSingleWriteAction(\"claimDnsName\", prepare);\n\nexport type {\n  ClaimDnsNameError,\n  ClaimDnsNameIntent,\n  ClaimDnsNameParameters,\n  ClaimDnsNameResult,\n} from \"../types.js\";\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAM,UAAsE,OAAO,GACjF,+BACF,CAAC,CAAC,WAAW,QAAQ,YAAY;CAC/B,MAAM,KAAK,OAAO,YAAY;CAC9B,IAAI,OAAO,QACT,OAAO,OAAO,IAAI,eAAe;EAC/B,MAAM;EACN,SAAS;CACX,CAAC;CAEH,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,MAAM,QAAQ,OAAO,OAAO,oBAAoB,gBAAgB,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC,KAClF,OAAO,eAEH,IAAI,eAAe;EACjB,MAAM;EACN,SAAS,+DAA+D;CAC1E,CAAC,CACL,CACF;CACA,IAAI,WAAW,YAAY,UAAa,WAAW,aAAa,QAC9D,OAAO,OAAO,IAAI,eAAe;EAC/B,MAAM;EACN,SAAS,sDAAsD;CACjE,CAAC;CAEH,MAAM,WACJ,WAAW,aAAa,SACpB,OACA,OAAO,uBAAuB,WAAW,UAAU,UAAU;CACnE,MAAM,UACJ,WAAW,YAAY,SACnB,cACA,OAAO,uBAAuB,WAAW,SAAS,oBAAoB;CAC5E,MAAM,UAAU,OAAO,cAAc,OAAO,IAAI;CAEhD,MAAM,OAAO,OAAO,OAAO,IAAI;EAC7B,WACE,aAAa,OACT,mBAAmB;GACjB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,SAAS,KAAK;EACvB,CAAC,IACD,mBAAmB;GACjB,KAAK;GACL,cAAc;GACd,MAAM;IAAC;IAAS;IAAO;IAAU;GAAO;EAC1C,CAAC;EACP,QAAQ,UACN,IAAI,cAAc;GAChB,MAAM;GACN,SAAS,yCAAyC;GAClD;EACF,CAAC;CACL,CAAC;CACD,OAAO;EACL,IAAI,GAAG,UAAU;EACjB;EACA,OAAO;EACP,UAAU;CACZ;AACF,CAAC;AAED,MAAa,eAAe,sBAAsB,gBAAgB,OAAO"}

package/dist/actions/dns/get-dns-claim-status/index.d.ts

@@ -0,0 +1,26 @@
+import { BlockParameters } from "../../../action/block.js";
+import { EnsReadAction } from "../../../action/read-request.js";
+import { DnsClaimStatus, DnsReadError } from "../types.js";
+import "../../../index.js";
+//#region src/actions/dns/get-dns-claim-status/index.d.ts
+type GetDnsClaimStatusParameters = {
+  readonly name: string;
+} & BlockParameters;
+declare const getDnsClaimStatus: EnsReadAction<GetDnsClaimStatusParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly previousInception: bigint;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly previousInception: bigint;
+}, DnsReadError>;
+//#endregion
+export { type DnsReadError as GetDnsClaimStatusError, GetDnsClaimStatusParameters, getDnsClaimStatus };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/dns/get-dns-claim-status/index.ts"],"mappings":";;;;;KAmBY;WAAyC;IAAiB;cA2DzD,mBAIa,cAJI;;;;;;;;;;;;;;GAIJ"}

package/dist/actions/dns/get-dns-claim-status/index.js

@@ -0,0 +1,62 @@
+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 { namehash } from "../../../names/hashes.js";
+import { DeploymentService } from "../../../internal/services/deployment.js";
+import { Effect } from "effect";
+import { isAddressEqual, zeroAddress } from "viem";
+import { dnsRegistrarV1InceptionsAbi, ensRegistryV1OwnerAbi, ensRegistryV1ResolverAbi } from "@ensforge/contracts/v1";
+
+//#region src/actions/dns/get-dns-claim-status/index.ts
+const getDnsClaimStatusEffect = Effect.fn("ensforge.getDnsClaimStatus")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, Effect.gen(function* () {
+		const { profile } = yield* DeploymentService;
+		const v1 = profile.v1;
+		if (v1 === void 0) return {
+			status: "unsupported",
+			name,
+			reason: "DNS_REGISTRAR_UNAVAILABLE"
+		};
+		const ethereum = yield* EthereumClient;
+		const node = namehash(name);
+		const [owner, resolver, inception] = yield* Effect.all([
+			ethereum.readContract({
+				address: v1.contracts.registry,
+				abi: ensRegistryV1OwnerAbi,
+				functionName: "owner",
+				args: [node]
+			}),
+			ethereum.readContract({
+				address: v1.contracts.registry,
+				abi: ensRegistryV1ResolverAbi,
+				functionName: "resolver",
+				args: [node]
+			}),
+			ethereum.readContract({
+				address: v1.contracts.dnsRegistrar,
+				abi: dnsRegistrarV1InceptionsAbi,
+				functionName: "inceptions",
+				args: [node]
+			})
+		], { concurrency: "unbounded" });
+		const previousInception = BigInt(inception);
+		return isAddressEqual(owner, zeroAddress) ? {
+			status: "proof-required",
+			name,
+			previousInception
+		} : {
+			status: "claimed",
+			name,
+			owner,
+			resolver: isAddressEqual(resolver, zeroAddress) ? null : resolver,
+			previousInception
+		};
+	}));
+});
+const getDnsClaimStatus = defineReadAction(getDnsClaimStatusEffect);
+
+//#endregion
+export { getDnsClaimStatus };
+//# sourceMappingURL=index.js.map

package/dist/actions/dns/get-dns-claim-status/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/dns/get-dns-claim-status/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport {\n  dnsRegistrarV1InceptionsAbi,\n  ensRegistryV1OwnerAbi,\n  ensRegistryV1ResolverAbi,\n} from \"@ensforge/contracts/v1\";\nimport { isAddressEqual, zeroAddress } from \"viem\";\n\nimport type { BlockParameters } from \"../../../action/block.js\";\nimport { defineReadAction } from \"../../../action/read-request.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { EthereumClient } from \"../../../internal/client/ethereum-client.js\";\nimport { executeRead } from \"../../../internal/read/execute-read.js\";\nimport { DeploymentService } from \"../../../internal/services/deployment.js\";\nimport { namehash } from \"../../../names/hashes.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { DnsClaimStatus, DnsReadError } from \"../types.js\";\n\nexport type GetDnsClaimStatusParameters = { readonly name: string } & BlockParameters;\n\nconst getDnsClaimStatusEffect = Effect.fn(\"ensforge.getDnsClaimStatus\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetDnsClaimStatusParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n  return yield* executeRead(\n    config,\n    parameters,\n    Effect.gen(function* () {\n      const { profile } = yield* DeploymentService;\n      const v1 = profile.v1;\n      if (v1 === undefined) {\n        return {\n          status: \"unsupported\",\n          name,\n          reason: \"DNS_REGISTRAR_UNAVAILABLE\",\n        } as const;\n      }\n      const ethereum = yield* EthereumClient;\n      const node = namehash(name);\n      const [owner, resolver, inception] = yield* Effect.all(\n        [\n          ethereum.readContract({\n            address: v1.contracts.registry,\n            abi: ensRegistryV1OwnerAbi,\n            functionName: \"owner\",\n            args: [node],\n          }),\n          ethereum.readContract({\n            address: v1.contracts.registry,\n            abi: ensRegistryV1ResolverAbi,\n            functionName: \"resolver\",\n            args: [node],\n          }),\n          ethereum.readContract({\n            address: v1.contracts.dnsRegistrar,\n            abi: dnsRegistrarV1InceptionsAbi,\n            functionName: \"inceptions\",\n            args: [node],\n          }),\n        ] as const,\n        { concurrency: \"unbounded\" },\n      );\n      const previousInception = BigInt(inception);\n      return isAddressEqual(owner, zeroAddress)\n        ? ({ status: \"proof-required\", name, previousInception } as const)\n        : ({\n            status: \"claimed\",\n            name,\n            owner,\n            resolver: isAddressEqual(resolver, zeroAddress) ? null : resolver,\n            previousInception,\n          } as const);\n    }),\n  );\n});\n\nexport const getDnsClaimStatus = defineReadAction<\n  GetDnsClaimStatusParameters,\n  DnsClaimStatus,\n  DnsReadError\n>(getDnsClaimStatusEffect);\n\nexport type { DnsClaimStatus, DnsReadError as GetDnsClaimStatusError } from \"../types.js\";\n"],"mappings":";;;;;;;;;;;AAqBA,MAAM,0BAA0B,OAAO,GAAG,4BAA4B,CAAC,CAAC,WACtE,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,OAAO,OAAO,YACZ,QACA,YACA,OAAO,IAAI,aAAa;EACtB,MAAM,EAAE,YAAY,OAAO;EAC3B,MAAM,KAAK,QAAQ;EACnB,IAAI,OAAO,QACT,OAAO;GACL,QAAQ;GACR;GACA,QAAQ;EACV;EAEF,MAAM,WAAW,OAAO;EACxB,MAAM,OAAO,SAAS,IAAI;EAC1B,MAAM,CAAC,OAAO,UAAU,aAAa,OAAO,OAAO,IACjD;GACE,SAAS,aAAa;IACpB,SAAS,GAAG,UAAU;IACtB,KAAK;IACL,cAAc;IACd,MAAM,CAAC,IAAI;GACb,CAAC;GACD,SAAS,aAAa;IACpB,SAAS,GAAG,UAAU;IACtB,KAAK;IACL,cAAc;IACd,MAAM,CAAC,IAAI;GACb,CAAC;GACD,SAAS,aAAa;IACpB,SAAS,GAAG,UAAU;IACtB,KAAK;IACL,cAAc;IACd,MAAM,CAAC,IAAI;GACb,CAAC;EACH,GACA,EAAE,aAAa,YAAY,CAC7B;EACA,MAAM,oBAAoB,OAAO,SAAS;EAC1C,OAAO,eAAe,OAAO,WAAW,IACnC;GAAE,QAAQ;GAAkB;GAAM;EAAkB,IACpD;GACC,QAAQ;GACR;GACA;GACA,UAAU,eAAe,UAAU,WAAW,IAAI,OAAO;GACzD;EACF;CACN,CAAC,CACH;AACF,CAAC;AAED,MAAa,oBAAoB,iBAI/B,uBAAuB"}

package/dist/actions/dns/get-dns-import-plan/index.d.ts

@@ -0,0 +1,32 @@
+import { BlockParameters } from "../../../action/block.js";
+import { EnsReadAction } from "../../../action/read-request.js";
+import { DnsImportPlan, DnsReadError } from "../types.js";
+import "../../../index.js";
+//#region src/actions/dns/get-dns-import-plan/index.d.ts
+type GetDnsImportPlanParameters = {
+  readonly name: string;
+} & BlockParameters;
+declare const getDnsImportPlan: EnsReadAction<GetDnsImportPlanParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "already-claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly proofRequest: {
+    readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+    readonly previousInception: bigint;
+  };
+}, DnsReadError>;
+//#endregion
+export { type DnsReadError as GetDnsImportPlanError, GetDnsImportPlanParameters, getDnsImportPlan };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/dns/get-dns-import-plan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/dns/get-dns-import-plan/index.ts"],"mappings":";;;;;KAeY;WAAwC;IAAiB;cAqDxD,kBAIY,cAJI;;;;;;;;;;;;;;;;;;;;GAIJ"}

package/dist/actions/dns/get-dns-import-plan/index.js

@@ -0,0 +1,53 @@
+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 { dnsEncodeName } from "../../../names/dns.js";
+import { DeploymentService } from "../../../internal/services/deployment.js";
+import { getDnsClaimStatus } from "../get-dns-claim-status/index.js";
+import { Effect } from "effect";
+import { dnsRegistrarV1OracleAbi } from "@ensforge/contracts/v1";
+
+//#region src/actions/dns/get-dns-import-plan/index.ts
+const getDnsImportPlanEffect = Effect.fn("ensforge.getDnsImportPlan")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, Effect.gen(function* () {
+		const claim = yield* getDnsClaimStatus.effect(config, parameters);
+		if (claim.status === "unsupported") return claim;
+		const { profile } = yield* DeploymentService;
+		const v1 = profile.v1;
+		if (v1 === void 0) return {
+			status: "unsupported",
+			name,
+			reason: "DNS_REGISTRAR_UNAVAILABLE"
+		};
+		const oracle = yield* (yield* EthereumClient).readContract({
+			address: v1.contracts.dnsRegistrar,
+			abi: dnsRegistrarV1OracleAbi,
+			functionName: "oracle"
+		});
+		if (claim.status === "claimed") return {
+			status: "already-claimed",
+			name,
+			registrar: v1.contracts.dnsRegistrar,
+			oracle,
+			owner: claim.owner,
+			resolver: claim.resolver
+		};
+		return {
+			status: "proof-required",
+			name,
+			registrar: v1.contracts.dnsRegistrar,
+			oracle,
+			proofRequest: {
+				name: yield* dnsEncodeName.effect(name),
+				previousInception: claim.previousInception
+			}
+		};
+	}));
+});
+const getDnsImportPlan = defineReadAction(getDnsImportPlanEffect);
+
+//#endregion
+export { getDnsImportPlan };
+//# sourceMappingURL=index.js.map