@agentdomain/eliza-plugin 0.5.1 → 0.7.0

package/NOTICE

@@ -0,0 +1,5 @@
+AgentDomain public developer tools and verified Base contracts
+Copyright 2026 Md. Rakib
+
+AgentDomain and related names and logos are trademarks or service marks of
+their respective owner. This license does not grant trademark rights.

package/README.md

@@ -10,10 +10,19 @@ The plugin gives Eliza agents a complete AgentDomain lifecycle surface:
 
 - Registration quote and x402 registration
 - Registry discovery
-- Agent email send/list/delete/batch, monthly usage, signed inbound webhooks, primary address updates, and Starter/Pro/Enterprise aliases
-- DNS management
+- Agent email send/list/batch, monthly usage, signed inbound webhooks, primary address updates, and Starter/Pro/Enterprise aliases
+- Typed DNS management for all 13 Spaceship-supported types, including capabilities, revision-safe batches, and BIND import/export
 - SSL repair/reconfiguration
 - RenewalVault status, funding, and auto-renew
-- Per-agent Premium Plan status, upgrades, and exact next-renewal tier selection
+- Per-agent Premium Plan status and upgrades
 
 Configure `AGENTDOMAIN_API_URL` only if you need a custom endpoint. The default is `https://agentdomain.app/api/v1`.
+
+Set `AGENTDOMAIN_BUILDER_CODE` to your public ERC-8021 app identifier whenever
+the runtime can submit direct Base writes. The value is not a private key.
+Eliza passes it to the SDK and uses it for post-registration auto-renew; missing
+or invalid attribution stops the direct transaction before submission. Reads,
+offchain signatures, Ethereum L1 ENS operations, and standard x402 v2 paid
+requests are not changed.
+
+Request the default base URL directly to retrieve AgentDomain's machine-readable API discovery metadata.

package/dist/index.d.ts

@@ -11,6 +11,8 @@ interface Memory {
         text: string;
     };
 }
+/** Builds the attributed direct calldata used by Eliza's post-registration auto-renew step. */
+export declare function encodeElizaAutoRenewCalldata(tokenId: bigint, builderCode?: string): `0x${string}`;
 export declare const quoteRegistrationAction: {
     name: string;
     description: string;
@@ -234,6 +236,17 @@ export declare const listDnsAction: {
         data: import("@agentdomain/shared").DnsRecord[];
     }>;
 };
+export declare const dnsCapabilitiesAction: {
+    name: string;
+    description: string;
+    similes: string[];
+    examples: never[];
+    validate: (runtime: IAgentRuntime) => Promise<boolean>;
+    handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+        text: string;
+        data: import("@agentdomain/shared").DnsCapabilities;
+    }>;
+};
 export declare const createDnsAction: {
     name: string;
     description: string;
@@ -269,6 +282,42 @@ export declare const deleteDnsAction: {
         };
     }>;
 };
+export declare const changeDnsRecordsAction: {
+    name: string;
+    description: string;
+    similes: string[];
+    examples: never[];
+    validate: (runtime: IAgentRuntime) => Promise<boolean>;
+    handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+        text: string;
+        data: import("@agentdomain/shared").DnsChangePreview;
+    }>;
+};
+export declare const importDnsZoneAction: {
+    name: string;
+    description: string;
+    similes: string[];
+    examples: never[];
+    validate: (runtime: IAgentRuntime) => Promise<boolean>;
+    handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+        text: string;
+        data: import("@agentdomain/shared").DnsChangePreview;
+    }>;
+};
+export declare const exportDnsZoneAction: {
+    name: string;
+    description: string;
+    similes: string[];
+    examples: never[];
+    validate: (runtime: IAgentRuntime) => Promise<boolean>;
+    handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+        text: string;
+        data: {
+            format: string;
+            zone: string;
+        };
+    }>;
+};
 export declare const servicePlanStatusAction: {
     name: string;
     description: string;
@@ -512,6 +561,16 @@ export declare const agentDomainPlugin: {
             text: string;
             data: import("@agentdomain/shared").DnsRecord[];
         }>;
+    } | {
+        name: string;
+        description: string;
+        similes: string[];
+        examples: never[];
+        validate: (runtime: IAgentRuntime) => Promise<boolean>;
+        handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+            text: string;
+            data: import("@agentdomain/shared").DnsCapabilities;
+        }>;
     } | {
         name: string;
         description: string;
@@ -534,6 +593,29 @@ export declare const agentDomainPlugin: {
                 success: boolean;
             };
         }>;
+    } | {
+        name: string;
+        description: string;
+        similes: string[];
+        examples: never[];
+        validate: (runtime: IAgentRuntime) => Promise<boolean>;
+        handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+            text: string;
+            data: import("@agentdomain/shared").DnsChangePreview;
+        }>;
+    } | {
+        name: string;
+        description: string;
+        similes: string[];
+        examples: never[];
+        validate: (runtime: IAgentRuntime) => Promise<boolean>;
+        handler: (runtime: IAgentRuntime, message: Memory) => Promise<{
+            text: string;
+            data: {
+                format: string;
+                zone: string;
+            };
+        }>;
     } | {
         name: string;
         description: string;

package/dist/index.js

@@ -1,20 +1,29 @@
-import { AgentDomain } from '@agentdomain/sdk';
+import { AgentDomain, encodeSetAutoRenewCalldata } from '@agentdomain/sdk';
 import { AGENTDOMAIN_API_BASE_URL, SERVICE_PLAN_KEYS, SUPPORTED_TLDS, } from '@agentdomain/shared/constants';
-import { createPublicClient, createWalletClient, http, } from 'viem';
+import { DNS_RECORD_TYPES, dnsRecordSchema as sharedDnsRecordSchema, } from '@agentdomain/shared';
+import { createPublicClient, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { base, baseSepolia } from 'viem/chains';
 import { z } from 'zod';
+/** Builds the attributed direct calldata used by Eliza's post-registration auto-renew step. */
+export function encodeElizaAutoRenewCalldata(tokenId, builderCode) {
+    if (!builderCode) {
+        throw new Error('AGENTDOMAIN_BUILDER_CODE is required for attributed direct Base transactions.');
+    }
+    return encodeSetAutoRenewCalldata(tokenId, true, builderCode);
+}
 function getClients(runtime, opts = {}) {
     const apiUrl = runtime.getSetting('AGENTDOMAIN_API_URL') ?? AGENTDOMAIN_API_BASE_URL;
     const apiKey = runtime.getSetting('AGENTDOMAIN_API_KEY');
     const pk = runtime.getSetting('AGENT_PRIVATE_KEY');
     const rpc = runtime.getSetting('BASE_RPC_URL') ?? 'https://mainnet.base.org';
     const network = runtime.getSetting('AGENTDOMAIN_NETWORK') ?? 'base';
+    const builderCode = runtime.getSetting('AGENTDOMAIN_BUILDER_CODE');
     const chain = network === 'base-sepolia' ? baseSepolia : base;
     if (!pk) {
         if (opts.requireWallet)
             throw new Error('AGENT_PRIVATE_KEY not set');
-        const ad = new AgentDomain({ apiUrl, apiKey, network });
+        const ad = new AgentDomain({ apiUrl, apiKey, network, builderCode });
         return { ad, account: null, walletClient: null, publicClient: null, network, chain, rpc };
     }
     const account = privateKeyToAccount(pk);
@@ -26,6 +35,7 @@ function getClients(runtime, opts = {}) {
         network,
         walletClient: walletClient,
         publicClient: publicClient,
+        builderCode,
     });
     return { ad, account, walletClient, publicClient, network, chain, rpc };
 }
@@ -47,9 +57,9 @@ const registerSchema = z.object({
     premiumPlan: z.enum(SERVICE_PLAN_KEYS).default('included'),
 });
 const dnsRecordSchema = z.object({
-    type: z.enum(['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV']),
+    type: z.enum(DNS_RECORD_TYPES),
     name: z.string(),
-    value: z.string(),
+    value: z.string().min(1).max(65_535),
     ttl: z.number().int().min(60).max(3600).default(3600),
     priority: z.number().int().min(0).optional(),
 });
@@ -111,20 +121,46 @@ function parsePlan(text) {
 }
 function parseDnsRecord(text) {
     const lower = text.toLowerCase();
-    const typeMatch = text.match(/\b(A|AAAA|ALIAS|CNAME|MX|TXT|NS|SRV)\b/i);
+    const typeMatch = text.match(/\b(A|AAAA|ALIAS|CAA|CNAME|HTTPS|MX|NS|PTR|SRV|SVCB|TLSA|TXT)\b/i);
     const nameMatch = text.match(/\bname[:=]\s*([^\s]+)/i);
-    const valueMatch = text.match(/\bvalue[:=]\s*([^\s]+)/i);
+    const valueMatch = text.match(/\bvalue[:=]\s*(.+?)(?=\s+\b(?:ttl|priority)[:=]|$)/i);
     const ttlMatch = text.match(/\bttl[:=]\s*(\d+)/i);
     const priorityMatch = text.match(/\bpriority[:=]\s*(\d+)/i);
     const parsed = dnsRecordSchema.parse({
         type: typeMatch?.[1]?.toUpperCase() ?? (lower.includes('txt') ? 'TXT' : 'A'),
         name: nameMatch?.[1] ?? '@',
-        value: valueMatch?.[1] ?? text.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)?.[0] ?? '',
+        value: valueMatch?.[1]?.trim() ?? text.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)?.[0] ?? '',
         ttl: ttlMatch ? Number(ttlMatch[1]) : 3600,
         priority: priorityMatch ? Number(priorityMatch[1]) : undefined,
     });
     return parsed;
 }
+function parseDnsRecordsJson(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
+    const json = fenced ?? text.slice(text.indexOf('['), text.lastIndexOf(']') + 1);
+    if (!json)
+        throw new Error('A JSON array of DNS records is required');
+    return z.array(sharedDnsRecordSchema).min(1).max(200).parse(JSON.parse(json));
+}
+function parseZoneFile(text) {
+    const fenced = text.match(/```(?:bind|zone|dns)?\s*([\s\S]*?)```/i)?.[1];
+    if (!fenced?.trim())
+        throw new Error('Put the BIND zone records inside a fenced code block');
+    return fenced.trim();
+}
+function parseDnsApplyOptions(text) {
+    const lower = text.toLowerCase();
+    return {
+        mode: lower.includes('replace') ? 'replace' : 'merge',
+        dryRun: !/\bapply\b/i.test(text),
+        baseRevision: text.match(/\bbaseRevision[:=]\s*([a-f0-9]{64})/i)?.[1],
+    };
+}
+function requireDnsRevision(value) {
+    if (!value)
+        throw new Error('Apply requires baseRevision from a fresh DNS preview');
+    return value;
+}
 function parseEmailUsername(text) {
     const explicit = text.match(/\b(?:email\s+username|primary\s+email|username|alias)[:=]?\s*([a-z0-9._+-]{1,64})/i)?.[1] ?? text.match(EMAIL_PATTERN)?.[0]?.split('@')[0];
     const username = explicit?.trim().toLowerCase();
@@ -178,8 +214,10 @@ export const registerIdentityAction = {
     handler: async (runtime, message) => {
         const params = parseParamsFromText(message.content.text);
         const validated = registerSchema.parse(params);
-        const { ad, account, walletClient, chain } = getClients(runtime, { requireWallet: true });
-        if (!account || !walletClient)
+        const { ad, account, walletClient, publicClient, chain } = getClients(runtime, {
+            requireWallet: true,
+        });
+        if (!account || !walletClient || !publicClient)
             throw new Error('AGENT_PRIVATE_KEY not set');
         const result = await ad.register({
             ...validated,
@@ -191,23 +229,22 @@ export const registerIdentityAction = {
             const vaultAddress = runtime.getSetting('RENEWAL_VAULT_ADDRESS');
             if (vaultAddress) {
                 try {
-                    const txHash = await walletClient.writeContract({
-                        address: vaultAddress,
-                        abi: [
-                            {
-                                type: 'function',
-                                name: 'setAutoRenew',
-                                inputs: [
-                                    { name: 'tokenId', type: 'uint256' },
-                                    { name: 'enabled', type: 'bool' },
-                                ],
-                            },
-                        ],
-                        functionName: 'setAutoRenew',
-                        args: [BigInt(result.nftTokenId), true],
+                    const txHash = await walletClient.sendTransaction({
+                        to: vaultAddress,
+                        data: encodeElizaAutoRenewCalldata(BigInt(result.nftTokenId), runtime.getSetting('AGENTDOMAIN_BUILDER_CODE')),
                         chain,
                         account,
                     });
+                    let receipt;
+                    try {
+                        receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+                    }
+                    catch (e) {
+                        throw new Error(`Auto-renew transaction ${txHash} was submitted but confirmation failed or remained pending: ${String(e)}`);
+                    }
+                    if (receipt.status !== 'success') {
+                        throw new Error(`Auto-renew transaction ${txHash} confirmed with status ${receipt.status}; auto-renew was not enabled.`);
+                    }
                     autoRenewMsg = ` Auto-renew enabled via tx ${txHash}.`;
                 }
                 catch (e) {
@@ -426,6 +463,7 @@ export const enableAutoRenewAction = {
         const agentId = requireAgentId(message.content.text);
         const result = await ad.setAutoRenew(agentId, true, {
             renewalVaultAddress: runtime.getSetting('RENEWAL_VAULT_ADDRESS'),
+            waitForReceipt: true,
         });
         return { text: `Auto-renew enabled for token #${result.tokenId}.`, data: result };
     },
@@ -461,6 +499,21 @@ export const listDnsAction = {
         return { text: `Found ${records.length} DNS records.`, data: records };
     },
 };
+export const dnsCapabilitiesAction = {
+    name: 'GET_DNS_CAPABILITIES',
+    description: 'Get AgentDomain DNS record types, validation fields, limits, and provider warnings.',
+    similes: ['DNS_CAPABILITIES', 'DNS_TYPES', 'DNS_LIMITS'],
+    examples: [],
+    validate: async (runtime) => Boolean(runtime.getSetting('AGENT_PRIVATE_KEY') || runtime.getSetting('AGENTDOMAIN_API_KEY')),
+    handler: async (runtime, message) => {
+        const { ad } = getClients(runtime);
+        const result = await ad.getDnsCapabilities(requireAgentId(message.content.text));
+        return {
+            text: `AgentDomain supports ${result.supportedTypes.length} Spaceship DNS record types.`,
+            data: result,
+        };
+    },
+};
 export const createDnsAction = {
     name: 'CREATE_DNS_RECORD',
     description: 'Create a user-managed DNS record. Use text like: agentId type A name @ value 1.2.3.4.',
@@ -510,6 +563,58 @@ export const deleteDnsAction = {
         return { text: `Deleted DNS record ${recordId}.`, data: result };
     },
 };
+export const changeDnsRecordsAction = {
+    name: 'CHANGE_DNS_RECORDS',
+    description: 'Preview or apply a revision-protected DNS batch from a JSON array of structured records.',
+    similes: ['BATCH_DNS', 'PREVIEW_DNS_CHANGES', 'APPLY_DNS_CHANGES'],
+    examples: [],
+    validate: async (runtime) => Boolean(runtime.getSetting('AGENT_PRIVATE_KEY') || runtime.getSetting('AGENTDOMAIN_API_KEY')),
+    handler: async (runtime, message) => {
+        const { ad } = getClients(runtime);
+        const agentId = requireAgentId(message.content.text);
+        const records = parseDnsRecordsJson(message.content.text);
+        const options = parseDnsApplyOptions(message.content.text);
+        const result = options.dryRun
+            ? await ad.previewDnsBatch(agentId, records, options.mode)
+            : await ad.applyDnsBatch(agentId, records, requireDnsRevision(options.baseRevision), options.mode);
+        return {
+            text: options.dryRun ? 'DNS preview generated.' : 'DNS change set applied.',
+            data: result,
+        };
+    },
+};
+export const importDnsZoneAction = {
+    name: 'IMPORT_DNS_ZONE',
+    description: 'Preview or apply a validated BIND DNS zone import.',
+    similes: ['DNS_ZONE_IMPORT', 'IMPORT_BIND_ZONE'],
+    examples: [],
+    validate: async (runtime) => Boolean(runtime.getSetting('AGENT_PRIVATE_KEY') || runtime.getSetting('AGENTDOMAIN_API_KEY')),
+    handler: async (runtime, message) => {
+        const { ad } = getClients(runtime);
+        const agentId = requireAgentId(message.content.text);
+        const zoneFile = parseZoneFile(message.content.text);
+        const options = parseDnsApplyOptions(message.content.text);
+        const result = options.dryRun
+            ? await ad.previewDnsImport(agentId, zoneFile, options.mode)
+            : await ad.applyDnsImport(agentId, zoneFile, requireDnsRevision(options.baseRevision), options.mode);
+        return {
+            text: options.dryRun ? 'DNS import preview generated.' : 'DNS zone import applied.',
+            data: result,
+        };
+    },
+};
+export const exportDnsZoneAction = {
+    name: 'EXPORT_DNS_ZONE',
+    description: 'Export AgentDomain DNS records as a standard BIND zone file.',
+    similes: ['DNS_ZONE_EXPORT', 'EXPORT_BIND_ZONE'],
+    examples: [],
+    validate: async (runtime) => Boolean(runtime.getSetting('AGENT_PRIVATE_KEY') || runtime.getSetting('AGENTDOMAIN_API_KEY')),
+    handler: async (runtime, message) => {
+        const { ad } = getClients(runtime);
+        const zone = await ad.exportDnsZone(requireAgentId(message.content.text), /\b(?:all|complete)\b/i.test(message.content.text) ? 'all' : 'user');
+        return { text: zone, data: { format: 'bind', zone } };
+    },
+};
 export const servicePlanStatusAction = {
     name: 'GET_SERVICE_PLAN',
     description: 'Get an agent Premium Plan, limits, current period, and billing state.',
@@ -607,10 +712,14 @@ export const agentDomainPlugin = {
         fundRenewalAction,
         enableAutoRenewAction,
         reconfigureSslAction,
+        dnsCapabilitiesAction,
         listDnsAction,
         createDnsAction,
         updateDnsAction,
         deleteDnsAction,
+        changeDnsRecordsAction,
+        importDnsZoneAction,
+        exportDnsZoneAction,
         servicePlanStatusAction,
         setRegistryVisibilityAction,
         scheduleServicePlanRenewalAction,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentdomain/eliza-plugin",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "ElizaOS plugin for AgentDomain - give your Eliza agent a complete identity stack",
   "license": "Apache-2.0",
   "repository": "https://github.com/0xmdrakib/AgentDomain.git",
@@ -18,6 +18,8 @@
   "files": [
     "dist",
     "README.md",
+    "LICENSE",
+    "NOTICE",
     "package.json"
   ],
   "publishConfig": {
@@ -26,8 +28,8 @@
   "dependencies": {
     "viem": "^2.55.2",
     "zod": "^3.24.1",
-    "@agentdomain/sdk": "^0.5.1",
-    "@agentdomain/shared": "^0.5.1"
+    "@agentdomain/sdk": "^0.7.0",
+    "@agentdomain/shared": "^0.7.0"
   },
   "peerDependencies": {
     "@elizaos/core": "^1.0.0"
@@ -37,6 +39,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "pnpm --filter @agentdomain/sdk build && pnpm run build && node --test test/*.test.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "echo \"no lint\""
   }