git.stevedylan.dev

src/commands/edit.ts 8.4 K raw

import {
	setTextRecord,
	setAddressRecord,
	setResolver as setResolverRecord,
	setPrimaryName as setPrimaryNameRecord,
	setAbiRecord,
	setContentHashRecord,
} from "@ensdomains/ensjs/wallet";
import { normalize } from "viem/ens";
import { spinner, walletClient } from "../utils";
import { encodeAbi } from "@ensdomains/ensjs/utils";
import { readFile } from "node:fs/promises";

export async function setTxt(options: {
	name: string;
	record: string;
	value: string;
	resolverAddress?: string;
}) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		// Get resolver if not provided
		let resolverAddress = options.resolverAddress;
		if (!resolverAddress) {
			const { ensClient } = await import("../utils");
			const resolver = await ensClient.getEnsResolver({
				name: normalize(options.name),
			});
			resolverAddress = resolver || undefined;
		}

		if (!resolverAddress) {
			spinner.stop();
			console.error("Error: No resolver found for this name");
			return;
		}

		const hash = await setTextRecord(wallet, {
			name: options.name,
			key: options.record,
			value: options.value,
			resolverAddress: resolverAddress as `0x${string}`,
		});

		spinner.stop();
		if (options.value === "") {
			console.log(`✓ TXT record cleared successfully`);
		} else {
			console.log(`✓ TXT record set successfully`);
		}
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting TXT record:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

export async function setAddress(options: {
	name: string;
	coin: string;
	value: string;
	resolverAddress?: string;
}) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		// Get resolver if not provided
		let resolverAddress = options.resolverAddress;
		if (!resolverAddress) {
			const { ensClient } = await import("../utils");
			const resolver = await ensClient.getEnsResolver({
				name: normalize(options.name),
			});
			resolverAddress = resolver || undefined;
		}

		if (!resolverAddress) {
			spinner.stop();
			console.error("Error: No resolver found for this name");
			return;
		}

		const hash = await setAddressRecord(wallet, {
			name: options.name,
			coin: options.coin,
			value: options.value === "null" ? null : options.value,
			resolverAddress: resolverAddress as `0x${string}`,
		});

		spinner.stop();
		if (options.value === "null") {
			console.log(`✓ Address record cleared successfully`);
		} else {
			console.log(`✓ Address record set successfully`);
		}
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting address record:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

export async function setResolver(options: {
	name: string;
	resolverAddress: string;
	contract?: "registry" | "nameWrapper";
}) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		const hash = await setResolverRecord(wallet, {
			name: options.name,
			contract: options.contract || "registry",
			resolverAddress: options.resolverAddress as `0x${string}`,
		});

		spinner.stop();
		console.log(`✓ Resolver set successfully`);
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting resolver:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

export async function setPrimaryName(options: { name: string }) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		const hash = await setPrimaryNameRecord(wallet, {
			name: options.name,
		});

		spinner.stop();
		console.log(`✓ Primary name set successfully`);
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting primary name:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

export async function setAbi(options: {
	name: string;
	abiPath: string;
	encodeAs?: "json" | "zlib" | "cbor" | "uri";
	resolverAddress?: string;
}) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		let encodedAbi: `0x${string}`;

		// Handle null case to clear ABI
		if (options.abiPath === "null") {
			// Encode empty ABI to clear the record
			encodedAbi = await encodeAbi({
				encodeAs: options.encodeAs || "json",
				data: null,
			});
		} else {
			// Read ABI file
			const abiContent = await readFile(options.abiPath, "utf-8");
			const abi = JSON.parse(abiContent);

			// Encode ABI
			encodedAbi = await encodeAbi({
				encodeAs: options.encodeAs || "json",
				data: abi,
			});
		}

		// Get resolver if not provided
		let resolverAddress = options.resolverAddress;
		if (!resolverAddress) {
			const { ensClient } = await import("../utils");
			const resolver = await ensClient.getEnsResolver({
				name: normalize(options.name),
			});
			resolverAddress = resolver || undefined;
		}

		if (!resolverAddress) {
			spinner.stop();
			console.error("Error: No resolver found for this name");
			return;
		}

		const hash = await setAbiRecord(wallet, {
			name: options.name,
			encodedAbi,
			resolverAddress: resolverAddress as `0x${string}`,
		});

		spinner.stop();
		if (options.abiPath === "null") {
			console.log(`✓ ABI record cleared successfully`);
		} else {
			console.log(`✓ ABI record set successfully`);
		}
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting ABI record:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

export async function setContentHash(options: {
	name: string;
	contentHash: string;
	resolverAddress?: string;
}) {
	try {
		spinner.start();
		const wallet = await walletClient();

		if (!wallet) {
			spinner.stop();
			console.error(
				"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
			);
			return;
		}

		// Get resolver if not provided
		let resolverAddress = options.resolverAddress;
		if (!resolverAddress) {
			const { ensClient } = await import("../utils");
			const resolver = await ensClient.getEnsResolver({
				name: normalize(options.name),
			});
			resolverAddress = resolver || undefined;
		}

		if (!resolverAddress) {
			spinner.stop();
			console.error("Error: No resolver found for this name");
			return;
		}

		const hash = await setContentHashRecord(wallet, {
			name: options.name,
			contentHash: options.contentHash === "null" ? null : options.contentHash,
			resolverAddress: resolverAddress as `0x${string}`,
		});

		spinner.stop();
		if (options.contentHash === "null") {
			console.log(`✓ Content hash cleared successfully`);
		} else {
			console.log(`✓ Content hash set successfully`);
		}
		console.log(`Transaction hash: ${hash}`);
	} catch (error) {
		const e = error as { shortMessage?: string; message: string };
		spinner.stop();
		console.error("Error setting content hash:", e.shortMessage || e.message);
		console.error(
			"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
		);
	}
}

1	import {
2	setTextRecord,
3	setAddressRecord,
4	setResolver as setResolverRecord,
5	setPrimaryName as setPrimaryNameRecord,
6	setAbiRecord,
7	setContentHashRecord,
8	} from "@ensdomains/ensjs/wallet";
9	import { normalize } from "viem/ens";
10	import { spinner, walletClient } from "../utils";
11	import { encodeAbi } from "@ensdomains/ensjs/utils";
12	import { readFile } from "node:fs/promises";
13
14	export async function setTxt(options: {
15	name: string;
16	record: string;
17	value: string;
18	resolverAddress?: string;
19	}) {
20	try {
21	spinner.start();
22	const wallet = await walletClient();
23
24	if (!wallet) {
25	spinner.stop();
26	console.error(
27	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
28	);
29	return;
30	}
31
32	// Get resolver if not provided
33	let resolverAddress = options.resolverAddress;
34	if (!resolverAddress) {
35	const { ensClient } = await import("../utils");
36	const resolver = await ensClient.getEnsResolver({
37	name: normalize(options.name),
38	});
39	resolverAddress = resolver \|\| undefined;
40	}
41
42	if (!resolverAddress) {
43	spinner.stop();
44	console.error("Error: No resolver found for this name");
45	return;
46	}
47
48	const hash = await setTextRecord(wallet, {
49	name: options.name,
50	key: options.record,
51	value: options.value,
52	resolverAddress: resolverAddress as `0x${string}`,
53	});
54
55	spinner.stop();
56	if (options.value === "") {
57	console.log(`✓ TXT record cleared successfully`);
58	} else {
59	console.log(`✓ TXT record set successfully`);
60	}
61	console.log(`Transaction hash: ${hash}`);
62	} catch (error) {
63	const e = error as { shortMessage?: string; message: string };
64	spinner.stop();
65	console.error("Error setting TXT record:", e.shortMessage \|\| e.message);
66	console.error(
67	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
68	);
69	}
70	}
71
72	export async function setAddress(options: {
73	name: string;
74	coin: string;
75	value: string;
76	resolverAddress?: string;
77	}) {
78	try {
79	spinner.start();
80	const wallet = await walletClient();
81
82	if (!wallet) {
83	spinner.stop();
84	console.error(
85	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
86	);
87	return;
88	}
89
90	// Get resolver if not provided
91	let resolverAddress = options.resolverAddress;
92	if (!resolverAddress) {
93	const { ensClient } = await import("../utils");
94	const resolver = await ensClient.getEnsResolver({
95	name: normalize(options.name),
96	});
97	resolverAddress = resolver \|\| undefined;
98	}
99
100	if (!resolverAddress) {
101	spinner.stop();
102	console.error("Error: No resolver found for this name");
103	return;
104	}
105
106	const hash = await setAddressRecord(wallet, {
107	name: options.name,
108	coin: options.coin,
109	value: options.value === "null" ? null : options.value,
110	resolverAddress: resolverAddress as `0x${string}`,
111	});
112
113	spinner.stop();
114	if (options.value === "null") {
115	console.log(`✓ Address record cleared successfully`);
116	} else {
117	console.log(`✓ Address record set successfully`);
118	}
119	console.log(`Transaction hash: ${hash}`);
120	} catch (error) {
121	const e = error as { shortMessage?: string; message: string };
122	spinner.stop();
123	console.error("Error setting address record:", e.shortMessage \|\| e.message);
124	console.error(
125	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
126	);
127	}
128	}
129
130	export async function setResolver(options: {
131	name: string;
132	resolverAddress: string;
133	contract?: "registry" \| "nameWrapper";
134	}) {
135	try {
136	spinner.start();
137	const wallet = await walletClient();
138
139	if (!wallet) {
140	spinner.stop();
141	console.error(
142	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
143	);
144	return;
145	}
146
147	const hash = await setResolverRecord(wallet, {
148	name: options.name,
149	contract: options.contract \|\| "registry",
150	resolverAddress: options.resolverAddress as `0x${string}`,
151	});
152
153	spinner.stop();
154	console.log(`✓ Resolver set successfully`);
155	console.log(`Transaction hash: ${hash}`);
156	} catch (error) {
157	const e = error as { shortMessage?: string; message: string };
158	spinner.stop();
159	console.error("Error setting resolver:", e.shortMessage \|\| e.message);
160	console.error(
161	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
162	);
163	}
164	}
165
166	export async function setPrimaryName(options: { name: string }) {
167	try {
168	spinner.start();
169	const wallet = await walletClient();
170
171	if (!wallet) {
172	spinner.stop();
173	console.error(
174	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
175	);
176	return;
177	}
178
179	const hash = await setPrimaryNameRecord(wallet, {
180	name: options.name,
181	});
182
183	spinner.stop();
184	console.log(`✓ Primary name set successfully`);
185	console.log(`Transaction hash: ${hash}`);
186	} catch (error) {
187	const e = error as { shortMessage?: string; message: string };
188	spinner.stop();
189	console.error("Error setting primary name:", e.shortMessage \|\| e.message);
190	console.error(
191	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
192	);
193	}
194	}
195
196	export async function setAbi(options: {
197	name: string;
198	abiPath: string;
199	encodeAs?: "json" \| "zlib" \| "cbor" \| "uri";
200	resolverAddress?: string;
201	}) {
202	try {
203	spinner.start();
204	const wallet = await walletClient();
205
206	if (!wallet) {
207	spinner.stop();
208	console.error(
209	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
210	);
211	return;
212	}
213
214	let encodedAbi: `0x${string}`;
215
216	// Handle null case to clear ABI
217	if (options.abiPath === "null") {
218	// Encode empty ABI to clear the record
219	encodedAbi = await encodeAbi({
220	encodeAs: options.encodeAs \|\| "json",
221	data: null,
222	});
223	} else {
224	// Read ABI file
225	const abiContent = await readFile(options.abiPath, "utf-8");
226	const abi = JSON.parse(abiContent);
227
228	// Encode ABI
229	encodedAbi = await encodeAbi({
230	encodeAs: options.encodeAs \|\| "json",
231	data: abi,
232	});
233	}
234
235	// Get resolver if not provided
236	let resolverAddress = options.resolverAddress;
237	if (!resolverAddress) {
238	const { ensClient } = await import("../utils");
239	const resolver = await ensClient.getEnsResolver({
240	name: normalize(options.name),
241	});
242	resolverAddress = resolver \|\| undefined;
243	}
244
245	if (!resolverAddress) {
246	spinner.stop();
247	console.error("Error: No resolver found for this name");
248	return;
249	}
250
251	const hash = await setAbiRecord(wallet, {
252	name: options.name,
253	encodedAbi,
254	resolverAddress: resolverAddress as `0x${string}`,
255	});
256
257	spinner.stop();
258	if (options.abiPath === "null") {
259	console.log(`✓ ABI record cleared successfully`);
260	} else {
261	console.log(`✓ ABI record set successfully`);
262	}
263	console.log(`Transaction hash: ${hash}`);
264	} catch (error) {
265	const e = error as { shortMessage?: string; message: string };
266	spinner.stop();
267	console.error("Error setting ABI record:", e.shortMessage \|\| e.message);
268	console.error(
269	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
270	);
271	}
272	}
273
274	export async function setContentHash(options: {
275	name: string;
276	contentHash: string;
277	resolverAddress?: string;
278	}) {
279	try {
280	spinner.start();
281	const wallet = await walletClient();
282
283	if (!wallet) {
284	spinner.stop();
285	console.error(
286	"Error: Wallet not configured. Please set ATLAS_PRIVATE_KEY environment variable.",
287	);
288	return;
289	}
290
291	// Get resolver if not provided
292	let resolverAddress = options.resolverAddress;
293	if (!resolverAddress) {
294	const { ensClient } = await import("../utils");
295	const resolver = await ensClient.getEnsResolver({
296	name: normalize(options.name),
297	});
298	resolverAddress = resolver \|\| undefined;
299	}
300
301	if (!resolverAddress) {
302	spinner.stop();
303	console.error("Error: No resolver found for this name");
304	return;
305	}
306
307	const hash = await setContentHashRecord(wallet, {
308	name: options.name,
309	contentHash: options.contentHash === "null" ? null : options.contentHash,
310	resolverAddress: resolverAddress as `0x${string}`,
311	});
312
313	spinner.stop();
314	if (options.contentHash === "null") {
315	console.log(`✓ Content hash cleared successfully`);
316	} else {
317	console.log(`✓ Content hash set successfully`);
318	}
319	console.log(`Transaction hash: ${hash}`);
320	} catch (error) {
321	const e = error as { shortMessage?: string; message: string };
322	spinner.stop();
323	console.error("Error setting content hash:", e.shortMessage \|\| e.message);
324	console.error(
325	"If you are receiving HTTP errors consider setting ETH_RPC_URL as an environemnt variable",
326	);
327	}
328	}