agentwallet-sdk 2.0.0 → 2.3.0

package/dist/identity/erc8004.js

@@ -0,0 +1,656 @@
+/**
+ * ERC-8004: Trustless Agents — Identity Registry Integration
+ *
+ * Implements the Identity Registry component of ERC-8004, which provides every
+ * AI agent with a portable, censorship-resistant on-chain identifier using ERC-721
+ * with URIStorage extension.
+ *
+ * Spec: https://eips.ethereum.org/EIPS/eip-8004
+ * Status: DRAFT (August 2025). No official mainnet singleton deployed yet —
+ * registry address is configurable per deployment.
+ *
+ * Key Principle: Non-custodial. All signing happens locally via the caller's
+ * WalletClient. Keys never leave the device.
+ */
+import { createPublicClient, getContract, http, } from 'viem';
+import { base, baseSepolia, mainnet, arbitrum, polygon } from 'viem/chains';
+// ─── ABI ─────────────────────────────────────────────────────────────────────
+/**
+ * Minimal ABI for the ERC-8004 Identity Registry.
+ * Extends ERC-721 with agent-specific registration functions.
+ */
+export const ERC8004IdentityRegistryAbi = [
+    // Registration
+    {
+        name: 'register',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [{ name: 'agentURI', type: 'string' }],
+        outputs: [{ name: 'agentId', type: 'uint256' }],
+    },
+    {
+        name: 'registerWithMetadata',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'agentURI', type: 'string' },
+            {
+                name: 'metadata',
+                type: 'tuple[]',
+                components: [
+                    { name: 'metadataKey', type: 'string' },
+                    { name: 'metadataValue', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [{ name: 'agentId', type: 'uint256' }],
+    },
+    {
+        name: 'registerEmpty',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [],
+        outputs: [{ name: 'agentId', type: 'uint256' }],
+    },
+    // URI management
+    {
+        name: 'setAgentURI',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'agentId', type: 'uint256' },
+            { name: 'newURI', type: 'string' },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'tokenURI',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'agentId', type: 'uint256' }],
+        outputs: [{ name: '', type: 'string' }],
+    },
+    // On-chain metadata
+    {
+        name: 'getMetadata',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'agentId', type: 'uint256' },
+            { name: 'metadataKey', type: 'string' },
+        ],
+        outputs: [{ name: '', type: 'bytes' }],
+    },
+    {
+        name: 'setMetadata',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'agentId', type: 'uint256' },
+            { name: 'metadataKey', type: 'string' },
+            { name: 'metadataValue', type: 'bytes' },
+        ],
+        outputs: [],
+    },
+    // Agent wallet (payment address)
+    {
+        name: 'getAgentWallet',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'agentId', type: 'uint256' }],
+        outputs: [{ name: '', type: 'address' }],
+    },
+    {
+        name: 'setAgentWallet',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'agentId', type: 'uint256' },
+            { name: 'newWallet', type: 'address' },
+            { name: 'deadline', type: 'uint256' },
+            { name: 'signature', type: 'bytes' },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'unsetAgentWallet',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [{ name: 'agentId', type: 'uint256' }],
+        outputs: [],
+    },
+    // ERC-721 ownership
+    {
+        name: 'ownerOf',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'tokenId', type: 'uint256' }],
+        outputs: [{ name: '', type: 'address' }],
+    },
+    // Events
+    {
+        name: 'Registered',
+        type: 'event',
+        inputs: [
+            { name: 'agentId', type: 'uint256', indexed: true },
+            { name: 'agentURI', type: 'string', indexed: false },
+            { name: 'owner', type: 'address', indexed: true },
+        ],
+    },
+    {
+        name: 'URIUpdated',
+        type: 'event',
+        inputs: [
+            { name: 'agentId', type: 'uint256', indexed: true },
+            { name: 'newURI', type: 'string', indexed: false },
+            { name: 'updatedBy', type: 'address', indexed: true },
+        ],
+    },
+    {
+        name: 'MetadataSet',
+        type: 'event',
+        inputs: [
+            { name: 'agentId', type: 'uint256', indexed: true },
+            { name: 'indexedMetadataKey', type: 'string', indexed: true },
+            { name: 'metadataKey', type: 'string', indexed: false },
+            { name: 'metadataValue', type: 'bytes', indexed: false },
+        ],
+    },
+];
+// ─── Reserved metadata keys (per spec) ───────────────────────────────────────
+export const METADATA_KEYS = {
+    /** Reserved by spec — set via setAgentWallet(), not setMetadata() */
+    AGENT_WALLET: 'agentWallet',
+    /** Optional: AI model identifier */
+    MODEL: 'agentModel',
+    /** Optional: model provider */
+    MODEL_PROVIDER: 'agentModelProvider',
+    /** Optional: agent version string */
+    VERSION: 'agentVersion',
+    /** Optional: JSON-encoded capability tags */
+    CAPABILITIES: 'agentCapabilities',
+    /** Optional: agent framework name */
+    FRAMEWORK: 'agentFramework',
+};
+/** ERC-8004 registration file type string (MUST match this exactly) */
+export const REGISTRATION_FILE_TYPE = 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1';
+/**
+ * Known testnet deployments of ERC-8004 Identity Registry.
+ * Mainnet singleton not yet deployed (spec is DRAFT as of Feb 2026).
+ * Update these addresses once official deployments are announced.
+ */
+export const KNOWN_REGISTRY_ADDRESSES = {
+    // Placeholder — replace with official addresses once deployed
+    'base-sepolia': '0x0000000000000000000000000000000000000000',
+};
+// ─── Chain map (mirrors index.ts) ─────────────────────────────────────────────
+const CHAINS = {
+    base,
+    'base-sepolia': baseSepolia,
+    ethereum: mainnet,
+    arbitrum,
+    polygon,
+};
+// ─── Client ──────────────────────────────────────────────────────────────────
+/**
+ * ERC-8004 Identity Registry client.
+ *
+ * Provides type-safe, non-custodial access to the ERC-8004 Identity Registry.
+ * All write operations require a WalletClient — keys never leave the caller's device.
+ *
+ * @example
+ * ```typescript
+ * import { ERC8004Client } from '@agentwallet/sdk';
+ *
+ * const identity = new ERC8004Client({
+ *   registryAddress: '0xYOUR_REGISTRY',
+ *   chain: 'base',
+ * });
+ *
+ * // Register a new agent identity
+ * const { txHash, agentId } = await identity.registerAgent(
+ *   walletClient,
+ *   {
+ *     name: 'MyTradingAgent',
+ *     description: 'Autonomous DeFi trading agent',
+ *     services: [{ name: 'A2A', endpoint: 'https://agent.example/.well-known/agent-card.json' }],
+ *     x402Support: true,
+ *     active: true,
+ *   },
+ *   'ipfs://QmYourCID'
+ * );
+ *
+ * // Lookup an agent
+ * const agentIdentity = await identity.lookupAgentIdentity(walletClient.account!.address);
+ * ```
+ */
+export class ERC8004Client {
+    constructor(config) {
+        this.config = config;
+        const chain = CHAINS[config.chain];
+        if (!chain)
+            throw new Error(`ERC8004Client: Unsupported chain "${config.chain}"`);
+        this.chain = chain;
+        this.publicClient = createPublicClient({
+            chain,
+            transport: http(config.rpcUrl),
+        });
+    }
+    /** @internal Get a viem contract instance for read operations */
+    getReadContract() {
+        return getContract({
+            address: this.config.registryAddress,
+            abi: ERC8004IdentityRegistryAbi,
+            client: this.publicClient,
+        });
+    }
+    /** @internal Get a viem contract instance for read+write operations */
+    getWriteContract(walletClient) {
+        return getContract({
+            address: this.config.registryAddress,
+            abi: ERC8004IdentityRegistryAbi,
+            client: { public: this.publicClient, wallet: walletClient },
+        });
+    }
+    // ─── Registration ───────────────────────────────────────────────────────
+    /**
+     * Register a new agent identity on-chain.
+     *
+     * Builds a spec-compliant registration file JSON and registers it via
+     * the Identity Registry. The URI can be:
+     * - An IPFS URI you've already pinned: "ipfs://QmYourCID"
+     * - A base64 data URI for fully on-chain storage (auto-generated if not provided)
+     * - An HTTPS URI pointing to a static JSON file
+     *
+     * Non-custodial: the walletClient signs the transaction locally.
+     *
+     * @param walletClient - WalletClient controlling the agent owner key
+     * @param metadata - Agent metadata to include in the registration file
+     * @param agentURI - URI for the registration file (auto-builds data URI if omitted)
+     * @param onChainMetadata - Optional extra on-chain key/value pairs
+     * @returns txHash and agentId (from Registered event)
+     */
+    async registerAgent(walletClient, metadata, agentURI, onChainMetadata) {
+        if (!walletClient.account)
+            throw new Error('ERC8004Client: WalletClient has no account');
+        const registrationFile = {
+            type: REGISTRATION_FILE_TYPE,
+            ...metadata,
+        };
+        // Build data URI if no external URI provided
+        const resolvedURI = agentURI ??
+            buildDataURI(registrationFile);
+        const contract = this.getWriteContract(walletClient);
+        let txHash;
+        if (onChainMetadata && Object.keys(onChainMetadata).length > 0) {
+            const entries = encodeMetadataEntries(onChainMetadata);
+            txHash = await contract.write.registerWithMetadata([resolvedURI, entries], {
+                account: walletClient.account,
+                chain: this.chain,
+            });
+        }
+        else {
+            txHash = await contract.write.register([resolvedURI], {
+                account: walletClient.account,
+                chain: this.chain,
+            });
+        }
+        // Extract agentId from Registered event in receipt
+        let agentId = null;
+        try {
+            const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+            const registeredEvent = receipt.logs.find((log) => log.address.toLowerCase() === this.config.registryAddress.toLowerCase() &&
+                log.topics[0] === REGISTERED_TOPIC);
+            if (registeredEvent?.topics[1]) {
+                agentId = BigInt(registeredEvent.topics[1]);
+            }
+        }
+        catch {
+            // agentId remains null; caller can use lookupAgentsByOwner after confirmation
+        }
+        return { txHash, agentId };
+    }
+    // ─── Lookup ─────────────────────────────────────────────────────────────
+    /**
+     * Look up an agent's full identity by their on-chain token ID.
+     *
+     * Fetches: owner, URI, payment wallet, and attempts to parse the
+     * registration file. Also reads standard on-chain model metadata if present.
+     *
+     * @param agentId - The ERC-721 tokenId assigned during registration
+     */
+    async lookupAgentIdentity(agentId) {
+        const contract = this.getReadContract();
+        const [owner, agentURI, agentWallet] = await Promise.all([
+            contract.read.ownerOf([agentId]),
+            contract.read.tokenURI([agentId]),
+            contract.read.getAgentWallet([agentId]),
+        ]);
+        // Attempt to parse registration file from URI
+        let registrationFile = null;
+        try {
+            registrationFile = await resolveAgentURI(agentURI);
+        }
+        catch {
+            // URI may be an external HTTPS/IPFS that's unavailable in this context
+        }
+        // Read optional on-chain model metadata
+        const modelMetadata = await this.readModelMetadata(agentId);
+        return {
+            agentId,
+            owner,
+            agentURI,
+            agentWallet,
+            registrationFile,
+            modelMetadata,
+        };
+    }
+    /**
+     * Look up an agent's identity by their wallet/owner address.
+     * Scans the Registered event log to find the most recent agentId for this owner.
+     *
+     * @param ownerAddress - The agent owner's Ethereum address
+     * @param fromBlock - Start scanning from this block (default: 0)
+     */
+    async lookupAgentByOwner(ownerAddress, fromBlock = 0n) {
+        const logs = await this.publicClient.getLogs({
+            address: this.config.registryAddress,
+            event: {
+                type: 'event',
+                name: 'Registered',
+                inputs: [
+                    { name: 'agentId', type: 'uint256', indexed: true },
+                    { name: 'agentURI', type: 'string', indexed: false },
+                    { name: 'owner', type: 'address', indexed: true },
+                ],
+            },
+            args: {
+                owner: ownerAddress,
+            },
+            fromBlock,
+            toBlock: 'latest',
+        });
+        if (logs.length === 0)
+            return null;
+        // Use the most recently registered agentId
+        const latestLog = logs[logs.length - 1];
+        const agentId = BigInt(latestLog.args?.agentId ?? 0);
+        return this.lookupAgentIdentity(agentId);
+    }
+    // ─── URI Management ─────────────────────────────────────────────────────
+    /**
+     * Update the agent's registration file URI.
+     * Only callable by the NFT owner or an approved operator.
+     *
+     * @param walletClient - Owner/operator WalletClient
+     * @param agentId - The agent's tokenId
+     * @param newURI - New URI pointing to updated registration file
+     */
+    async updateAgentURI(walletClient, agentId, newURI) {
+        if (!walletClient.account)
+            throw new Error('ERC8004Client: WalletClient has no account');
+        const contract = this.getWriteContract(walletClient);
+        return contract.write.setAgentURI([agentId, newURI], {
+            account: walletClient.account,
+            chain: this.chain,
+        });
+    }
+    // ─── On-chain Metadata ──────────────────────────────────────────────────
+    /**
+     * Read a single on-chain metadata value for an agent.
+     *
+     * @param agentId - The agent's tokenId
+     * @param key - Metadata key (see METADATA_KEYS for standard keys)
+     * @returns Raw bytes value, or null if not set
+     */
+    async getOnChainMetadata(agentId, key) {
+        const contract = this.getReadContract();
+        const value = await contract.read.getMetadata([agentId, key]);
+        return value === '0x' || value === null ? null : value;
+    }
+    /**
+     * Write a single on-chain metadata value for an agent.
+     * Note: the reserved 'agentWallet' key cannot be set via this method.
+     *
+     * @param walletClient - Owner/operator WalletClient
+     * @param agentId - The agent's tokenId
+     * @param key - Metadata key
+     * @param value - UTF-8 string value (will be hex-encoded)
+     */
+    async setOnChainMetadata(walletClient, agentId, key, value) {
+        if (!walletClient.account)
+            throw new Error('ERC8004Client: WalletClient has no account');
+        if (key === METADATA_KEYS.AGENT_WALLET) {
+            throw new Error('ERC8004Client: "agentWallet" is reserved — use setAgentWallet() instead');
+        }
+        const contract = this.getWriteContract(walletClient);
+        const hexValue = stringToHex(value);
+        return contract.write.setMetadata([agentId, key, hexValue], {
+            account: walletClient.account,
+            chain: this.chain,
+        });
+    }
+    /**
+     * Write model metadata on-chain for an agent.
+     * Uses the standard METADATA_KEYS constants.
+     *
+     * @param walletClient - Owner/operator WalletClient
+     * @param agentId - The agent's tokenId
+     * @param model - Model metadata object
+     */
+    async setModelMetadata(walletClient, agentId, model) {
+        const hashes = [];
+        const entries = [];
+        if (model.model)
+            entries.push([METADATA_KEYS.MODEL, model.model]);
+        if (model.provider)
+            entries.push([METADATA_KEYS.MODEL_PROVIDER, model.provider]);
+        if (model.version)
+            entries.push([METADATA_KEYS.VERSION, model.version]);
+        if (model.framework)
+            entries.push([METADATA_KEYS.FRAMEWORK, model.framework]);
+        if (model.capabilities?.length) {
+            entries.push([METADATA_KEYS.CAPABILITIES, JSON.stringify(model.capabilities)]);
+        }
+        for (const [key, val] of entries) {
+            const hash = await this.setOnChainMetadata(walletClient, agentId, key, val);
+            hashes.push(hash);
+        }
+        return hashes;
+    }
+    /**
+     * Read all standard model metadata for an agent.
+     * Returns null if no model metadata has been set.
+     */
+    async readModelMetadata(agentId) {
+        const keys = [
+            METADATA_KEYS.MODEL,
+            METADATA_KEYS.MODEL_PROVIDER,
+            METADATA_KEYS.VERSION,
+            METADATA_KEYS.FRAMEWORK,
+            METADATA_KEYS.CAPABILITIES,
+        ];
+        const values = await Promise.all(keys.map((k) => this.getOnChainMetadata(agentId, k)));
+        const [modelHex, providerHex, versionHex, frameworkHex, capabilitiesHex] = values;
+        // Check if any model metadata is set
+        if (!modelHex && !providerHex && !versionHex && !frameworkHex && !capabilitiesHex) {
+            return null;
+        }
+        const result = {};
+        if (modelHex)
+            result.model = hexToString(modelHex);
+        if (providerHex)
+            result.provider = hexToString(providerHex);
+        if (versionHex)
+            result.version = hexToString(versionHex);
+        if (frameworkHex)
+            result.framework = hexToString(frameworkHex);
+        if (capabilitiesHex) {
+            try {
+                result.capabilities = JSON.parse(hexToString(capabilitiesHex));
+            }
+            catch {
+                result.capabilities = [];
+            }
+        }
+        return result;
+    }
+    // ─── Agent Wallet ────────────────────────────────────────────────────────
+    /**
+     * Get the configured payment wallet for an agent.
+     * Returns zero address if not set (payment defaults to NFT owner).
+     *
+     * @param agentId - The agent's tokenId
+     */
+    async getAgentWallet(agentId) {
+        const contract = this.getReadContract();
+        return contract.read.getAgentWallet([agentId]);
+    }
+    /**
+     * Set the payment wallet for an agent.
+     * Requires an EIP-712 signature from the new wallet to prove control.
+     * This prevents draining payments to an attacker-controlled address.
+     *
+     * Non-custodial: the signature is generated locally by the walletClient.
+     *
+     * @param walletClient - Owner WalletClient (must own the agent NFT)
+     * @param agentId - The agent's tokenId
+     * @param newWallet - New payment wallet address
+     * @param deadline - Signature deadline (Unix timestamp)
+     * @param signature - EIP-712 or ERC-1271 signature from newWallet proving control
+     */
+    async setAgentWallet(walletClient, agentId, newWallet, deadline, signature) {
+        if (!walletClient.account)
+            throw new Error('ERC8004Client: WalletClient has no account');
+        const contract = this.getWriteContract(walletClient);
+        return contract.write.setAgentWallet([agentId, newWallet, deadline, signature], { account: walletClient.account, chain: this.chain });
+    }
+    /**
+     * Clear the agent wallet (resets payment address to NFT owner).
+     *
+     * @param walletClient - Owner WalletClient
+     * @param agentId - The agent's tokenId
+     */
+    async unsetAgentWallet(walletClient, agentId) {
+        if (!walletClient.account)
+            throw new Error('ERC8004Client: WalletClient has no account');
+        const contract = this.getWriteContract(walletClient);
+        return contract.write.unsetAgentWallet([agentId], {
+            account: walletClient.account,
+            chain: this.chain,
+        });
+    }
+}
+// ─── Standalone helpers ───────────────────────────────────────────────────────
+/**
+ * Build a base64 data URI from an agent registration file.
+ * Enables fully on-chain metadata storage without IPFS or HTTPS dependencies.
+ *
+ * @example
+ * const uri = buildDataURI({ name: 'MyAgent', description: '...', ... });
+ * // → "data:application/json;base64,eyJ0..."
+ */
+export function buildDataURI(registrationFile) {
+    // Ensure type field isn't duplicated if registrationFile already has it
+    const payload = { ...registrationFile, type: REGISTRATION_FILE_TYPE };
+    const json = JSON.stringify(payload);
+    // btoa requires Latin1 — use encodeURIComponent to handle UTF-8 safely
+    const b64 = btoa(unescape(encodeURIComponent(json)));
+    return `data:application/json;base64,${b64}`;
+}
+/**
+ * Parse a data URI or plain JSON string into an AgentRegistrationFile.
+ * For HTTPS/IPFS URIs, use resolveAgentURI() instead.
+ */
+export function parseDataURI(uri) {
+    if (uri.startsWith('data:application/json;base64,')) {
+        const b64 = uri.replace('data:application/json;base64,', '');
+        const json = decodeURIComponent(escape(atob(b64)));
+        return JSON.parse(json);
+    }
+    if (uri.startsWith('{')) {
+        return JSON.parse(uri);
+    }
+    throw new Error(`parseDataURI: Cannot parse URI scheme — use resolveAgentURI for HTTP/IPFS: ${uri.substring(0, 50)}`);
+}
+/**
+ * Resolve an agentURI to its registration file.
+ * Supports: data URIs (inline), HTTPS (fetch), IPFS (not fetched — throws).
+ */
+export async function resolveAgentURI(uri) {
+    if (uri.startsWith('data:')) {
+        return parseDataURI(uri);
+    }
+    if (uri.startsWith('https://') || uri.startsWith('http://')) {
+        const response = await fetch(uri);
+        if (!response.ok)
+            throw new Error(`resolveAgentURI: HTTP ${response.status} for ${uri}`);
+        return response.json();
+    }
+    throw new Error(`resolveAgentURI: Unsupported URI scheme. Pin to IPFS or use data URI: ${uri}`);
+}
+/**
+ * Validate an AgentRegistrationFile against ERC-8004 requirements.
+ * Returns an array of validation errors (empty = valid).
+ */
+export function validateRegistrationFile(file) {
+    const errors = [];
+    if (file.type !== REGISTRATION_FILE_TYPE) {
+        errors.push(`type must be "${REGISTRATION_FILE_TYPE}"`);
+    }
+    if (!file.name || typeof file.name !== 'string' || file.name.trim() === '') {
+        errors.push('name is required and must be a non-empty string');
+    }
+    if (!file.description || typeof file.description !== 'string') {
+        errors.push('description is required');
+    }
+    if (file.services) {
+        file.services.forEach((svc, i) => {
+            if (!svc.name)
+                errors.push(`services[${i}].name is required`);
+            if (!svc.endpoint)
+                errors.push(`services[${i}].endpoint is required`);
+        });
+    }
+    if (file.registrations) {
+        file.registrations.forEach((reg, i) => {
+            if (reg.agentId === undefined)
+                errors.push(`registrations[${i}].agentId is required`);
+            if (!reg.agentRegistry)
+                errors.push(`registrations[${i}].agentRegistry is required`);
+        });
+    }
+    return errors;
+}
+/**
+ * Format an agent registry identifier per ERC-8004 spec.
+ *
+ * @param chainId - Chain ID (e.g. 8453 for Base)
+ * @param registryAddress - Identity Registry contract address
+ * @returns "{namespace}:{chainId}:{identityRegistry}" e.g. "eip155:8453:0x742..."
+ */
+export function formatAgentRegistry(chainId, registryAddress) {
+    return `eip155:${chainId}:${registryAddress}`;
+}
+// ─── Internal utilities ───────────────────────────────────────────────────────
+/** keccak256 topic for Registered(uint256 indexed, string, address indexed) */
+const REGISTERED_TOPIC = '0x6f3c9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a';
+function stringToHex(str) {
+    const bytes = new TextEncoder().encode(str);
+    const hexStr = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return ('0x' + hexStr);
+}
+function hexToString(hex) {
+    const stripped = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const bytes = new Uint8Array(stripped.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+    return new TextDecoder('utf-8').decode(bytes);
+}
+function encodeMetadataEntries(entries) {
+    return Object.entries(entries).map(([key, value]) => ({
+        metadataKey: key,
+        metadataValue: stringToHex(value),
+    }));
+}
+//# sourceMappingURL=erc8004.js.map