@ensforge/core 0.0.0

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

@@ -0,0 +1,145 @@
+import { ConfirmationPolicy } from "../../config/write-options.js";
+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 { CallExecutionResult, WriteError, WriteMode, WritePlanProgress } from "../../write/types.js";
+import { EnsWriteIntent } from "../../action/write-intent.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { NormalizedName } from "../../schemas/name.js";
+import { Schema } from "effect";
+import { Account, Address, WalletClient } from "viem";
+//#region src/actions/dns/types.d.ts
+type DnsReadError = CodecError | ContractError | NameError | RpcError;
+declare const DnssecProof: Schema.Struct<{
+  readonly rrset: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly sig: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+type DnssecProof = typeof DnssecProof.Type;
+declare const DnssecProofChain: Schema.$Array<Schema.Struct<{
+  readonly rrset: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  readonly sig: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>>;
+type DnssecProofChain = typeof DnssecProofChain.Type;
+interface DnsWriteWalletParameters {
+  readonly walletClient?: WalletClient;
+  readonly account?: Account | Address;
+  readonly mode?: WriteMode;
+  readonly confirmation?: ConfirmationPolicy;
+}
+interface ClaimDnsNameParameters {
+  readonly name: string;
+  readonly proof: ReadonlyArray<DnssecProof>;
+  readonly resolver?: string;
+  readonly address?: string;
+}
+type ClaimDnsNameResult = CallExecutionResult;
+type ClaimDnsNameError = WriteError;
+type ClaimDnsNameIntent = EnsWriteIntent<ClaimDnsNameResult, ClaimDnsNameError>;
+type ImportDnsNameParameters = ClaimDnsNameParameters & DnsWriteWalletParameters & {
+  readonly resume?: ImportDnsNameResult;
+};
+type ImportDnsNameResult = {
+  readonly status: "completed" | "not-required";
+  readonly name: NormalizedName;
+  readonly owner: EthereumAddress;
+  readonly resolver: EthereumAddress | null;
+  readonly write: WritePlanProgress | null;
+} | {
+  readonly status: "partial";
+  readonly name: NormalizedName;
+  readonly owner: null;
+  readonly resolver: null;
+  readonly write: WritePlanProgress;
+};
+type ImportDnsNameError = WriteError;
+declare const DnsResource: Schema.Int;
+type DnsResource = typeof DnsResource.Type;
+type DnsRecordQuery = {
+  readonly recordName: string;
+  readonly resource: DnsResource;
+};
+type GetDnsRecordParameters = {
+  readonly name: string;
+  readonly recordName: string;
+  readonly resource: DnsResource;
+} & BlockParameters;
+declare const DnsRecordResult: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly recordName: Schema.brand<Schema.String, "NormalizedName">;
+  readonly resource: Schema.Int;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly value: Schema.NullOr<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+}>;
+type DnsRecordResult = typeof DnsRecordResult.Type;
+type GetDnsRecordsParameters = {
+  readonly name: string;
+  readonly records: ReadonlyArray<DnsRecordQuery>;
+} & BlockParameters;
+declare const DnsRecordsResult: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly records: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly recordName: Schema.brand<Schema.String, "NormalizedName">;
+    readonly resource: Schema.Int;
+    readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly value: Schema.NullOr<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  }>>;
+}>;
+type DnsRecordsResult = typeof DnsRecordsResult.Type;
+declare const DnsRecordsExistence: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly recordName: Schema.brand<Schema.String, "NormalizedName">;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly exists: Schema.Boolean;
+}>;
+type DnsRecordsExistence = typeof DnsRecordsExistence.Type;
+declare const ZoneHashResult: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly value: Schema.NullOr<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+}>;
+type ZoneHashResult = typeof ZoneHashResult.Type;
+declare const DnsClaimStatus: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literal<"DNS_REGISTRAR_UNAVAILABLE">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"claimed">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly previousInception: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"proof-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly previousInception: Schema.BigInt;
+}>]>;
+type DnsClaimStatus = typeof DnsClaimStatus.Type;
+declare const DnsImportPlan: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly reason: Schema.Literal<"DNS_REGISTRAR_UNAVAILABLE">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"already-claimed">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly oracle: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"proof-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly oracle: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly proofRequest: Schema.Struct<{
+    readonly name: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "DnsEncodedName">;
+    readonly previousInception: Schema.BigInt;
+  }>;
+}>]>;
+type DnsImportPlan = typeof DnsImportPlan.Type;
+//#endregion
+export { ClaimDnsNameError, ClaimDnsNameIntent, ClaimDnsNameParameters, ClaimDnsNameResult, DnsClaimStatus, DnsImportPlan, DnsReadError, DnsRecordQuery, DnsRecordResult, DnsRecordsExistence, DnsRecordsResult, DnsResource, DnssecProof, DnssecProofChain, GetDnsRecordParameters, GetDnsRecordsParameters, ImportDnsNameError, ImportDnsNameParameters, ImportDnsNameResult, ZoneHashResult };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/actions/dns/types.ts"],"mappings":";;;;;;;;;;;;;KAsBY,eAAe,aAAa,gBAAgB,YAAY;cAEvD,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;cAEhC,kBAAgB,OAAA,OAAA,OAAA;;;;KAGjB,0BAA0B,iBAAiB;UAE7C;WACC,eAAe;WACf,UAAU,UAAU;WACpB,OAAO;WACP,eAAe;;UAGT;WACN;WACA,OAAO,cAAc;WACrB;WACA;;KAGC,qBAAqB;KACrB,oBAAoB;KACpB,qBAAqB,eAAe,oBAAoB;KAExD,0BAA0B,yBACpC;WACW,SAAS;;KAGV;WAEG;WACA,MAAM;WACN,OAAO;WACP,UAAU;WACV,OAAO;;WAGP;WACA,MAAM;WACN;WACA;WACA,OAAO;;KAGV,qBAAqB;cAEpB,aAAW,OAAA;KAQZ,qBAAqB,YAAY;KAEjC;WAA4B;WAA6B,UAAU;;KAEnE;WACD;WACA;WACA,UAAU;IACjB;cAES,iBAAe,OAAA;;;;;;;KAOhB,yBAAyB,gBAAgB;KAEzC;WACD;WACA,SAAS,cAAc;IAC9B;cAES,kBAAgB,OAAA;;;;;;;;;;;KAKjB,0BAA0B,iBAAiB;cAE1C,qBAAmB,OAAA;;;;;;KAMpB,6BAA6B,oBAAoB;cAEhD,gBAAc,OAAA;;;;;KAKf,wBAAwB,eAAe;cAEtC,gBAAc,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;KAmBf,wBAAwB,eAAe;cAEtC,eAAa,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;KAyBd,uBAAuB,cAAc"}

package/dist/actions/dns/types.js

@@ -0,0 +1,87 @@
+import { Hex } from "../../schemas/hex.js";
+import { NormalizedName } from "../../schemas/name.js";
+import { DnsEncodedName } from "../../schemas/dns.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { Schema } from "effect";
+
+//#region src/actions/dns/types.ts
+const DnssecProof = Schema.Struct({
+	rrset: Hex,
+	sig: Hex
+});
+const DnssecProofChain = Schema.Array(DnssecProof).pipe(Schema.check(Schema.isMinLength(1, { message: "Expected at least one signed DNS RRSET" })));
+const DnsResource = Schema.Int.pipe(Schema.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 65535
+}, { message: "Expected a uint16 DNS resource" })));
+const DnsRecordResult = Schema.Struct({
+	name: NormalizedName,
+	recordName: NormalizedName,
+	resource: DnsResource,
+	resolver: Schema.NullOr(EthereumAddress),
+	value: Schema.NullOr(Hex)
+});
+const DnsRecordsResult = Schema.Struct({
+	name: NormalizedName,
+	resolver: Schema.NullOr(EthereumAddress),
+	records: Schema.Array(DnsRecordResult)
+});
+const DnsRecordsExistence = Schema.Struct({
+	name: NormalizedName,
+	recordName: NormalizedName,
+	resolver: Schema.NullOr(EthereumAddress),
+	exists: Schema.Boolean
+});
+const ZoneHashResult = Schema.Struct({
+	name: NormalizedName,
+	resolver: Schema.NullOr(EthereumAddress),
+	value: Schema.NullOr(Hex)
+});
+const DnsClaimStatus = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("unsupported"),
+		name: NormalizedName,
+		reason: Schema.Literal("DNS_REGISTRAR_UNAVAILABLE")
+	}),
+	Schema.Struct({
+		status: Schema.Literal("claimed"),
+		name: NormalizedName,
+		owner: EthereumAddress,
+		resolver: Schema.NullOr(EthereumAddress),
+		previousInception: Schema.BigInt
+	}),
+	Schema.Struct({
+		status: Schema.Literal("proof-required"),
+		name: NormalizedName,
+		previousInception: Schema.BigInt
+	})
+]);
+const DnsImportPlan = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("unsupported"),
+		name: NormalizedName,
+		reason: Schema.Literal("DNS_REGISTRAR_UNAVAILABLE")
+	}),
+	Schema.Struct({
+		status: Schema.Literal("already-claimed"),
+		name: NormalizedName,
+		registrar: EthereumAddress,
+		oracle: EthereumAddress,
+		owner: EthereumAddress,
+		resolver: Schema.NullOr(EthereumAddress)
+	}),
+	Schema.Struct({
+		status: Schema.Literal("proof-required"),
+		name: NormalizedName,
+		registrar: EthereumAddress,
+		oracle: EthereumAddress,
+		proofRequest: Schema.Struct({
+			name: DnsEncodedName,
+			previousInception: Schema.BigInt
+		})
+	})
+]);
+
+//#endregion
+export { DnsClaimStatus, DnsImportPlan, DnsRecordResult, DnsRecordsExistence, DnsRecordsResult, DnsResource, DnssecProof, DnssecProofChain, ZoneHashResult };
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/actions/dns/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport type { Account, Address, WalletClient } from \"viem\";\n\nimport type { BlockParameters } from \"../../action/block.js\";\nimport type { EnsWriteIntent } from \"../../action/write-intent.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 { DnsEncodedName } from \"../../schemas/dns.js\";\nimport { Hex } from \"../../schemas/hex.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\";\n\nexport type DnsReadError = CodecError | ContractError | NameError | RpcError;\n\nexport const DnssecProof = Schema.Struct({\n  rrset: Hex,\n  sig: Hex,\n});\nexport type DnssecProof = typeof DnssecProof.Type;\n\nexport const DnssecProofChain = Schema.Array(DnssecProof).pipe(\n  Schema.check(Schema.isMinLength(1, { message: \"Expected at least one signed DNS RRSET\" })),\n);\nexport type DnssecProofChain = typeof DnssecProofChain.Type;\n\ninterface DnsWriteWalletParameters {\n  readonly walletClient?: WalletClient;\n  readonly account?: Account | Address;\n  readonly mode?: WriteMode;\n  readonly confirmation?: ConfirmationPolicy;\n}\n\nexport interface ClaimDnsNameParameters {\n  readonly name: string;\n  readonly proof: ReadonlyArray<DnssecProof>;\n  readonly resolver?: string;\n  readonly address?: string;\n}\n\nexport type ClaimDnsNameResult = CallExecutionResult;\nexport type ClaimDnsNameError = WriteError;\nexport type ClaimDnsNameIntent = EnsWriteIntent<ClaimDnsNameResult, ClaimDnsNameError>;\n\nexport type ImportDnsNameParameters = ClaimDnsNameParameters &\n  DnsWriteWalletParameters & {\n    readonly resume?: ImportDnsNameResult;\n  };\n\nexport type ImportDnsNameResult =\n  | {\n      readonly status: \"completed\" | \"not-required\";\n      readonly name: NormalizedName;\n      readonly owner: EthereumAddress;\n      readonly resolver: EthereumAddress | null;\n      readonly write: WritePlanProgress | null;\n    }\n  | {\n      readonly status: \"partial\";\n      readonly name: NormalizedName;\n      readonly owner: null;\n      readonly resolver: null;\n      readonly write: WritePlanProgress;\n    };\n\nexport type ImportDnsNameError = WriteError;\n\nexport const DnsResource = Schema.Int.pipe(\n  Schema.check(\n    Schema.isBetween(\n      { minimum: 0, maximum: 65_535 },\n      { message: \"Expected a uint16 DNS resource\" },\n    ),\n  ),\n);\nexport type DnsResource = typeof DnsResource.Type;\n\nexport type DnsRecordQuery = { readonly recordName: string; readonly resource: DnsResource };\n\nexport type GetDnsRecordParameters = {\n  readonly name: string;\n  readonly recordName: string;\n  readonly resource: DnsResource;\n} & BlockParameters;\n\nexport const DnsRecordResult = Schema.Struct({\n  name: NormalizedName,\n  recordName: NormalizedName,\n  resource: DnsResource,\n  resolver: Schema.NullOr(EthereumAddress),\n  value: Schema.NullOr(Hex),\n});\nexport type DnsRecordResult = typeof DnsRecordResult.Type;\n\nexport type GetDnsRecordsParameters = {\n  readonly name: string;\n  readonly records: ReadonlyArray<DnsRecordQuery>;\n} & BlockParameters;\n\nexport const DnsRecordsResult = Schema.Struct({\n  name: NormalizedName,\n  resolver: Schema.NullOr(EthereumAddress),\n  records: Schema.Array(DnsRecordResult),\n});\nexport type DnsRecordsResult = typeof DnsRecordsResult.Type;\n\nexport const DnsRecordsExistence = Schema.Struct({\n  name: NormalizedName,\n  recordName: NormalizedName,\n  resolver: Schema.NullOr(EthereumAddress),\n  exists: Schema.Boolean,\n});\nexport type DnsRecordsExistence = typeof DnsRecordsExistence.Type;\n\nexport const ZoneHashResult = Schema.Struct({\n  name: NormalizedName,\n  resolver: Schema.NullOr(EthereumAddress),\n  value: Schema.NullOr(Hex),\n});\nexport type ZoneHashResult = typeof ZoneHashResult.Type;\n\nexport const DnsClaimStatus = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"unsupported\"),\n    name: NormalizedName,\n    reason: Schema.Literal(\"DNS_REGISTRAR_UNAVAILABLE\"),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"claimed\"),\n    name: NormalizedName,\n    owner: EthereumAddress,\n    resolver: Schema.NullOr(EthereumAddress),\n    previousInception: Schema.BigInt,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"proof-required\"),\n    name: NormalizedName,\n    previousInception: Schema.BigInt,\n  }),\n]);\nexport type DnsClaimStatus = typeof DnsClaimStatus.Type;\n\nexport const DnsImportPlan = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"unsupported\"),\n    name: NormalizedName,\n    reason: Schema.Literal(\"DNS_REGISTRAR_UNAVAILABLE\"),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"already-claimed\"),\n    name: NormalizedName,\n    registrar: EthereumAddress,\n    oracle: EthereumAddress,\n    owner: EthereumAddress,\n    resolver: Schema.NullOr(EthereumAddress),\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"proof-required\"),\n    name: NormalizedName,\n    registrar: EthereumAddress,\n    oracle: EthereumAddress,\n    proofRequest: Schema.Struct({\n      name: DnsEncodedName,\n      previousInception: Schema.BigInt,\n    }),\n  }),\n]);\nexport type DnsImportPlan = typeof DnsImportPlan.Type;\n"],"mappings":";;;;;;;AAwBA,MAAa,cAAc,OAAO,OAAO;CACvC,OAAO;CACP,KAAK;AACP,CAAC;AAGD,MAAa,mBAAmB,OAAO,MAAM,WAAW,CAAC,CAAC,KACxD,OAAO,MAAM,OAAO,YAAY,GAAG,EAAE,SAAS,yCAAyC,CAAC,CAAC,CAC3F;AA4CA,MAAa,cAAc,OAAO,IAAI,KACpC,OAAO,MACL,OAAO,UACL;CAAE,SAAS;CAAG,SAAS;AAAO,GAC9B,EAAE,SAAS,iCAAiC,CAC9C,CACF,CACF;AAWA,MAAa,kBAAkB,OAAO,OAAO;CAC3C,MAAM;CACN,YAAY;CACZ,UAAU;CACV,UAAU,OAAO,OAAO,eAAe;CACvC,OAAO,OAAO,OAAO,GAAG;AAC1B,CAAC;AAQD,MAAa,mBAAmB,OAAO,OAAO;CAC5C,MAAM;CACN,UAAU,OAAO,OAAO,eAAe;CACvC,SAAS,OAAO,MAAM,eAAe;AACvC,CAAC;AAGD,MAAa,sBAAsB,OAAO,OAAO;CAC/C,MAAM;CACN,YAAY;CACZ,UAAU,OAAO,OAAO,eAAe;CACvC,QAAQ,OAAO;AACjB,CAAC;AAGD,MAAa,iBAAiB,OAAO,OAAO;CAC1C,MAAM;CACN,UAAU,OAAO,OAAO,eAAe;CACvC,OAAO,OAAO,OAAO,GAAG;AAC1B,CAAC;AAGD,MAAa,iBAAiB,OAAO,MAAM;CACzC,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,aAAa;EACpC,MAAM;EACN,QAAQ,OAAO,QAAQ,2BAA2B;CACpD,CAAC;CACD,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,SAAS;EAChC,MAAM;EACN,OAAO;EACP,UAAU,OAAO,OAAO,eAAe;EACvC,mBAAmB,OAAO;CAC5B,CAAC;CACD,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,gBAAgB;EACvC,MAAM;EACN,mBAAmB,OAAO;CAC5B,CAAC;AACH,CAAC;AAGD,MAAa,gBAAgB,OAAO,MAAM;CACxC,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,aAAa;EACpC,MAAM;EACN,QAAQ,OAAO,QAAQ,2BAA2B;CACpD,CAAC;CACD,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,iBAAiB;EACxC,MAAM;EACN,WAAW;EACX,QAAQ;EACR,OAAO;EACP,UAAU,OAAO,OAAO,eAAe;CACzC,CAAC;CACD,OAAO,OAAO;EACZ,QAAQ,OAAO,QAAQ,gBAAgB;EACvC,MAAM;EACN,WAAW;EACX,QAAQ;EACR,cAAc,OAAO,OAAO;GAC1B,MAAM;GACN,mBAAmB,OAAO;EAC5B,CAAC;CACH,CAAC;AACH,CAAC"}

package/dist/actions/events/get-ens-events/index.d.ts

@@ -0,0 +1,33 @@
+import { EnsAction } from "../../../action/action.js";
+import { EnsEvent, EnsEventError, GetEnsEventsParameters } from "../types.js";
+import "../../../index.js";
+//#region src/actions/events/get-ens-events/index.d.ts
+declare const getEnsEvents: EnsAction<GetEnsEventsParameters, readonly {
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly blockNumber: bigint | null;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "commitment" | "registration" | "renewal" | "ownership" | "manager" | "resolver" | "records" | "subname" | "migration" | "other";
+  readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly contract: `0x${string}`;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly tokenId?: bigint | undefined;
+}[], EnsEventError>;
+//#endregion
+export { type EnsEventError as GetEnsEventsError, type GetEnsEventsParameters, getEnsEvents };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/events/get-ens-events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/events/get-ens-events/index.ts"],"mappings":";;;;cA4Ca,cAIQ,UAJI;;;;;;;;;;;;;;;;;;;;;;;;;KAIJ"}

package/dist/actions/events/get-ens-events/index.js

@@ -0,0 +1,30 @@
+import { defineAction } from "../../../action/action.js";
+import { viemErrorToEffectError } from "../../../internal/errors/viem-error.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { getEnsEventContracts } from "../../../internal/events/contracts.js";
+import { matchesEnsEventFilters, normalizeEnsLog } from "../../../internal/events/normalize-event.js";
+import { Effect } from "effect";
+
+//#region src/actions/events/get-ens-events/index.ts
+const getEnsEventsEffect = Effect.fn("ensforge.getEnsEvents")(function* (config, parameters) {
+	const normalizedName = parameters.name === void 0 ? void 0 : yield* normalizeName.effect(parameters.name);
+	const contracts = getEnsEventContracts(config.deployments);
+	return (yield* Effect.tryPromise({
+		try: () => config.publicClient.getLogs({
+			address: contracts.map((contract) => contract.address),
+			fromBlock: parameters.fromBlock,
+			...parameters.toBlock === void 0 ? {} : { toBlock: parameters.toBlock }
+		}),
+		catch: (cause) => viemErrorToEffectError(cause, "getLogs")
+	})).map((log) => normalizeEnsLog(log, contracts)).filter((event) => event !== null).filter((event) => matchesEnsEventFilters(event, parameters, normalizedName)).sort((left, right) => {
+		const block = Number((left.blockNumber ?? 0n) - (right.blockNumber ?? 0n));
+		if (block !== 0) return block;
+		const transaction = (left.transactionIndex ?? 0) - (right.transactionIndex ?? 0);
+		return transaction !== 0 ? transaction : (left.logIndex ?? 0) - (right.logIndex ?? 0);
+	});
+});
+const getEnsEvents = defineAction(getEnsEventsEffect);
+
+//#endregion
+export { getEnsEvents };
+//# sourceMappingURL=index.js.map

package/dist/actions/events/get-ens-events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/events/get-ens-events/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { defineAction } from \"../../../action/action.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { viemErrorToEffectError } from \"../../../internal/errors/viem-error.js\";\nimport { getEnsEventContracts } from \"../../../internal/events/contracts.js\";\nimport {\n  matchesEnsEventFilters,\n  normalizeEnsLog,\n} from \"../../../internal/events/normalize-event.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { EnsEvent, EnsEventError, GetEnsEventsParameters } from \"../types.js\";\n\nconst getEnsEventsEffect = Effect.fn(\"ensforge.getEnsEvents\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetEnsEventsParameters,\n) {\n  const normalizedName =\n    parameters.name === undefined ? undefined : yield* normalizeName.effect(parameters.name);\n  const contracts = getEnsEventContracts(config.deployments);\n  const logs = yield* Effect.tryPromise({\n    try: () =>\n      config.publicClient.getLogs({\n        address: contracts.map((contract) => contract.address),\n        fromBlock: parameters.fromBlock,\n        ...(parameters.toBlock === undefined ? {} : { toBlock: parameters.toBlock }),\n      }),\n    catch: (cause) => viemErrorToEffectError(cause, \"getLogs\"),\n  });\n\n  const events = logs\n    .map((log) => normalizeEnsLog(log, contracts))\n    .filter((event): event is EnsEvent => event !== null)\n    .filter((event) => matchesEnsEventFilters(event, parameters, normalizedName));\n  // Array#toSorted is outside the package's ES2022 type target.\n  // oxlint-disable-next-line unicorn/no-array-sort\n  return events.sort((left: EnsEvent, right: EnsEvent) => {\n    const block = Number((left.blockNumber ?? 0n) - (right.blockNumber ?? 0n));\n    if (block !== 0) return block;\n    const transaction = (left.transactionIndex ?? 0) - (right.transactionIndex ?? 0);\n    return transaction !== 0 ? transaction : (left.logIndex ?? 0) - (right.logIndex ?? 0);\n  });\n});\n\nexport const getEnsEvents = defineAction<\n  GetEnsEventsParameters,\n  ReadonlyArray<EnsEvent>,\n  EnsEventError\n>(getEnsEventsEffect);\n\nexport type {\n  EnsEvent,\n  EnsEventError as GetEnsEventsError,\n  GetEnsEventsParameters,\n} from \"../types.js\";\n"],"mappings":";;;;;;;;AAaA,MAAM,qBAAqB,OAAO,GAAG,uBAAuB,CAAC,CAAC,WAC5D,QACA,YACA;CACA,MAAM,iBACJ,WAAW,SAAS,SAAY,SAAY,OAAO,cAAc,OAAO,WAAW,IAAI;CACzF,MAAM,YAAY,qBAAqB,OAAO,WAAW;CAiBzD,QANe,OAVK,OAAO,WAAW;EACpC,WACE,OAAO,aAAa,QAAQ;GAC1B,SAAS,UAAU,KAAK,aAAa,SAAS,OAAO;GACrD,WAAW,WAAW;GACtB,GAAI,WAAW,YAAY,SAAY,CAAC,IAAI,EAAE,SAAS,WAAW,QAAQ;EAC5E,CAAC;EACH,QAAQ,UAAU,uBAAuB,OAAO,SAAS;CAC3D,CAAC,EAEkB,CAChB,KAAK,QAAQ,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAC7C,QAAQ,UAA6B,UAAU,IAAI,CAAC,CACpD,QAAQ,UAAU,uBAAuB,OAAO,YAAY,cAAc,CAGjE,CAAC,CAAC,MAAM,MAAgB,UAAoB;EACtD,MAAM,QAAQ,QAAQ,KAAK,eAAe,OAAO,MAAM,eAAe,GAAG;EACzE,IAAI,UAAU,GAAG,OAAO;EACxB,MAAM,eAAe,KAAK,oBAAoB,MAAM,MAAM,oBAAoB;EAC9E,OAAO,gBAAgB,IAAI,eAAe,KAAK,YAAY,MAAM,MAAM,YAAY;CACrF,CAAC;AACH,CAAC;AAED,MAAa,eAAe,aAI1B,kBAAkB"}

package/dist/actions/events/get-name-history/index.d.ts

@@ -0,0 +1,36 @@
+import { EnsAction } from "../../../action/action.js";
+import { EnsEventError, GetNameHistoryParameters, NameHistory } from "../types.js";
+import "../../../index.js";
+//#region src/actions/events/get-name-history/index.d.ts
+declare const getNameHistory: EnsAction<GetNameHistoryParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly events: readonly {
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly blockNumber: bigint | null;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "commitment" | "registration" | "renewal" | "ownership" | "manager" | "resolver" | "records" | "subname" | "migration" | "other";
+    readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
+    readonly eventName: string;
+    readonly contract: `0x${string}`;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly tokenId?: bigint | undefined;
+  }[];
+}, EnsEventError>;
+//#endregion
+export { type EnsEventError as GetNameHistoryError, type GetNameHistoryParameters, getNameHistory };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/events/get-name-history/index.ts"],"mappings":";;;;cAiBa,gBAEZ,UAF0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE1B"}

package/dist/actions/events/get-name-history/index.js

@@ -0,0 +1,17 @@
+import { defineAction } from "../../../action/action.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { getEnsEvents } from "../get-ens-events/index.js";
+import { Effect } from "effect";
+
+//#region src/actions/events/get-name-history/index.ts
+const getNameHistoryEffect = Effect.fn("ensforge.getNameHistory")(function* (config, parameters) {
+	return {
+		name: yield* normalizeName.effect(parameters.name),
+		events: yield* getEnsEvents.effect(config, parameters)
+	};
+});
+const getNameHistory = defineAction(getNameHistoryEffect);
+
+//#endregion
+export { getNameHistory };
+//# sourceMappingURL=index.js.map

package/dist/actions/events/get-name-history/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/events/get-name-history/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { defineAction } from \"../../../action/action.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport { getEnsEvents } from \"../get-ens-events/index.js\";\nimport type { EnsEventError, GetNameHistoryParameters, NameHistory } from \"../types.js\";\n\nconst getNameHistoryEffect = Effect.fn(\"ensforge.getNameHistory\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetNameHistoryParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n  const events = yield* getEnsEvents.effect(config, parameters);\n  return { name, events } satisfies NameHistory;\n});\n\nexport const getNameHistory = defineAction<GetNameHistoryParameters, NameHistory, EnsEventError>(\n  getNameHistoryEffect,\n);\n\nexport type {\n  GetNameHistoryParameters,\n  NameHistory,\n  EnsEventError as GetNameHistoryError,\n} from \"../types.js\";\n"],"mappings":";;;;;;AAQA,MAAM,uBAAuB,OAAO,GAAG,yBAAyB,CAAC,CAAC,WAChE,QACA,YACA;CAGA,OAAO;EAAE,aAFW,cAAc,OAAO,WAAW,IAAI;EAEzC,eADO,aAAa,OAAO,QAAQ,UAAU;CACtC;AACxB,CAAC;AAED,MAAa,iBAAiB,aAC5B,oBACF"}

package/dist/actions/events/index.d.ts

@@ -0,0 +1,5 @@
+import { EnsEvent, EnsEventContractKind, EnsEventError, EnsEventKind, GetEnsEventsParameters, GetNameHistoryParameters, NameHistory, WatchEnsEventsParameters } from "./types.js";
+import { getEnsEvents } from "./get-ens-events/index.js";
+import { getNameHistory } from "./get-name-history/index.js";
+import { WatchEnsEvents, watchEnsEvents } from "./watch-ens-events/index.js";
+export { EnsEvent, EnsEventContractKind, type EnsEventError, EnsEventKind, type EnsEventError as GetEnsEventsError, type GetEnsEventsParameters, type EnsEventError as GetNameHistoryError, type GetNameHistoryParameters, NameHistory, type WatchEnsEvents, type EnsEventError as WatchEnsEventsError, type WatchEnsEventsParameters, getEnsEvents, getNameHistory, watchEnsEvents };

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

@@ -0,0 +1,89 @@
+import { ContractError } from "../../errors/contract-error.js";
+import { NameError } from "../../errors/name-error.js";
+import { RpcError } from "../../errors/rpc-error.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { Bytes32 } from "../../schemas/hash.js";
+import { Schema } from "effect";
+//#region src/actions/events/types.d.ts
+type EnsEventError = ContractError | NameError | RpcError;
+declare const EnsEventKind: Schema.Literals<readonly ["commitment", "registration", "renewal", "ownership", "manager", "resolver", "records", "subname", "migration", "other"]>;
+type EnsEventKind = typeof EnsEventKind.Type;
+declare const EnsEventContractKind: Schema.Literals<readonly ["registrar", "registry", "name-wrapper", "resolver", "migration-controller"]>;
+type EnsEventContractKind = typeof EnsEventContractKind.Type;
+declare const EnsEvent: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["commitment", "registration", "renewal", "ownership", "manager", "resolver", "records", "subname", "migration", "other"]>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly contractKind: Schema.Literals<readonly ["registrar", "registry", "name-wrapper", "resolver", "migration-controller"]>;
+  readonly eventName: Schema.String;
+  readonly contract: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly blockNumber: Schema.NullOr<Schema.BigInt>;
+  readonly transactionHash: Schema.NullOr<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  readonly transactionIndex: Schema.NullOr<Schema.Int>;
+  readonly logIndex: Schema.NullOr<Schema.Int>;
+  readonly removed: Schema.Boolean;
+  readonly name: Schema.optional<Schema.brand<Schema.String, "NormalizedName">>;
+  readonly label: Schema.optional<Schema.String>;
+  readonly node: Schema.optional<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  readonly owner: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly from: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly to: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly resolver: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly tokenId: Schema.optional<Schema.BigInt>;
+  readonly commitment: Schema.optional<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+  readonly raw: Schema.Struct<{
+    readonly topics: Schema.$Array<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+    readonly data: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+    readonly args: Schema.Unknown;
+  }>;
+}>;
+type EnsEvent = typeof EnsEvent.Type;
+type GetEnsEventsParameters = {
+  readonly fromBlock: bigint;
+  readonly toBlock?: bigint;
+  readonly kinds?: ReadonlyArray<EnsEventKind>;
+  readonly name?: string;
+  readonly account?: EthereumAddress;
+  readonly commitment?: Bytes32;
+};
+type WatchEnsEventsParameters = Omit<GetEnsEventsParameters, "fromBlock" | "toBlock"> & {
+  readonly fromBlock?: bigint;
+  readonly pollingInterval?: number;
+};
+type GetNameHistoryParameters = {
+  readonly name: string;
+  readonly fromBlock: bigint;
+  readonly toBlock?: bigint;
+};
+declare const NameHistory: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly events: Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["commitment", "registration", "renewal", "ownership", "manager", "resolver", "records", "subname", "migration", "other"]>;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly contractKind: Schema.Literals<readonly ["registrar", "registry", "name-wrapper", "resolver", "migration-controller"]>;
+    readonly eventName: Schema.String;
+    readonly contract: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly blockNumber: Schema.NullOr<Schema.BigInt>;
+    readonly transactionHash: Schema.NullOr<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+    readonly transactionIndex: Schema.NullOr<Schema.Int>;
+    readonly logIndex: Schema.NullOr<Schema.Int>;
+    readonly removed: Schema.Boolean;
+    readonly name: Schema.optional<Schema.brand<Schema.String, "NormalizedName">>;
+    readonly label: Schema.optional<Schema.String>;
+    readonly node: Schema.optional<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+    readonly owner: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly from: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly to: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly resolver: Schema.optional<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly tokenId: Schema.optional<Schema.BigInt>;
+    readonly commitment: Schema.optional<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+    readonly raw: Schema.Struct<{
+      readonly topics: Schema.$Array<Schema.TemplateLiteral<readonly ["0x", Schema.String]>>;
+      readonly data: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+      readonly args: Schema.Unknown;
+    }>;
+  }>>;
+}>;
+type NameHistory = typeof NameHistory.Type;
+//#endregion
+export { EnsEvent, EnsEventContractKind, EnsEventError, EnsEventKind, GetEnsEventsParameters, GetNameHistoryParameters, NameHistory, WatchEnsEventsParameters };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/actions/events/types.ts"],"mappings":";;;;;;;KAWY,gBAAgB,gBAAgB,YAAY;cAE3C,cAAY,OAAA;KAYb,sBAAsB,aAAa;cAElC,sBAAoB,OAAA;KAOrB,8BAA8B,qBAAqB;cAElD,UAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BT,kBAAkB,SAAS;KAE3B;WACD;WACA;WACA,QAAQ,cAAc;WACtB;WACA,UAAU;WACV,aAAa;;KAGZ,2BAA2B,KAAK;WACjC;WACA;;KAGC;WACD;WACA;WACA;;cAGE,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIZ,qBAAqB,YAAY"}

package/dist/actions/events/types.js

@@ -0,0 +1,61 @@
+import { Hex } from "../../schemas/hex.js";
+import { NormalizedName } from "../../schemas/name.js";
+import { Bytes32 } from "../../schemas/hash.js";
+import { EnsProtocol } from "../../schemas/protocol.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { Schema } from "effect";
+
+//#region src/actions/events/types.ts
+const EnsEventKind = Schema.Literals([
+	"commitment",
+	"registration",
+	"renewal",
+	"ownership",
+	"manager",
+	"resolver",
+	"records",
+	"subname",
+	"migration",
+	"other"
+]);
+const EnsEventContractKind = Schema.Literals([
+	"registrar",
+	"registry",
+	"name-wrapper",
+	"resolver",
+	"migration-controller"
+]);
+const EnsEvent = Schema.Struct({
+	kind: EnsEventKind,
+	protocol: EnsProtocol,
+	contractKind: EnsEventContractKind,
+	eventName: Schema.String,
+	contract: EthereumAddress,
+	blockNumber: Schema.NullOr(Schema.BigInt),
+	transactionHash: Schema.NullOr(Hex),
+	transactionIndex: Schema.NullOr(Schema.Int),
+	logIndex: Schema.NullOr(Schema.Int),
+	removed: Schema.Boolean,
+	name: Schema.optional(NormalizedName),
+	label: Schema.optional(Schema.String),
+	node: Schema.optional(Bytes32),
+	owner: Schema.optional(EthereumAddress),
+	from: Schema.optional(EthereumAddress),
+	to: Schema.optional(EthereumAddress),
+	resolver: Schema.optional(EthereumAddress),
+	tokenId: Schema.optional(Schema.BigInt),
+	commitment: Schema.optional(Bytes32),
+	raw: Schema.Struct({
+		topics: Schema.Array(Hex),
+		data: Hex,
+		args: Schema.Unknown
+	})
+});
+const NameHistory = Schema.Struct({
+	name: NormalizedName,
+	events: Schema.Array(EnsEvent)
+});
+
+//#endregion
+export { EnsEvent, EnsEventContractKind, EnsEventKind, NameHistory };
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/actions/events/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\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 { Bytes32 } from \"../../schemas/hash.js\";\nimport { Hex } from \"../../schemas/hex.js\";\nimport { EthereumAddress } from \"../../schemas/identity.js\";\nimport { NormalizedName } from \"../../schemas/name.js\";\nimport { EnsProtocol } from \"../../schemas/protocol.js\";\n\nexport type EnsEventError = ContractError | NameError | RpcError;\n\nexport const EnsEventKind = Schema.Literals([\n  \"commitment\",\n  \"registration\",\n  \"renewal\",\n  \"ownership\",\n  \"manager\",\n  \"resolver\",\n  \"records\",\n  \"subname\",\n  \"migration\",\n  \"other\",\n]);\nexport type EnsEventKind = typeof EnsEventKind.Type;\n\nexport const EnsEventContractKind = Schema.Literals([\n  \"registrar\",\n  \"registry\",\n  \"name-wrapper\",\n  \"resolver\",\n  \"migration-controller\",\n]);\nexport type EnsEventContractKind = typeof EnsEventContractKind.Type;\n\nexport const EnsEvent = Schema.Struct({\n  kind: EnsEventKind,\n  protocol: EnsProtocol,\n  contractKind: EnsEventContractKind,\n  eventName: Schema.String,\n  contract: EthereumAddress,\n  blockNumber: Schema.NullOr(Schema.BigInt),\n  transactionHash: Schema.NullOr(Hex),\n  transactionIndex: Schema.NullOr(Schema.Int),\n  logIndex: Schema.NullOr(Schema.Int),\n  removed: Schema.Boolean,\n  name: Schema.optional(NormalizedName),\n  label: Schema.optional(Schema.String),\n  node: Schema.optional(Bytes32),\n  owner: Schema.optional(EthereumAddress),\n  from: Schema.optional(EthereumAddress),\n  to: Schema.optional(EthereumAddress),\n  resolver: Schema.optional(EthereumAddress),\n  tokenId: Schema.optional(Schema.BigInt),\n  commitment: Schema.optional(Bytes32),\n  raw: Schema.Struct({\n    topics: Schema.Array(Hex),\n    data: Hex,\n    args: Schema.Unknown,\n  }),\n});\nexport type EnsEvent = typeof EnsEvent.Type;\n\nexport type GetEnsEventsParameters = {\n  readonly fromBlock: bigint;\n  readonly toBlock?: bigint;\n  readonly kinds?: ReadonlyArray<EnsEventKind>;\n  readonly name?: string;\n  readonly account?: EthereumAddress;\n  readonly commitment?: Bytes32;\n};\n\nexport type WatchEnsEventsParameters = Omit<GetEnsEventsParameters, \"fromBlock\" | \"toBlock\"> & {\n  readonly fromBlock?: bigint;\n  readonly pollingInterval?: number;\n};\n\nexport type GetNameHistoryParameters = {\n  readonly name: string;\n  readonly fromBlock: bigint;\n  readonly toBlock?: bigint;\n};\n\nexport const NameHistory = Schema.Struct({\n  name: NormalizedName,\n  events: Schema.Array(EnsEvent),\n});\nexport type NameHistory = typeof NameHistory.Type;\n"],"mappings":";;;;;;;;AAaA,MAAa,eAAe,OAAO,SAAS;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAGD,MAAa,uBAAuB,OAAO,SAAS;CAClD;CACA;CACA;CACA;CACA;AACF,CAAC;AAGD,MAAa,WAAW,OAAO,OAAO;CACpC,MAAM;CACN,UAAU;CACV,cAAc;CACd,WAAW,OAAO;CAClB,UAAU;CACV,aAAa,OAAO,OAAO,OAAO,MAAM;CACxC,iBAAiB,OAAO,OAAO,GAAG;CAClC,kBAAkB,OAAO,OAAO,OAAO,GAAG;CAC1C,UAAU,OAAO,OAAO,OAAO,GAAG;CAClC,SAAS,OAAO;CAChB,MAAM,OAAO,SAAS,cAAc;CACpC,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,MAAM,OAAO,SAAS,OAAO;CAC7B,OAAO,OAAO,SAAS,eAAe;CACtC,MAAM,OAAO,SAAS,eAAe;CACrC,IAAI,OAAO,SAAS,eAAe;CACnC,UAAU,OAAO,SAAS,eAAe;CACzC,SAAS,OAAO,SAAS,OAAO,MAAM;CACtC,YAAY,OAAO,SAAS,OAAO;CACnC,KAAK,OAAO,OAAO;EACjB,QAAQ,OAAO,MAAM,GAAG;EACxB,MAAM;EACN,MAAM,OAAO;CACf,CAAC;AACH,CAAC;AAuBD,MAAa,cAAc,OAAO,OAAO;CACvC,MAAM;CACN,QAAQ,OAAO,MAAM,QAAQ;AAC/B,CAAC"}

package/dist/actions/events/watch-ens-events/index.d.ts

@@ -0,0 +1,12 @@
+import { EnsforgeConfig } from "../../../config/config.js";
+import { EnsEvent, EnsEventError, WatchEnsEventsParameters } from "../types.js";
+import { Stream } from "effect";
+//#region src/actions/events/watch-ens-events/index.d.ts
+interface WatchEnsEvents {
+  (config: EnsforgeConfig, parameters: WatchEnsEventsParameters, onEvent: (event: EnsEvent) => void, onError: (error: EnsEventError) => void): Promise<() => void>;
+  readonly stream: (config: EnsforgeConfig, parameters: WatchEnsEventsParameters) => Stream.Stream<EnsEvent, EnsEventError>;
+}
+declare const watchEnsEvents: WatchEnsEvents;
+//#endregion
+export { WatchEnsEvents, type EnsEventError as WatchEnsEventsError, type WatchEnsEventsParameters, watchEnsEvents };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/events/watch-ens-events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/events/watch-ens-events/index.ts"],"mappings":";;;;UAciB;GAEb,QAAQ,gBACR,YAAY,0BACZ,UAAU,OAAO,mBACjB,UAAU,OAAO,yBAChB;WACM,SACP,QAAQ,gBACR,YAAY,6BACT,OAAO,OAAO,UAAU;;cAgGlB,gBAOR"}