@ensforge/sdk 0.0.0

package/dist/groups/records.d.ts

@@ -0,0 +1,98 @@
+import { BoundAction, BoundGetRecordsAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/records.d.ts
+declare const makeRecordsActions: (config: EnsforgeConfig) => Readonly<{
+  clearAvatar: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ClearAvatarParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  clearRecords: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ClearRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  getAbi: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetAbiParameters, {
+    readonly contentType: "json" | "zlib-json" | "cbor";
+    readonly value: import("viem").Abi;
+    readonly raw: `0x${string}` & import("effect/Brand").Brand<"AbiRecordData">;
+  } | {
+    readonly contentType: "uri";
+    readonly value: string;
+    readonly raw: `0x${string}` & import("effect/Brand").Brand<"AbiRecordData">;
+  } | {
+    readonly contentType: null;
+    readonly value: null;
+    readonly raw: null;
+  }, import("@ensforge/core").GetAbiError>>;
+  getAddress: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetAddressParameters, {
+    readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+    readonly address: string;
+    readonly raw: `0x${string}` & import("effect/Brand").Brand<"AddressRecordData">;
+  } | {
+    readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+    readonly address: null;
+    readonly raw: null;
+  }, import("@ensforge/core").GetAddressError>>;
+  getAddresses: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetAddressesParameters, readonly ({
+    readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+    readonly address: string;
+    readonly raw: `0x${string}` & import("effect/Brand").Brand<"AddressRecordData">;
+  } | {
+    readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+    readonly address: null;
+    readonly raw: null;
+  })[], import("@ensforge/core").GetAddressError>>;
+  getAvatar: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetAvatarParameters, {
+    readonly status: "resolved";
+    readonly record: string;
+    readonly uri: string;
+  } | {
+    readonly status: "unsupported-chain";
+    readonly record: string;
+    readonly chainId: number;
+  } | null, import("@ensforge/core").GetAvatarError>>;
+  getContentHash: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetContentHashParameters, {
+    readonly protocol: "ipfs" | "ipns" | "swarm" | "onion" | "onion3" | "skynet" | "arweave" | "adnl";
+    readonly value: string;
+    readonly raw: `0x${string}` & import("effect/Brand").Brand<"ContentHash">;
+  } | {
+    readonly protocol: null;
+    readonly value: null;
+    readonly raw: null;
+  }, import("@ensforge/core").GetContentHashError>>;
+  getData: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetDataParameters, {
+    readonly key: string;
+    readonly value: `0x${string}` | null;
+  }, import("@ensforge/core").GetDataError>>;
+  getInterface: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetInterfaceParameters, {
+    readonly interfaceId: `0x${string}` & import("effect/Brand").Brand<"InterfaceId">;
+    readonly implementer: `0x${string}` | null;
+  }, import("@ensforge/core").GetInterfaceError>>;
+  getName: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetNameParameters, {
+    readonly name: string | null;
+  }, import("@ensforge/core").GetNameError>>;
+  getPubkey: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetPubkeyParameters, {
+    readonly x: `0x${string}`;
+    readonly y: `0x${string}`;
+  } | null, import("@ensforge/core").GetPubkeyError>>;
+  getRecords: BoundGetRecordsAction;
+  getText: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetTextParameters, {
+    readonly key: string;
+    readonly value: string | null;
+  }, import("@ensforge/core").GetTextError>>;
+  getTexts: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetTextsParameters, readonly {
+    readonly key: string;
+    readonly value: string | null;
+  }[], import("@ensforge/core").GetTextError>>;
+  setAbi: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetAbiParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setAddress: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetAddressParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setAddresses: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetAddressesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setAlias: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetAliasParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setAvatar: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetAvatarParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setContentHash: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetContentHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setData: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetDataParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setInterface: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetInterfaceParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setPubkey: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetPubkeyParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setRecords: BoundAction<import("@ensforge/core").SetRecordsAction>;
+  setText: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetTextParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setTexts: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetTextsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+}>;
+type RecordsActions = ReturnType<typeof makeRecordsActions>;
+//#endregion
+export { RecordsActions, makeRecordsActions };
+//# sourceMappingURL=records.d.ts.map

package/dist/groups/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","names":[],"sources":["../../src/groups/records.ts"],"mappings":";;;;cAiCa,qBAAsB,QAAQ,mBAAc;eAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+B/B,iBAAiB,kBAAkB"}

package/dist/groups/records.js

@@ -0,0 +1,37 @@
+import { bindAction } from "../internal/bind-action.js";
+import { clearAvatar, clearRecords, getAbi, getAddress, getAddresses, getAvatar, getContentHash, getData, getInterface, getName, getPubkey, getRecords, getText, getTexts, setAbi, setAddress, setAddresses, setAlias, setAvatar, setContentHash, setData, setInterface, setName, setPubkey, setRecords, setText, setTexts } from "@ensforge/core";
+
+//#region src/groups/records.ts
+const makeRecordsActions = (config) => Object.freeze({
+	clearAvatar: bindAction(config, clearAvatar),
+	clearRecords: bindAction(config, clearRecords),
+	getAbi: bindAction(config, getAbi),
+	getAddress: bindAction(config, getAddress),
+	getAddresses: bindAction(config, getAddresses),
+	getAvatar: bindAction(config, getAvatar),
+	getContentHash: bindAction(config, getContentHash),
+	getData: bindAction(config, getData),
+	getInterface: bindAction(config, getInterface),
+	getName: bindAction(config, getName),
+	getPubkey: bindAction(config, getPubkey),
+	getRecords: bindAction(config, getRecords),
+	getText: bindAction(config, getText),
+	getTexts: bindAction(config, getTexts),
+	setAbi: bindAction(config, setAbi),
+	setAddress: bindAction(config, setAddress),
+	setAddresses: bindAction(config, setAddresses),
+	setAlias: bindAction(config, setAlias),
+	setAvatar: bindAction(config, setAvatar),
+	setContentHash: bindAction(config, setContentHash),
+	setData: bindAction(config, setData),
+	setInterface: bindAction(config, setInterface),
+	setName: bindAction(config, setName),
+	setPubkey: bindAction(config, setPubkey),
+	setRecords: bindAction(config, setRecords),
+	setText: bindAction(config, setText),
+	setTexts: bindAction(config, setTexts)
+});
+
+//#endregion
+export { makeRecordsActions };
+//# sourceMappingURL=records.js.map

package/dist/groups/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","names":[],"sources":["../../src/groups/records.ts"],"sourcesContent":["import {\n  clearAvatar,\n  clearRecords,\n  getAbi,\n  getAddress,\n  getAddresses,\n  getAvatar,\n  getContentHash,\n  getData,\n  getInterface,\n  getName,\n  getPubkey,\n  getRecords,\n  getText,\n  getTexts,\n  setAbi,\n  setAddress,\n  setAddresses,\n  setAlias,\n  setAvatar,\n  setContentHash,\n  setData,\n  setInterface,\n  setName,\n  setPubkey,\n  setRecords,\n  setText,\n  setTexts,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeRecordsActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    clearAvatar: bindAction(config, clearAvatar),\n    clearRecords: bindAction(config, clearRecords),\n    getAbi: bindAction(config, getAbi),\n    getAddress: bindAction(config, getAddress),\n    getAddresses: bindAction(config, getAddresses),\n    getAvatar: bindAction(config, getAvatar),\n    getContentHash: bindAction(config, getContentHash),\n    getData: bindAction(config, getData),\n    getInterface: bindAction(config, getInterface),\n    getName: bindAction(config, getName),\n    getPubkey: bindAction(config, getPubkey),\n    getRecords: bindAction(config, getRecords),\n    getText: bindAction(config, getText),\n    getTexts: bindAction(config, getTexts),\n    setAbi: bindAction(config, setAbi),\n    setAddress: bindAction(config, setAddress),\n    setAddresses: bindAction(config, setAddresses),\n    setAlias: bindAction(config, setAlias),\n    setAvatar: bindAction(config, setAvatar),\n    setContentHash: bindAction(config, setContentHash),\n    setData: bindAction(config, setData),\n    setInterface: bindAction(config, setInterface),\n    setName: bindAction(config, setName),\n    setPubkey: bindAction(config, setPubkey),\n    setRecords: bindAction(config, setRecords),\n    setText: bindAction(config, setText),\n    setTexts: bindAction(config, setTexts),\n  });\n\nexport type RecordsActions = ReturnType<typeof makeRecordsActions>;\n"],"mappings":";;;;AAiCA,MAAa,sBAAsB,WACjC,OAAO,OAAO;CACZ,aAAa,WAAW,QAAQ,WAAW;CAC3C,cAAc,WAAW,QAAQ,YAAY;CAC7C,QAAQ,WAAW,QAAQ,MAAM;CACjC,YAAY,WAAW,QAAQ,UAAU;CACzC,cAAc,WAAW,QAAQ,YAAY;CAC7C,WAAW,WAAW,QAAQ,SAAS;CACvC,gBAAgB,WAAW,QAAQ,cAAc;CACjD,SAAS,WAAW,QAAQ,OAAO;CACnC,cAAc,WAAW,QAAQ,YAAY;CAC7C,SAAS,WAAW,QAAQ,OAAO;CACnC,WAAW,WAAW,QAAQ,SAAS;CACvC,YAAY,WAAW,QAAQ,UAAU;CACzC,SAAS,WAAW,QAAQ,OAAO;CACnC,UAAU,WAAW,QAAQ,QAAQ;CACrC,QAAQ,WAAW,QAAQ,MAAM;CACjC,YAAY,WAAW,QAAQ,UAAU;CACzC,cAAc,WAAW,QAAQ,YAAY;CAC7C,UAAU,WAAW,QAAQ,QAAQ;CACrC,WAAW,WAAW,QAAQ,SAAS;CACvC,gBAAgB,WAAW,QAAQ,cAAc;CACjD,SAAS,WAAW,QAAQ,OAAO;CACnC,cAAc,WAAW,QAAQ,YAAY;CAC7C,SAAS,WAAW,QAAQ,OAAO;CACnC,WAAW,WAAW,QAAQ,SAAS;CACvC,YAAY,WAAW,QAAQ,UAAU;CACzC,SAAS,WAAW,QAAQ,OAAO;CACnC,UAAU,WAAW,QAAQ,QAAQ;AACvC,CAAC"}

package/dist/groups/registration.d.ts

@@ -0,0 +1,257 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/registration.d.ts
+declare const makeRegistrationActions: (config: EnsforgeConfig) => Readonly<{
+  approvePaymentToken: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ApprovePaymentTokenParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  approveRenewalPayment: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ApproveRenewalPaymentParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  commitName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").CommitNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  completeRegistration: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").CompleteRegistrationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  getCommitmentStatus: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCommitmentStatusParameters, {
+    readonly status: "not-found";
+    readonly protocol: "v1" | "v2";
+  } | {
+    readonly status: "pending";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+    readonly remainingSeconds: bigint;
+  } | {
+    readonly status: "ready";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+    readonly remainingSeconds: bigint;
+  } | {
+    readonly status: "expired";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  getRegistrationParameters: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").BlockParameters, {
+    readonly protocol: "v1";
+    readonly registrar: `0x${string}`;
+    readonly priceOracle: `0x${string}`;
+    readonly minimumRegistrationDuration: bigint;
+    readonly minimumRenewalDuration: bigint;
+    readonly minimumCommitmentAge: bigint;
+    readonly maximumCommitmentAge: bigint;
+    readonly payment: {
+      readonly kind: "native";
+    };
+  } | {
+    readonly protocol: "v2";
+    readonly registrar: `0x${string}`;
+    readonly priceOracle: `0x${string}`;
+    readonly minimumRegistrationDuration: bigint;
+    readonly minimumRenewalDuration: bigint;
+    readonly minimumCommitmentAge: bigint;
+    readonly maximumCommitmentAge: bigint;
+    readonly payment: {
+      readonly kind: "erc20";
+      readonly enumerable: false;
+    };
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  getRegistrationPlan: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistrationPlanParameters, {
+    readonly status: "unavailable";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "payment-token-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "unsupported-payment-token";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly paymentToken: `0x${string}`;
+  } | {
+    readonly status: "ready" | "commitment-required" | "commitment-pending" | "commitment-expired";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly parameters: {
+      readonly protocol: "v1";
+      readonly registrar: `0x${string}`;
+      readonly priceOracle: `0x${string}`;
+      readonly minimumRegistrationDuration: bigint;
+      readonly minimumRenewalDuration: bigint;
+      readonly minimumCommitmentAge: bigint;
+      readonly maximumCommitmentAge: bigint;
+      readonly payment: {
+        readonly kind: "native";
+      };
+    } | {
+      readonly protocol: "v2";
+      readonly registrar: `0x${string}`;
+      readonly priceOracle: `0x${string}`;
+      readonly minimumRegistrationDuration: bigint;
+      readonly minimumRenewalDuration: bigint;
+      readonly minimumCommitmentAge: bigint;
+      readonly maximumCommitmentAge: bigint;
+      readonly payment: {
+        readonly kind: "erc20";
+        readonly enumerable: false;
+      };
+    };
+    readonly price: {
+      readonly status: "available";
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly protocol: "v1" | "v2";
+      readonly registrar: `0x${string}`;
+      readonly duration: bigint;
+      readonly base: bigint;
+      readonly premium: bigint;
+      readonly total: bigint;
+      readonly currency: {
+        readonly kind: "native";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+      } | {
+        readonly kind: "erc20";
+        readonly address: `0x${string}`;
+        readonly symbol: string;
+        readonly decimals: number;
+      };
+    } | {
+      readonly status: "unavailable";
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly protocol: "v1" | "v2";
+      readonly reason: "NAME_UNAVAILABLE";
+    } | {
+      readonly status: "payment-token-required";
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly protocol: "v1" | "v2";
+    } | {
+      readonly status: "unsupported-payment-token";
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly protocol: "v1" | "v2";
+      readonly paymentToken: `0x${string}`;
+    };
+    readonly commitment: {
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly protocol: "v1" | "v2";
+      readonly registrar: `0x${string}`;
+      readonly commitment: `0x${string}`;
+    };
+    readonly commitmentStatus: {
+      readonly status: "not-found";
+      readonly protocol: "v1" | "v2";
+    } | {
+      readonly status: "pending";
+      readonly protocol: "v1" | "v2";
+      readonly submittedAt: bigint;
+      readonly readyAt: bigint;
+      readonly expiresAt: bigint;
+      readonly remainingSeconds: bigint;
+    } | {
+      readonly status: "ready";
+      readonly protocol: "v1" | "v2";
+      readonly submittedAt: bigint;
+      readonly readyAt: bigint;
+      readonly expiresAt: bigint;
+      readonly remainingSeconds: bigint;
+    } | {
+      readonly status: "expired";
+      readonly protocol: "v1" | "v2";
+      readonly submittedAt: bigint;
+      readonly readyAt: bigint;
+      readonly expiresAt: bigint;
+    };
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  getRegistrationPrice: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistrationPriceParameters, {
+    readonly status: "available";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly registrar: `0x${string}`;
+    readonly duration: bigint;
+    readonly base: bigint;
+    readonly premium: bigint;
+    readonly total: bigint;
+    readonly currency: {
+      readonly kind: "native";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    } | {
+      readonly kind: "erc20";
+      readonly address: `0x${string}`;
+      readonly symbol: string;
+      readonly decimals: number;
+    };
+  } | {
+    readonly status: "unavailable";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "NAME_UNAVAILABLE";
+  } | {
+    readonly status: "payment-token-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+  } | {
+    readonly status: "unsupported-payment-token";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly paymentToken: `0x${string}`;
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  getRenewalPrice: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistrationPriceParameters, {
+    readonly status: "payment-token-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+  } | {
+    readonly status: "unsupported-payment-token";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly paymentToken: `0x${string}`;
+  } | {
+    readonly status: "renewable";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly route: "v1-controller" | "v2-registrar" | "v1-renewer";
+    readonly renewer: `0x${string}`;
+    readonly duration: bigint;
+    readonly price: bigint;
+    readonly currency: {
+      readonly kind: "native";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    } | {
+      readonly kind: "erc20";
+      readonly address: `0x${string}`;
+      readonly symbol: string;
+      readonly decimals: number;
+    };
+  } | {
+    readonly status: "not-renewable";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "NAME_NOT_RENEWABLE";
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  isPaymentTokenSupported: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
+    readonly protocol: "v1";
+    readonly supported: false;
+    readonly reason: "NATIVE_PAYMENT_ONLY";
+  } | {
+    readonly protocol: "v2";
+    readonly supported: false;
+    readonly token: `0x${string}`;
+    readonly reason: "PAYMENT_TOKEN_NOT_SUPPORTED";
+  } | {
+    readonly protocol: "v2";
+    readonly supported: true;
+    readonly token: `0x${string}`;
+    readonly symbol: string;
+    readonly decimals: number;
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  makeRegistrationCommitment: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly registrar: `0x${string}`;
+    readonly commitment: `0x${string}`;
+  }, import("@ensforge/core").GetCommitmentStatusError>>;
+  registerName: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").RegisterNameParameters, import("@ensforge/core").RegisterNameResult, import("@ensforge/core").WriteError>>;
+  registerNames: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").RegisterNamesParameters, import("@ensforge/core").RegisterNamesResult, import("@ensforge/core").WriteError>>;
+  renewName: BoundAction<import("@ensforge/core").RenewNameAction>;
+  renewNames: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").RenewNamesParameters, import("@ensforge/core").RenewNamesResult, import("@ensforge/core").WriteError>>;
+}>;
+type RegistrationActions = ReturnType<typeof makeRegistrationActions>;
+//#endregion
+export { RegistrationActions, makeRegistrationActions };
+//# sourceMappingURL=registration.d.ts.map

package/dist/groups/registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/groups/registration.ts"],"mappings":";;;;cAqBa,0BAA2B,QAAQ,mBAAc;uBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmBpC,sBAAsB,kBAAkB"}

package/dist/groups/registration.js

@@ -0,0 +1,25 @@
+import { bindAction } from "../internal/bind-action.js";
+import { approvePaymentToken, approveRenewalPayment, commitName, completeRegistration, getCommitmentStatus, getRegistrationParameters, getRegistrationPlan, getRegistrationPrice, getRenewalPrice, isPaymentTokenSupported, makeRegistrationCommitment, registerName, registerNames, renewName, renewNames } from "@ensforge/core";
+
+//#region src/groups/registration.ts
+const makeRegistrationActions = (config) => Object.freeze({
+	approvePaymentToken: bindAction(config, approvePaymentToken),
+	approveRenewalPayment: bindAction(config, approveRenewalPayment),
+	commitName: bindAction(config, commitName),
+	completeRegistration: bindAction(config, completeRegistration),
+	getCommitmentStatus: bindAction(config, getCommitmentStatus),
+	getRegistrationParameters: bindAction(config, getRegistrationParameters),
+	getRegistrationPlan: bindAction(config, getRegistrationPlan),
+	getRegistrationPrice: bindAction(config, getRegistrationPrice),
+	getRenewalPrice: bindAction(config, getRenewalPrice),
+	isPaymentTokenSupported: bindAction(config, isPaymentTokenSupported),
+	makeRegistrationCommitment: bindAction(config, makeRegistrationCommitment),
+	registerName: bindAction(config, registerName),
+	registerNames: bindAction(config, registerNames),
+	renewName: bindAction(config, renewName),
+	renewNames: bindAction(config, renewNames)
+});
+
+//#endregion
+export { makeRegistrationActions };
+//# sourceMappingURL=registration.js.map

package/dist/groups/registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.js","names":[],"sources":["../../src/groups/registration.ts"],"sourcesContent":["import {\n  approvePaymentToken,\n  approveRenewalPayment,\n  commitName,\n  completeRegistration,\n  getCommitmentStatus,\n  getRegistrationParameters,\n  getRegistrationPlan,\n  getRegistrationPrice,\n  getRenewalPrice,\n  isPaymentTokenSupported,\n  makeRegistrationCommitment,\n  registerName,\n  registerNames,\n  renewName,\n  renewNames,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeRegistrationActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    approvePaymentToken: bindAction(config, approvePaymentToken),\n    approveRenewalPayment: bindAction(config, approveRenewalPayment),\n    commitName: bindAction(config, commitName),\n    completeRegistration: bindAction(config, completeRegistration),\n    getCommitmentStatus: bindAction(config, getCommitmentStatus),\n    getRegistrationParameters: bindAction(config, getRegistrationParameters),\n    getRegistrationPlan: bindAction(config, getRegistrationPlan),\n    getRegistrationPrice: bindAction(config, getRegistrationPrice),\n    getRenewalPrice: bindAction(config, getRenewalPrice),\n    isPaymentTokenSupported: bindAction(config, isPaymentTokenSupported),\n    makeRegistrationCommitment: bindAction(config, makeRegistrationCommitment),\n    registerName: bindAction(config, registerName),\n    registerNames: bindAction(config, registerNames),\n    renewName: bindAction(config, renewName),\n    renewNames: bindAction(config, renewNames),\n  });\n\nexport type RegistrationActions = ReturnType<typeof makeRegistrationActions>;\n"],"mappings":";;;;AAqBA,MAAa,2BAA2B,WACtC,OAAO,OAAO;CACZ,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,uBAAuB,WAAW,QAAQ,qBAAqB;CAC/D,YAAY,WAAW,QAAQ,UAAU;CACzC,sBAAsB,WAAW,QAAQ,oBAAoB;CAC7D,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,2BAA2B,WAAW,QAAQ,yBAAyB;CACvE,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,sBAAsB,WAAW,QAAQ,oBAAoB;CAC7D,iBAAiB,WAAW,QAAQ,eAAe;CACnD,yBAAyB,WAAW,QAAQ,uBAAuB;CACnE,4BAA4B,WAAW,QAAQ,0BAA0B;CACzE,cAAc,WAAW,QAAQ,YAAY;CAC7C,eAAe,WAAW,QAAQ,aAAa;CAC/C,WAAW,WAAW,QAAQ,SAAS;CACvC,YAAY,WAAW,QAAQ,UAAU;AAC3C,CAAC"}

package/dist/groups/resolution.d.ts

@@ -0,0 +1,53 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/resolution.d.ts
+declare const makeResolutionActions: (config: EnsforgeConfig) => Readonly<{
+  createResolver: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError> & {
+    readonly call: (parameters: import("@ensforge/core").CreateResolverParameters) => import("@ensforge/core").EnsWriteIntent<import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+  }>;
+  getAlias: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetAliasParameters, {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}` | null;
+    readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}`;
+    readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
+    readonly raw: `0x${string}`;
+  }, import("@ensforge/core").GetAliasError>>;
+  getOrCreateResolver: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>>;
+  getResolver: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError>>;
+  getResolverVersion: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetResolverVersionParameters, {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}` | null;
+    readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}`;
+    readonly version: bigint;
+  }, import("@ensforge/core").GetResolverError>>;
+  predictResolverAddress: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError>>;
+  resolve: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").ResolveParameters, {
+    readonly data: `0x${string}`;
+    readonly resolverAddress: `0x${string}`;
+  } | null, import("@ensforge/core").ResolveError>>;
+  resolveBatch: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError>>;
+  resolveWithResolver: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").ResolveWithResolverParameters, {
+    readonly data: `0x${string}`;
+    readonly resolverAddress: `0x${string}`;
+  }, import("@ensforge/core").ResolveError>>;
+  setResolver: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setResolverAndRecords: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").SetResolverAndRecordsParameters, import("@ensforge/core").SetResolverAndRecordsProgress, import("@ensforge/core").WriteError>>;
+  upgradeResolver: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").UpgradeResolverParameters, import("@ensforge/core").UpgradeResolverResult, import("@ensforge/core").WriteError> & {
+    readonly call: (parameters: import("@ensforge/core").UpgradeResolverParameters) => import("@ensforge/core").EnsWriteIntent<import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+  }>;
+}>;
+type ResolutionActions = ReturnType<typeof makeResolutionActions>;
+//#endregion
+export { ResolutionActions, makeResolutionActions };
+//# sourceMappingURL=resolution.d.ts.map

package/dist/groups/resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/groups/resolution.ts"],"mappings":";;;;cAkBa,wBAAyB,QAAQ,mBAAc;kBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgBlC,oBAAoB,kBAAkB"}

package/dist/groups/resolution.js

@@ -0,0 +1,22 @@
+import { bindAction } from "../internal/bind-action.js";
+import { createResolver, getAlias, getOrCreateResolver, getResolver, getResolverVersion, predictResolverAddress, resolve, resolveBatch, resolveWithResolver, setResolver, setResolverAndRecords, upgradeResolver } from "@ensforge/core";
+
+//#region src/groups/resolution.ts
+const makeResolutionActions = (config) => Object.freeze({
+	createResolver: bindAction(config, createResolver),
+	getAlias: bindAction(config, getAlias),
+	getOrCreateResolver: bindAction(config, getOrCreateResolver),
+	getResolver: bindAction(config, getResolver),
+	getResolverVersion: bindAction(config, getResolverVersion),
+	predictResolverAddress: bindAction(config, predictResolverAddress),
+	resolve: bindAction(config, resolve),
+	resolveBatch: bindAction(config, resolveBatch),
+	resolveWithResolver: bindAction(config, resolveWithResolver),
+	setResolver: bindAction(config, setResolver),
+	setResolverAndRecords: bindAction(config, setResolverAndRecords),
+	upgradeResolver: bindAction(config, upgradeResolver)
+});
+
+//#endregion
+export { makeResolutionActions };
+//# sourceMappingURL=resolution.js.map

package/dist/groups/resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.js","names":[],"sources":["../../src/groups/resolution.ts"],"sourcesContent":["import {\n  createResolver,\n  getAlias,\n  getOrCreateResolver,\n  getResolver,\n  getResolverVersion,\n  predictResolverAddress,\n  resolve,\n  resolveBatch,\n  resolveWithResolver,\n  setResolver,\n  setResolverAndRecords,\n  upgradeResolver,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeResolutionActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    createResolver: bindAction(config, createResolver),\n    getAlias: bindAction(config, getAlias),\n    getOrCreateResolver: bindAction(config, getOrCreateResolver),\n    getResolver: bindAction(config, getResolver),\n    getResolverVersion: bindAction(config, getResolverVersion),\n    predictResolverAddress: bindAction(config, predictResolverAddress),\n    resolve: bindAction(config, resolve),\n    resolveBatch: bindAction(config, resolveBatch),\n    resolveWithResolver: bindAction(config, resolveWithResolver),\n    setResolver: bindAction(config, setResolver),\n    setResolverAndRecords: bindAction(config, setResolverAndRecords),\n    upgradeResolver: bindAction(config, upgradeResolver),\n  });\n\nexport type ResolutionActions = ReturnType<typeof makeResolutionActions>;\n"],"mappings":";;;;AAkBA,MAAa,yBAAyB,WACpC,OAAO,OAAO;CACZ,gBAAgB,WAAW,QAAQ,cAAc;CACjD,UAAU,WAAW,QAAQ,QAAQ;CACrC,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,aAAa,WAAW,QAAQ,WAAW;CAC3C,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,wBAAwB,WAAW,QAAQ,sBAAsB;CACjE,SAAS,WAAW,QAAQ,OAAO;CACnC,cAAc,WAAW,QAAQ,YAAY;CAC7C,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,aAAa,WAAW,QAAQ,WAAW;CAC3C,uBAAuB,WAAW,QAAQ,qBAAqB;CAC/D,iBAAiB,WAAW,QAAQ,eAAe;AACrD,CAAC"}

package/dist/groups/reverse.d.ts

@@ -0,0 +1,18 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/reverse.d.ts
+declare const makeReverseActions: (config: EnsforgeConfig) => Readonly<{
+  clearPrimaryName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ClearPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  getPrimaryName: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetPrimaryNameParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly match: true;
+  } | null, import("@ensforge/core").GetPrimaryNameError>>;
+  setContractPrimaryName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetContractPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setPrimaryName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setPrimaryNameForAddress: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetPrimaryNameForAddressParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+}>;
+type ReverseActions = ReturnType<typeof makeReverseActions>;
+//#endregion
+export { ReverseActions, makeReverseActions };
+//# sourceMappingURL=reverse.d.ts.map

package/dist/groups/reverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/groups/reverse.ts"],"mappings":";;;;cAWa,qBAAsB,QAAQ,mBAAc;oBAAd;;;;;;;;;KAS/B,iBAAiB,kBAAkB"}

package/dist/groups/reverse.js

@@ -0,0 +1,15 @@
+import { bindAction } from "../internal/bind-action.js";
+import { clearPrimaryName, getPrimaryName, setContractPrimaryName, setPrimaryName, setPrimaryNameForAddress } from "@ensforge/core";
+
+//#region src/groups/reverse.ts
+const makeReverseActions = (config) => Object.freeze({
+	clearPrimaryName: bindAction(config, clearPrimaryName),
+	getPrimaryName: bindAction(config, getPrimaryName),
+	setContractPrimaryName: bindAction(config, setContractPrimaryName),
+	setPrimaryName: bindAction(config, setPrimaryName),
+	setPrimaryNameForAddress: bindAction(config, setPrimaryNameForAddress)
+});
+
+//#endregion
+export { makeReverseActions };
+//# sourceMappingURL=reverse.js.map

package/dist/groups/reverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.js","names":[],"sources":["../../src/groups/reverse.ts"],"sourcesContent":["import {\n  clearPrimaryName,\n  getPrimaryName,\n  setContractPrimaryName,\n  setPrimaryName,\n  setPrimaryNameForAddress,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeReverseActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    clearPrimaryName: bindAction(config, clearPrimaryName),\n    getPrimaryName: bindAction(config, getPrimaryName),\n    setContractPrimaryName: bindAction(config, setContractPrimaryName),\n    setPrimaryName: bindAction(config, setPrimaryName),\n    setPrimaryNameForAddress: bindAction(config, setPrimaryNameForAddress),\n  });\n\nexport type ReverseActions = ReturnType<typeof makeReverseActions>;\n"],"mappings":";;;;AAWA,MAAa,sBAAsB,WACjC,OAAO,OAAO;CACZ,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,gBAAgB,WAAW,QAAQ,cAAc;CACjD,wBAAwB,WAAW,QAAQ,sBAAsB;CACjE,gBAAgB,WAAW,QAAQ,cAAc;CACjD,0BAA0B,WAAW,QAAQ,wBAAwB;AACvE,CAAC"}

package/dist/groups/subnames.d.ts

@@ -0,0 +1,17 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/subnames.d.ts
+declare const makeSubnameActions: (config: EnsforgeConfig) => Readonly<{
+  createSubname: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").CreateSubnameParameters, import("@ensforge/core").CreateSubnameResult, import("@ensforge/core").WriteError>>;
+  deleteSubname: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").DeleteSubnameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setSubnameExpiry: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setSubnameManager: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetSubnameManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setSubnameRecord: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").SetSubnameRecordParameters, import("@ensforge/core").SetSubnameRecordResult, import("@ensforge/core").WriteError>>;
+  setSubnameResolver: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetSubnameResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  transferSubname: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").TransferSubnameParameters, import("@ensforge/core").TransferNameProgress, import("@ensforge/core").WriteError>>;
+}>;
+type SubnameActions = ReturnType<typeof makeSubnameActions>;
+//#endregion
+export { SubnameActions, makeSubnameActions };
+//# sourceMappingURL=subnames.d.ts.map

package/dist/groups/subnames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subnames.d.ts","names":[],"sources":["../../src/groups/subnames.ts"],"mappings":";;;;cAaa,qBAAsB,QAAQ,mBAAc;iBAAd;;;;;;;;KAW/B,iBAAiB,kBAAkB"}

package/dist/groups/subnames.js

@@ -0,0 +1,17 @@
+import { bindAction } from "../internal/bind-action.js";
+import { createSubname, deleteSubname, setSubnameExpiry, setSubnameManager, setSubnameRecord, setSubnameResolver, transferSubname } from "@ensforge/core";
+
+//#region src/groups/subnames.ts
+const makeSubnameActions = (config) => Object.freeze({
+	createSubname: bindAction(config, createSubname),
+	deleteSubname: bindAction(config, deleteSubname),
+	setSubnameExpiry: bindAction(config, setSubnameExpiry),
+	setSubnameManager: bindAction(config, setSubnameManager),
+	setSubnameRecord: bindAction(config, setSubnameRecord),
+	setSubnameResolver: bindAction(config, setSubnameResolver),
+	transferSubname: bindAction(config, transferSubname)
+});
+
+//#endregion
+export { makeSubnameActions };
+//# sourceMappingURL=subnames.js.map

package/dist/groups/subnames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subnames.js","names":[],"sources":["../../src/groups/subnames.ts"],"sourcesContent":["import {\n  createSubname,\n  deleteSubname,\n  setSubnameExpiry,\n  setSubnameManager,\n  setSubnameRecord,\n  setSubnameResolver,\n  transferSubname,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeSubnameActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    createSubname: bindAction(config, createSubname),\n    deleteSubname: bindAction(config, deleteSubname),\n    setSubnameExpiry: bindAction(config, setSubnameExpiry),\n    setSubnameManager: bindAction(config, setSubnameManager),\n    setSubnameRecord: bindAction(config, setSubnameRecord),\n    setSubnameResolver: bindAction(config, setSubnameResolver),\n    transferSubname: bindAction(config, transferSubname),\n  });\n\nexport type SubnameActions = ReturnType<typeof makeSubnameActions>;\n"],"mappings":";;;;AAaA,MAAa,sBAAsB,WACjC,OAAO,OAAO;CACZ,eAAe,WAAW,QAAQ,aAAa;CAC/C,eAAe,WAAW,QAAQ,aAAa;CAC/C,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,mBAAmB,WAAW,QAAQ,iBAAiB;CACvD,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,iBAAiB,WAAW,QAAQ,eAAe;AACrD,CAAC"}