@ensforge/core 0.0.0

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

@@ -0,0 +1,418 @@
+import { EnsProtocol } from "../../schemas/protocol.js";
+import { ConfirmationPolicy } from "../../config/write-options.js";
+import { EnsAction } from "../../action/action.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 { NameState } from "../name/get-name-state/types.js";
+import { Bytes32 } from "../../schemas/hash.js";
+import { NormalizedName } from "../../schemas/name.js";
+import { Hex as Hex$1 } from "../../schemas/hex.js";
+import { SetRecordInput } from "../records/set-records/types.js";
+import { Schema } from "effect";
+import { Account, Address, WalletClient } from "viem";
+//#region src/actions/registration/types.d.ts
+type RegistrationReadError = CodecError | ContractError | NameError | RpcError;
+type RegistrationNameParameters = {
+  readonly name: string;
+  readonly duration: bigint;
+} & BlockParameters;
+type RegistrationPriceParameters = RegistrationNameParameters & {
+  readonly paymentToken?: EthereumAddress;
+};
+declare const NativePaymentCurrency: Schema.Struct<{
+  readonly kind: Schema.Literal<"native">;
+  readonly symbol: Schema.Literal<"ETH">;
+  readonly decimals: Schema.Literal<18>;
+}>;
+declare const Erc20PaymentCurrency: Schema.Struct<{
+  readonly kind: Schema.Literal<"erc20">;
+  readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly symbol: Schema.String;
+  readonly decimals: Schema.Int;
+}>;
+declare const PaymentCurrency: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"native">;
+  readonly symbol: Schema.Literal<"ETH">;
+  readonly decimals: Schema.Literal<18>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"erc20">;
+  readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly symbol: Schema.String;
+  readonly decimals: Schema.Int;
+}>]>;
+type PaymentCurrency = typeof PaymentCurrency.Type;
+declare const RegistrationPriceResult: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"available">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly duration: Schema.BigInt;
+  readonly base: Schema.BigInt;
+  readonly premium: Schema.BigInt;
+  readonly total: Schema.BigInt;
+  readonly currency: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"native">;
+    readonly symbol: Schema.Literal<"ETH">;
+    readonly decimals: Schema.Literal<18>;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"erc20">;
+    readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly symbol: Schema.String;
+    readonly decimals: Schema.Int;
+  }>]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unavailable">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literal<"NAME_UNAVAILABLE">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"payment-token-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported-payment-token">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly paymentToken: Schema.declare<`0x${string}`, `0x${string}`>;
+}>]>;
+type RegistrationPriceResult = typeof RegistrationPriceResult.Type;
+declare const RenewalRoute: Schema.Literals<readonly ["v1-controller", "v2-registrar", "v1-renewer"]>;
+type RenewalRoute = typeof RenewalRoute.Type;
+declare const RenewalPriceResult: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"renewable">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly route: Schema.Literals<readonly ["v1-controller", "v2-registrar", "v1-renewer"]>;
+  readonly renewer: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly duration: Schema.BigInt;
+  readonly price: Schema.BigInt;
+  readonly currency: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"native">;
+    readonly symbol: Schema.Literal<"ETH">;
+    readonly decimals: Schema.Literal<18>;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"erc20">;
+    readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly symbol: Schema.String;
+    readonly decimals: Schema.Int;
+  }>]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"not-renewable">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literal<"NAME_NOT_RENEWABLE">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"payment-token-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported-payment-token">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly paymentToken: Schema.declare<`0x${string}`, `0x${string}`>;
+}>]>;
+type RenewalPriceResult = typeof RenewalPriceResult.Type;
+declare const RegistrationParameters: Schema.Union<readonly [Schema.Struct<{
+  readonly protocol: Schema.Literal<"v1">;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly priceOracle: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly minimumRegistrationDuration: Schema.BigInt;
+  readonly minimumRenewalDuration: Schema.BigInt;
+  readonly minimumCommitmentAge: Schema.BigInt;
+  readonly maximumCommitmentAge: Schema.BigInt;
+  readonly payment: Schema.Struct<{
+    readonly kind: Schema.Literal<"native">;
+  }>;
+}>, Schema.Struct<{
+  readonly protocol: Schema.Literal<"v2">;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly priceOracle: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly minimumRegistrationDuration: Schema.BigInt;
+  readonly minimumRenewalDuration: Schema.BigInt;
+  readonly minimumCommitmentAge: Schema.BigInt;
+  readonly maximumCommitmentAge: Schema.BigInt;
+  readonly payment: Schema.Struct<{
+    readonly kind: Schema.Literal<"erc20">;
+    readonly enumerable: Schema.Literal<false>;
+  }>;
+}>]>;
+type RegistrationParameters = typeof RegistrationParameters.Type;
+declare const PaymentTokenSupport: Schema.Union<readonly [Schema.Struct<{
+  readonly protocol: Schema.Literal<"v1">;
+  readonly supported: Schema.Literal<false>;
+  readonly reason: Schema.Literal<"NATIVE_PAYMENT_ONLY">;
+}>, Schema.Struct<{
+  readonly protocol: Schema.Literal<"v2">;
+  readonly supported: Schema.Literal<false>;
+  readonly token: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly reason: Schema.Literal<"PAYMENT_TOKEN_NOT_SUPPORTED">;
+}>, Schema.Struct<{
+  readonly protocol: Schema.Literal<"v2">;
+  readonly supported: Schema.Literal<true>;
+  readonly token: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly symbol: Schema.String;
+  readonly decimals: Schema.Int;
+}>]>;
+type PaymentTokenSupport = typeof PaymentTokenSupport.Type;
+type RegistrationCommitmentParameters = RegistrationNameParameters & {
+  readonly owner: EthereumAddress;
+  readonly secret: Bytes32;
+  readonly resolver?: EthereumAddress;
+  readonly subregistry?: EthereumAddress;
+  readonly records?: ReadonlyArray<Hex$1>;
+  readonly reverseRecord?: 0 | 1 | 2;
+  readonly referrer?: Bytes32;
+};
+declare const RegistrationCommitment: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly commitment: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+}>;
+type RegistrationCommitment = typeof RegistrationCommitment.Type;
+declare const CommitmentStatus: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"not-found">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"pending">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly submittedAt: Schema.BigInt;
+  readonly readyAt: Schema.BigInt;
+  readonly expiresAt: Schema.BigInt;
+  readonly remainingSeconds: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"ready">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly submittedAt: Schema.BigInt;
+  readonly readyAt: Schema.BigInt;
+  readonly expiresAt: Schema.BigInt;
+  readonly remainingSeconds: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"expired">;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly submittedAt: Schema.BigInt;
+  readonly readyAt: Schema.BigInt;
+  readonly expiresAt: Schema.BigInt;
+}>]>;
+type CommitmentStatus = typeof CommitmentStatus.Type;
+declare const RegistrationPlan: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"unavailable">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"payment-token-required">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unsupported-payment-token">;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly paymentToken: Schema.declare<`0x${string}`, `0x${string}`>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literals<readonly ["commitment-required", "commitment-pending", "ready", "commitment-expired"]>;
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly parameters: Schema.Union<readonly [Schema.Struct<{
+    readonly protocol: Schema.Literal<"v1">;
+    readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly priceOracle: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly minimumRegistrationDuration: Schema.BigInt;
+    readonly minimumRenewalDuration: Schema.BigInt;
+    readonly minimumCommitmentAge: Schema.BigInt;
+    readonly maximumCommitmentAge: Schema.BigInt;
+    readonly payment: Schema.Struct<{
+      readonly kind: Schema.Literal<"native">;
+    }>;
+  }>, Schema.Struct<{
+    readonly protocol: Schema.Literal<"v2">;
+    readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly priceOracle: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly minimumRegistrationDuration: Schema.BigInt;
+    readonly minimumRenewalDuration: Schema.BigInt;
+    readonly minimumCommitmentAge: Schema.BigInt;
+    readonly maximumCommitmentAge: Schema.BigInt;
+    readonly payment: Schema.Struct<{
+      readonly kind: Schema.Literal<"erc20">;
+      readonly enumerable: Schema.Literal<false>;
+    }>;
+  }>]>;
+  readonly price: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"available">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly duration: Schema.BigInt;
+    readonly base: Schema.BigInt;
+    readonly premium: Schema.BigInt;
+    readonly total: Schema.BigInt;
+    readonly currency: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"native">;
+      readonly symbol: Schema.Literal<"ETH">;
+      readonly decimals: Schema.Literal<18>;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"erc20">;
+      readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+      readonly symbol: Schema.String;
+      readonly decimals: Schema.Int;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unavailable">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly reason: Schema.Literal<"NAME_UNAVAILABLE">;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"payment-token-required">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unsupported-payment-token">;
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly paymentToken: Schema.declare<`0x${string}`, `0x${string}`>;
+  }>]>;
+  readonly commitment: Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "NormalizedName">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly registrar: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly commitment: Schema.TemplateLiteral<readonly ["0x", Schema.String]>;
+  }>;
+  readonly commitmentStatus: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"not-found">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly submittedAt: Schema.BigInt;
+    readonly readyAt: Schema.BigInt;
+    readonly expiresAt: Schema.BigInt;
+    readonly remainingSeconds: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"ready">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly submittedAt: Schema.BigInt;
+    readonly readyAt: Schema.BigInt;
+    readonly expiresAt: Schema.BigInt;
+    readonly remainingSeconds: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"expired">;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly submittedAt: Schema.BigInt;
+    readonly readyAt: Schema.BigInt;
+    readonly expiresAt: Schema.BigInt;
+  }>]>;
+}>]>;
+type RegistrationPlan = typeof RegistrationPlan.Type;
+interface CommitNameParameters {
+  readonly commitment: Bytes32;
+}
+interface ApprovePaymentTokenParameters {
+  readonly paymentToken: string;
+  readonly amount: bigint;
+}
+type RegistrationCommitmentWriteParameters = Omit<RegistrationCommitmentParameters, "blockNumber" | "blockTag">;
+type CompleteRegistrationParameters = RegistrationCommitmentWriteParameters & {
+  readonly paymentToken?: EthereumAddress;
+  readonly maxPrice?: bigint;
+};
+interface RegistrationWalletParameters {
+  readonly walletClient?: WalletClient;
+  readonly account?: Account | Address;
+  readonly mode?: WriteMode;
+  readonly confirmation?: ConfirmationPolicy;
+}
+type RegisterNameParameters = Omit<RegistrationCommitmentWriteParameters, "records"> & RegistrationWalletParameters & {
+  readonly paymentToken?: EthereumAddress;
+  readonly maxPrice?: bigint;
+  readonly records?: ReadonlyArray<SetRecordInput>;
+  readonly resume?: RegisterNameResult;
+};
+type AvailableRegistrationPrice = Extract<RegistrationPriceResult, {
+  status: "available";
+}>;
+interface RegisterNameResult {
+  readonly status: "waiting" | "partial" | "submitted" | "completed";
+  readonly name: NormalizedName;
+  readonly protocol: typeof EnsProtocol.Type;
+  readonly commitment: Bytes32;
+  readonly committedByWorkflow: boolean;
+  readonly paymentApprovalIncluded: boolean;
+  readonly readyAt: bigint | null;
+  readonly expiresAt: bigint | null;
+  readonly nextActionAt: bigint | null;
+  readonly price: AvailableRegistrationPrice;
+  readonly write: WritePlanProgress;
+  readonly finalState: NameState | null;
+}
+type RegisterNamesEntryParameters = Omit<RegisterNameParameters, "resume" | "walletClient" | "account" | "mode" | "confirmation">;
+interface RegisterNamesParameters extends RegistrationWalletParameters {
+  readonly registrations: ReadonlyArray<RegisterNamesEntryParameters>;
+  readonly resume?: RegisterNamesResult;
+}
+interface RegisterNamesResult {
+  readonly status: "waiting" | "partial" | "submitted" | "completed";
+  readonly registrations: ReadonlyArray<RegisterNameResult>;
+  readonly nextActionAt: bigint | null;
+}
+type RegistrationWriteError = WriteError;
+type RegistrationWriteResult = CallExecutionResult;
+type RegistrationWriteIntent = EnsWriteIntent<RegistrationWriteResult, RegistrationWriteError>;
+type RenewNameCallParameters = {
+  readonly name: string;
+  readonly duration: bigint;
+  readonly paymentToken?: EthereumAddress;
+  readonly maxPrice?: bigint;
+  readonly referrer?: Bytes32;
+};
+interface ApproveRenewalPaymentParameters {
+  readonly name: string;
+  readonly duration: bigint;
+  readonly paymentToken: string;
+  readonly amount: bigint;
+}
+type RenewNameParameters = RenewNameCallParameters & RegistrationWalletParameters & {
+  readonly resume?: RenewNameResult;
+};
+interface RenewalApproval {
+  readonly required: boolean;
+  readonly spender: EthereumAddress | null;
+  readonly token: EthereumAddress | null;
+  readonly amount: bigint;
+}
+interface RenewNameResult {
+  readonly status: "completed" | "partial";
+  readonly name: NormalizedName;
+  readonly protocol: typeof EnsProtocol.Type;
+  readonly route: RenewalRoute;
+  readonly duration: bigint;
+  readonly previousExpiry: bigint | null;
+  readonly newExpiry: bigint | null;
+  readonly price: bigint;
+  readonly currency: PaymentCurrency;
+  readonly approval: RenewalApproval;
+  readonly write: WritePlanProgress;
+  readonly finalState: NameState | null;
+}
+interface RenewNameAction extends EnsAction<RenewNameParameters, RenewNameResult, WriteError> {
+  readonly call: (parameters: RenewNameCallParameters) => EnsWriteIntent<CallExecutionResult, WriteError>;
+}
+type RenewNamesEntryParameters = RenewNameCallParameters;
+interface RenewNamesParameters extends RegistrationWalletParameters {
+  readonly renewals: ReadonlyArray<RenewNamesEntryParameters>;
+  readonly maxTotalPrice?: bigint;
+  readonly resume?: RenewNamesResult;
+}
+interface RenewNamesResult {
+  readonly status: "completed" | "partial";
+  readonly renewals: ReadonlyArray<Omit<RenewNameResult, "write" | "status" | "approval" | "finalState"> & {
+    readonly newExpiry: bigint | null;
+    readonly finalState: NameState | null;
+  }>;
+  readonly approvals: ReadonlyArray<RenewalApproval>;
+  readonly totalPrice: bigint;
+  readonly write: WritePlanProgress;
+}
+//#endregion
+export { ApprovePaymentTokenParameters, ApproveRenewalPaymentParameters, AvailableRegistrationPrice, CommitNameParameters, CommitmentStatus, CompleteRegistrationParameters, Erc20PaymentCurrency, NativePaymentCurrency, PaymentCurrency, PaymentTokenSupport, RegisterNameParameters, RegisterNameResult, RegisterNamesEntryParameters, RegisterNamesParameters, RegisterNamesResult, RegistrationCommitment, RegistrationCommitmentParameters, RegistrationNameParameters, RegistrationParameters, RegistrationPlan, RegistrationPriceParameters, RegistrationPriceResult, RegistrationReadError, RegistrationWriteError, RegistrationWriteIntent, RegistrationWriteResult, RenewNameAction, RenewNameCallParameters, RenewNameParameters, RenewNameResult, RenewNamesEntryParameters, RenewNamesParameters, RenewNamesResult, RenewalApproval, RenewalPriceResult, RenewalRoute };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/actions/registration/types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KA0BY,wBAAwB,aAAa,gBAAgB,YAAY;KAEjE;WACD;WACA;IACP;KAEQ,8BAA8B;WAC/B,eAAe;;cAGb,uBAAqB,OAAA;;;;;cAMrB,sBAAoB,OAAA;;;;;;cAOpB,iBAAe,OAAA,gBAAA,OAAA;;;;;;;;;;KAChB,yBAAyB,gBAAgB;cAexC,yBAAuB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqBxB,iCAAiC,wBAAwB;cAExD,cAAY,OAAA;KACb,sBAAsB,aAAa;cAElC,oBAAkB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoBnB,4BAA4B,mBAAmB;cAE9C,wBAAsB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;KAsBvB,gCAAgC,uBAAuB;cAEtD,qBAAmB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;KAoBpB,6BAA6B,oBAAoB;KAEjD,mCAAmC;WACpC,OAAO;WACP,QAAQ;WACR,WAAW;WACX,cAAc;WACd,UAAU,cAAc;WACxB;WACA,WAAW;;cAGT,wBAAsB,OAAA;;;;;;KAMvB,gCAAgC,uBAAuB;cAEtD,kBAAgB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;KA0BjB,0BAA0B,iBAAiB;cAE1C,kBAAgB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsBjB,0BAA0B,iBAAiB;UAEtC;WACN,YAAY;;UAGN;WACN;WACA;;KAGN,wCAAwC,KAC3C;KAIU,iCAAiC;WAClC,eAAe;WACf;;UAGD;WACC,eAAe;WACf,UAAU,UAAU;WACpB,OAAO;WACP,eAAe;;KAGd,yBAAyB,KAAK,oDACxC;WACW,eAAe;WACf;WACA,UAAU,cAAc;WACxB,SAAS;;KAGV,6BAA6B,QAAQ;EAA2B;;UAE3D;WACN;WACA,MAAM;WACN,iBAAiB,YAAY;WAC7B,YAAY;WACZ;WACA;WACA;WACA;WACA;WACA,OAAO;WACP,OAAO;WACP,YAAY;;KAGX,+BAA+B,KACzC;UAIe,gCAAgC;WACtC,eAAe,cAAc;WAC7B,SAAS;;UAGH;WACN;WACA,eAAe,cAAc;WAC7B;;KAGC,yBAAyB;KACzB,0BAA0B;KAC1B,0BAA0B,eACpC,yBACA;KAGU;WACD;WACA;WACA,eAAe;WACf;WACA,WAAW;;UAGL;WACN;WACA;WACA;WACA;;KAGC,sBAAsB,0BAChC;WACW,SAAS;;UAGL;WACN;WACA,SAAS;WACT,OAAO;WACP;;UAGM;WACN;WACA,MAAM;WACN,iBAAiB,YAAY;WAC7B,OAAO;WACP;WACA;WACA;WACA;WACA,UAAU;WACV,UAAU;WACV,OAAO;WACP,YAAY;;UAGN,wBAAwB,UACvC,qBACA,iBACA;WAES,OACP,YAAY,4BACT,eAAe,qBAAqB;;KAG/B,4BAA4B;UAEvB,6BAA6B;WACnC,UAAU,cAAc;WACxB;WACA,SAAS;;UAGH;WACN;WACA,UAAU,cACjB,KAAK;aACM;aACA,YAAY;;WAGhB,WAAW,cAAc;WACzB;WACA,OAAO"}

package/dist/actions/registration/types.js

@@ -0,0 +1,185 @@
+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/registration/types.ts
+const NativePaymentCurrency = Schema.Struct({
+	kind: Schema.Literal("native"),
+	symbol: Schema.Literal("ETH"),
+	decimals: Schema.Literal(18)
+});
+const Erc20PaymentCurrency = Schema.Struct({
+	kind: Schema.Literal("erc20"),
+	address: EthereumAddress,
+	symbol: Schema.String,
+	decimals: Schema.Int
+});
+const PaymentCurrency = Schema.Union([NativePaymentCurrency, Erc20PaymentCurrency]);
+const PaymentTokenRequired = Schema.Struct({
+	status: Schema.Literal("payment-token-required"),
+	name: NormalizedName,
+	protocol: EnsProtocol
+});
+const UnsupportedPaymentToken = Schema.Struct({
+	status: Schema.Literal("unsupported-payment-token"),
+	name: NormalizedName,
+	protocol: EnsProtocol,
+	paymentToken: EthereumAddress
+});
+const RegistrationPriceResult = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("available"),
+		name: NormalizedName,
+		protocol: EnsProtocol,
+		registrar: EthereumAddress,
+		duration: Schema.BigInt,
+		base: Schema.BigInt,
+		premium: Schema.BigInt,
+		total: Schema.BigInt,
+		currency: PaymentCurrency
+	}),
+	Schema.Struct({
+		status: Schema.Literal("unavailable"),
+		name: NormalizedName,
+		protocol: EnsProtocol,
+		reason: Schema.Literal("NAME_UNAVAILABLE")
+	}),
+	PaymentTokenRequired,
+	UnsupportedPaymentToken
+]);
+const RenewalRoute = Schema.Literals([
+	"v1-controller",
+	"v2-registrar",
+	"v1-renewer"
+]);
+const RenewalPriceResult = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("renewable"),
+		name: NormalizedName,
+		protocol: EnsProtocol,
+		route: RenewalRoute,
+		renewer: EthereumAddress,
+		duration: Schema.BigInt,
+		price: Schema.BigInt,
+		currency: PaymentCurrency
+	}),
+	Schema.Struct({
+		status: Schema.Literal("not-renewable"),
+		name: NormalizedName,
+		protocol: EnsProtocol,
+		reason: Schema.Literal("NAME_NOT_RENEWABLE")
+	}),
+	PaymentTokenRequired,
+	UnsupportedPaymentToken
+]);
+const RegistrationParameters = Schema.Union([Schema.Struct({
+	protocol: Schema.Literal("v1"),
+	registrar: EthereumAddress,
+	priceOracle: EthereumAddress,
+	minimumRegistrationDuration: Schema.BigInt,
+	minimumRenewalDuration: Schema.BigInt,
+	minimumCommitmentAge: Schema.BigInt,
+	maximumCommitmentAge: Schema.BigInt,
+	payment: Schema.Struct({ kind: Schema.Literal("native") })
+}), Schema.Struct({
+	protocol: Schema.Literal("v2"),
+	registrar: EthereumAddress,
+	priceOracle: EthereumAddress,
+	minimumRegistrationDuration: Schema.BigInt,
+	minimumRenewalDuration: Schema.BigInt,
+	minimumCommitmentAge: Schema.BigInt,
+	maximumCommitmentAge: Schema.BigInt,
+	payment: Schema.Struct({
+		kind: Schema.Literal("erc20"),
+		enumerable: Schema.Literal(false)
+	})
+})]);
+const PaymentTokenSupport = Schema.Union([
+	Schema.Struct({
+		protocol: Schema.Literal("v1"),
+		supported: Schema.Literal(false),
+		reason: Schema.Literal("NATIVE_PAYMENT_ONLY")
+	}),
+	Schema.Struct({
+		protocol: Schema.Literal("v2"),
+		supported: Schema.Literal(false),
+		token: EthereumAddress,
+		reason: Schema.Literal("PAYMENT_TOKEN_NOT_SUPPORTED")
+	}),
+	Schema.Struct({
+		protocol: Schema.Literal("v2"),
+		supported: Schema.Literal(true),
+		token: EthereumAddress,
+		symbol: Schema.String,
+		decimals: Schema.Int
+	})
+]);
+const RegistrationCommitment = Schema.Struct({
+	name: NormalizedName,
+	protocol: EnsProtocol,
+	registrar: EthereumAddress,
+	commitment: Bytes32
+});
+const CommitmentStatus = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("not-found"),
+		protocol: EnsProtocol
+	}),
+	Schema.Struct({
+		status: Schema.Literal("pending"),
+		protocol: EnsProtocol,
+		submittedAt: Schema.BigInt,
+		readyAt: Schema.BigInt,
+		expiresAt: Schema.BigInt,
+		remainingSeconds: Schema.BigInt
+	}),
+	Schema.Struct({
+		status: Schema.Literal("ready"),
+		protocol: EnsProtocol,
+		submittedAt: Schema.BigInt,
+		readyAt: Schema.BigInt,
+		expiresAt: Schema.BigInt,
+		remainingSeconds: Schema.BigInt
+	}),
+	Schema.Struct({
+		status: Schema.Literal("expired"),
+		protocol: EnsProtocol,
+		submittedAt: Schema.BigInt,
+		readyAt: Schema.BigInt,
+		expiresAt: Schema.BigInt
+	})
+]);
+const RegistrationPlan = Schema.Union([
+	Schema.Struct({
+		status: Schema.Literal("unavailable"),
+		name: NormalizedName
+	}),
+	Schema.Struct({
+		status: Schema.Literal("payment-token-required"),
+		name: NormalizedName
+	}),
+	Schema.Struct({
+		status: Schema.Literal("unsupported-payment-token"),
+		name: NormalizedName,
+		paymentToken: EthereumAddress
+	}),
+	Schema.Struct({
+		status: Schema.Literals([
+			"commitment-required",
+			"commitment-pending",
+			"ready",
+			"commitment-expired"
+		]),
+		name: NormalizedName,
+		parameters: RegistrationParameters,
+		price: RegistrationPriceResult,
+		commitment: RegistrationCommitment,
+		commitmentStatus: CommitmentStatus
+	})
+]);
+
+//#endregion
+export { CommitmentStatus, Erc20PaymentCurrency, NativePaymentCurrency, PaymentCurrency, PaymentTokenSupport, RegistrationCommitment, RegistrationParameters, RegistrationPlan, RegistrationPriceResult, RenewalPriceResult, RenewalRoute };
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/actions/registration/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 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 { Bytes32 } from \"../../schemas/hash.js\";\nimport type { Hex } from \"../../schemas/hex.js\";\nimport { EthereumAddress } from \"../../schemas/identity.js\";\nimport { NormalizedName } from \"../../schemas/name.js\";\nimport { EnsProtocol } from \"../../schemas/protocol.js\";\nimport type {\n  CallExecutionResult,\n  ConfirmationPolicy,\n  WriteError,\n  WriteMode,\n  WritePlanProgress,\n} from \"../../write/types.js\";\nimport type { NameState } from \"../name/get-name-state/types.js\";\nimport type { SetRecordInput } from \"../records/set-records/types.js\";\n\nexport type RegistrationReadError = CodecError | ContractError | NameError | RpcError;\n\nexport type RegistrationNameParameters = {\n  readonly name: string;\n  readonly duration: bigint;\n} & BlockParameters;\n\nexport type RegistrationPriceParameters = RegistrationNameParameters & {\n  readonly paymentToken?: EthereumAddress;\n};\n\nexport const NativePaymentCurrency = Schema.Struct({\n  kind: Schema.Literal(\"native\"),\n  symbol: Schema.Literal(\"ETH\"),\n  decimals: Schema.Literal(18),\n});\n\nexport const Erc20PaymentCurrency = Schema.Struct({\n  kind: Schema.Literal(\"erc20\"),\n  address: EthereumAddress,\n  symbol: Schema.String,\n  decimals: Schema.Int,\n});\n\nexport const PaymentCurrency = Schema.Union([NativePaymentCurrency, Erc20PaymentCurrency]);\nexport type PaymentCurrency = typeof PaymentCurrency.Type;\n\nconst PaymentTokenRequired = Schema.Struct({\n  status: Schema.Literal(\"payment-token-required\"),\n  name: NormalizedName,\n  protocol: EnsProtocol,\n});\n\nconst UnsupportedPaymentToken = Schema.Struct({\n  status: Schema.Literal(\"unsupported-payment-token\"),\n  name: NormalizedName,\n  protocol: EnsProtocol,\n  paymentToken: EthereumAddress,\n});\n\nexport const RegistrationPriceResult = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"available\"),\n    name: NormalizedName,\n    protocol: EnsProtocol,\n    registrar: EthereumAddress,\n    duration: Schema.BigInt,\n    base: Schema.BigInt,\n    premium: Schema.BigInt,\n    total: Schema.BigInt,\n    currency: PaymentCurrency,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"unavailable\"),\n    name: NormalizedName,\n    protocol: EnsProtocol,\n    reason: Schema.Literal(\"NAME_UNAVAILABLE\"),\n  }),\n  PaymentTokenRequired,\n  UnsupportedPaymentToken,\n]);\nexport type RegistrationPriceResult = typeof RegistrationPriceResult.Type;\n\nexport const RenewalRoute = Schema.Literals([\"v1-controller\", \"v2-registrar\", \"v1-renewer\"]);\nexport type RenewalRoute = typeof RenewalRoute.Type;\n\nexport const RenewalPriceResult = Schema.Union([\n  Schema.Struct({\n    status: Schema.Literal(\"renewable\"),\n    name: NormalizedName,\n    protocol: EnsProtocol,\n    route: RenewalRoute,\n    renewer: EthereumAddress,\n    duration: Schema.BigInt,\n    price: Schema.BigInt,\n    currency: PaymentCurrency,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"not-renewable\"),\n    name: NormalizedName,\n    protocol: EnsProtocol,\n    reason: Schema.Literal(\"NAME_NOT_RENEWABLE\"),\n  }),\n  PaymentTokenRequired,\n  UnsupportedPaymentToken,\n]);\nexport type RenewalPriceResult = typeof RenewalPriceResult.Type;\n\nexport const RegistrationParameters = Schema.Union([\n  Schema.Struct({\n    protocol: Schema.Literal(\"v1\"),\n    registrar: EthereumAddress,\n    priceOracle: EthereumAddress,\n    minimumRegistrationDuration: Schema.BigInt,\n    minimumRenewalDuration: Schema.BigInt,\n    minimumCommitmentAge: Schema.BigInt,\n    maximumCommitmentAge: Schema.BigInt,\n    payment: Schema.Struct({ kind: Schema.Literal(\"native\") }),\n  }),\n  Schema.Struct({\n    protocol: Schema.Literal(\"v2\"),\n    registrar: EthereumAddress,\n    priceOracle: EthereumAddress,\n    minimumRegistrationDuration: Schema.BigInt,\n    minimumRenewalDuration: Schema.BigInt,\n    minimumCommitmentAge: Schema.BigInt,\n    maximumCommitmentAge: Schema.BigInt,\n    payment: Schema.Struct({ kind: Schema.Literal(\"erc20\"), enumerable: Schema.Literal(false) }),\n  }),\n]);\nexport type RegistrationParameters = typeof RegistrationParameters.Type;\n\nexport const PaymentTokenSupport = Schema.Union([\n  Schema.Struct({\n    protocol: Schema.Literal(\"v1\"),\n    supported: Schema.Literal(false),\n    reason: Schema.Literal(\"NATIVE_PAYMENT_ONLY\"),\n  }),\n  Schema.Struct({\n    protocol: Schema.Literal(\"v2\"),\n    supported: Schema.Literal(false),\n    token: EthereumAddress,\n    reason: Schema.Literal(\"PAYMENT_TOKEN_NOT_SUPPORTED\"),\n  }),\n  Schema.Struct({\n    protocol: Schema.Literal(\"v2\"),\n    supported: Schema.Literal(true),\n    token: EthereumAddress,\n    symbol: Schema.String,\n    decimals: Schema.Int,\n  }),\n]);\nexport type PaymentTokenSupport = typeof PaymentTokenSupport.Type;\n\nexport type RegistrationCommitmentParameters = RegistrationNameParameters & {\n  readonly owner: EthereumAddress;\n  readonly secret: Bytes32;\n  readonly resolver?: EthereumAddress;\n  readonly subregistry?: EthereumAddress;\n  readonly records?: ReadonlyArray<Hex>;\n  readonly reverseRecord?: 0 | 1 | 2;\n  readonly referrer?: Bytes32;\n};\n\nexport const RegistrationCommitment = Schema.Struct({\n  name: NormalizedName,\n  protocol: EnsProtocol,\n  registrar: EthereumAddress,\n  commitment: Bytes32,\n});\nexport type RegistrationCommitment = typeof RegistrationCommitment.Type;\n\nexport const CommitmentStatus = Schema.Union([\n  Schema.Struct({ status: Schema.Literal(\"not-found\"), protocol: EnsProtocol }),\n  Schema.Struct({\n    status: Schema.Literal(\"pending\"),\n    protocol: EnsProtocol,\n    submittedAt: Schema.BigInt,\n    readyAt: Schema.BigInt,\n    expiresAt: Schema.BigInt,\n    remainingSeconds: Schema.BigInt,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"ready\"),\n    protocol: EnsProtocol,\n    submittedAt: Schema.BigInt,\n    readyAt: Schema.BigInt,\n    expiresAt: Schema.BigInt,\n    remainingSeconds: Schema.BigInt,\n  }),\n  Schema.Struct({\n    status: Schema.Literal(\"expired\"),\n    protocol: EnsProtocol,\n    submittedAt: Schema.BigInt,\n    readyAt: Schema.BigInt,\n    expiresAt: Schema.BigInt,\n  }),\n]);\nexport type CommitmentStatus = typeof CommitmentStatus.Type;\n\nexport const RegistrationPlan = Schema.Union([\n  Schema.Struct({ status: Schema.Literal(\"unavailable\"), name: NormalizedName }),\n  Schema.Struct({ status: Schema.Literal(\"payment-token-required\"), name: NormalizedName }),\n  Schema.Struct({\n    status: Schema.Literal(\"unsupported-payment-token\"),\n    name: NormalizedName,\n    paymentToken: EthereumAddress,\n  }),\n  Schema.Struct({\n    status: Schema.Literals([\n      \"commitment-required\",\n      \"commitment-pending\",\n      \"ready\",\n      \"commitment-expired\",\n    ]),\n    name: NormalizedName,\n    parameters: RegistrationParameters,\n    price: RegistrationPriceResult,\n    commitment: RegistrationCommitment,\n    commitmentStatus: CommitmentStatus,\n  }),\n]);\nexport type RegistrationPlan = typeof RegistrationPlan.Type;\n\nexport interface CommitNameParameters {\n  readonly commitment: Bytes32;\n}\n\nexport interface ApprovePaymentTokenParameters {\n  readonly paymentToken: string;\n  readonly amount: bigint;\n}\n\ntype RegistrationCommitmentWriteParameters = Omit<\n  RegistrationCommitmentParameters,\n  \"blockNumber\" | \"blockTag\"\n>;\n\nexport type CompleteRegistrationParameters = RegistrationCommitmentWriteParameters & {\n  readonly paymentToken?: EthereumAddress;\n  readonly maxPrice?: bigint;\n};\n\ninterface RegistrationWalletParameters {\n  readonly walletClient?: WalletClient;\n  readonly account?: Account | Address;\n  readonly mode?: WriteMode;\n  readonly confirmation?: ConfirmationPolicy;\n}\n\nexport type RegisterNameParameters = Omit<RegistrationCommitmentWriteParameters, \"records\"> &\n  RegistrationWalletParameters & {\n    readonly paymentToken?: EthereumAddress;\n    readonly maxPrice?: bigint;\n    readonly records?: ReadonlyArray<SetRecordInput>;\n    readonly resume?: RegisterNameResult;\n  };\n\nexport type AvailableRegistrationPrice = Extract<RegistrationPriceResult, { status: \"available\" }>;\n\nexport interface RegisterNameResult {\n  readonly status: \"waiting\" | \"partial\" | \"submitted\" | \"completed\";\n  readonly name: NormalizedName;\n  readonly protocol: typeof EnsProtocol.Type;\n  readonly commitment: Bytes32;\n  readonly committedByWorkflow: boolean;\n  readonly paymentApprovalIncluded: boolean;\n  readonly readyAt: bigint | null;\n  readonly expiresAt: bigint | null;\n  readonly nextActionAt: bigint | null;\n  readonly price: AvailableRegistrationPrice;\n  readonly write: WritePlanProgress;\n  readonly finalState: NameState | null;\n}\n\nexport type RegisterNamesEntryParameters = Omit<\n  RegisterNameParameters,\n  \"resume\" | \"walletClient\" | \"account\" | \"mode\" | \"confirmation\"\n>;\n\nexport interface RegisterNamesParameters extends RegistrationWalletParameters {\n  readonly registrations: ReadonlyArray<RegisterNamesEntryParameters>;\n  readonly resume?: RegisterNamesResult;\n}\n\nexport interface RegisterNamesResult {\n  readonly status: \"waiting\" | \"partial\" | \"submitted\" | \"completed\";\n  readonly registrations: ReadonlyArray<RegisterNameResult>;\n  readonly nextActionAt: bigint | null;\n}\n\nexport type RegistrationWriteError = WriteError;\nexport type RegistrationWriteResult = CallExecutionResult;\nexport type RegistrationWriteIntent = EnsWriteIntent<\n  RegistrationWriteResult,\n  RegistrationWriteError\n>;\n\nexport type RenewNameCallParameters = {\n  readonly name: string;\n  readonly duration: bigint;\n  readonly paymentToken?: EthereumAddress;\n  readonly maxPrice?: bigint;\n  readonly referrer?: Bytes32;\n};\n\nexport interface ApproveRenewalPaymentParameters {\n  readonly name: string;\n  readonly duration: bigint;\n  readonly paymentToken: string;\n  readonly amount: bigint;\n}\n\nexport type RenewNameParameters = RenewNameCallParameters &\n  RegistrationWalletParameters & {\n    readonly resume?: RenewNameResult;\n  };\n\nexport interface RenewalApproval {\n  readonly required: boolean;\n  readonly spender: EthereumAddress | null;\n  readonly token: EthereumAddress | null;\n  readonly amount: bigint;\n}\n\nexport interface RenewNameResult {\n  readonly status: \"completed\" | \"partial\";\n  readonly name: NormalizedName;\n  readonly protocol: typeof EnsProtocol.Type;\n  readonly route: RenewalRoute;\n  readonly duration: bigint;\n  readonly previousExpiry: bigint | null;\n  readonly newExpiry: bigint | null;\n  readonly price: bigint;\n  readonly currency: PaymentCurrency;\n  readonly approval: RenewalApproval;\n  readonly write: WritePlanProgress;\n  readonly finalState: NameState | null;\n}\n\nexport interface RenewNameAction extends EnsAction<\n  RenewNameParameters,\n  RenewNameResult,\n  WriteError\n> {\n  readonly call: (\n    parameters: RenewNameCallParameters,\n  ) => EnsWriteIntent<CallExecutionResult, WriteError>;\n}\n\nexport type RenewNamesEntryParameters = RenewNameCallParameters;\n\nexport interface RenewNamesParameters extends RegistrationWalletParameters {\n  readonly renewals: ReadonlyArray<RenewNamesEntryParameters>;\n  readonly maxTotalPrice?: bigint;\n  readonly resume?: RenewNamesResult;\n}\n\nexport interface RenewNamesResult {\n  readonly status: \"completed\" | \"partial\";\n  readonly renewals: ReadonlyArray<\n    Omit<RenewNameResult, \"write\" | \"status\" | \"approval\" | \"finalState\"> & {\n      readonly newExpiry: bigint | null;\n      readonly finalState: NameState | null;\n    }\n  >;\n  readonly approvals: ReadonlyArray<RenewalApproval>;\n  readonly totalPrice: bigint;\n  readonly write: WritePlanProgress;\n}\n"],"mappings":"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"}

package/dist/actions/resolution/create-resolver/index.d.ts

@@ -0,0 +1,16 @@
+import "../../../config/config.js";
+import { EnsAction } from "../../../action/action.js";
+import { WriteError } from "../../../write/types.js";
+import { CreateResolverError, CreateResolverIntent, CreateResolverParameters, CreateResolverResult } from "./types.js";
+import { createResolverIntent } from "./prepare.js";
+import "../../../index.js";
+import { Effect } from "effect";
+//#region src/actions/resolution/create-resolver/index.d.ts
+declare const predictResolverAddress: EnsAction<CreateResolverParameters, `0x${string}`, WriteError>;
+declare const action: EnsAction<CreateResolverParameters, CreateResolverResult, WriteError>;
+declare const createResolver: typeof action & {
+  readonly call: typeof createResolverIntent;
+};
+//#endregion
+export { type CreateResolverError, type CreateResolverIntent, type CreateResolverParameters, type CreateResolverResult, createResolver, predictResolverAddress };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/resolution/create-resolver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/resolution/create-resolver/index.ts"],"mappings":";;;;;;;;cAsDa,wBAAsB,UAAA,yCAAA;cA0C7B,QAAM,UAAA,0BAAA,sBAAA;cAMC,uBAOD;WAAoB,aAAa"}