agent0-sdk 1.0.3 → 1.1.1

package/dist/core/agent.js

@@ -1,12 +1,15 @@
 /**
  * Agent class for managing individual agents
  */
-import { ethers } from 'ethers';
+import { decodeEventLog, getAddress, hashDomain } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
 import { EndpointType, TrustModel } from '../models/enums.js';
 import { EndpointCrawler } from './endpoint-crawler.js';
 import { parseAgentId } from '../utils/id-format.js';
 import { TIMEOUTS } from '../utils/constants.js';
 import { validateSkill, validateDomain } from './oasf-validator.js';
+import { IDENTITY_REGISTRY_ABI } from './contracts.js';
+import { normalizeEcdsaSignature, recoverTypedDataSigner } from '../utils/signatures.js';
 /**
  * Agent class for managing individual agents
  */
@@ -291,18 +294,23 @@ export class Agent {
             throw new Error('Agent must be registered before setting agentWallet on-chain. ' +
                 'Register the agent first, then call setAgentWallet().');
         }
-        if (!this.sdk.web3Client.signer) {
-            throw new Error('No SDK signer available to submit setAgentWallet transaction');
+        if (this.sdk.isReadOnly) {
+            throw new Error('No signer configured to submit setAgentWallet transaction');
         }
         // Validate newWallet address
-        if (!this.sdk.web3Client.isAddress(newWallet)) {
+        if (!this.sdk.chainClient.isAddress(newWallet)) {
             throw new Error(`Invalid newWallet address: ${newWallet}`);
         }
         const { tokenId } = parseAgentId(this.registrationFile.agentId);
-        const identityRegistry = this.sdk.getIdentityRegistry();
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
         // Optional short-circuit if already set
         try {
-            const currentWallet = await this.sdk.web3Client.callContract(identityRegistry, 'getAgentWallet', BigInt(tokenId));
+            const currentWallet = await this.sdk.chainClient.readContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'getAgentWallet',
+                args: [BigInt(tokenId)],
+            });
             if (typeof currentWallet === 'string' &&
                 currentWallet.toLowerCase() === newWallet.toLowerCase()) {
                 const chainId = await this.sdk.chainId();
@@ -317,8 +325,7 @@ export class Agent {
         }
         // Deadline: contract enforces a short window. Use chain time (latest block timestamp)
         // rather than local system time to avoid clock skew causing reverts.
-        const latestBlock = await this.sdk.web3Client.provider.getBlock('latest');
-        const chainNow = latestBlock?.timestamp ?? Math.floor(Date.now() / 1000);
+        const chainNow = Number(await this.sdk.chainClient.getBlockTimestamp('latest'));
         const deadlineValue = opts?.deadline ?? chainNow + 60;
         if (deadlineValue < chainNow) {
             throw new Error(`Invalid deadline: ${deadlineValue} is in the past (chain time: ${chainNow})`);
@@ -329,16 +336,25 @@ export class Agent {
                 `(chain time: ${chainNow})`);
         }
         const chainId = await this.sdk.chainId();
-        const verifyingContract = await identityRegistry.getAddress();
-        const owner = await this.sdk.web3Client.callContract(identityRegistry, 'ownerOf', BigInt(tokenId));
+        const verifyingContract = identityRegistryAddress;
+        const owner = await this.sdk.chainClient.readContract({
+            address: identityRegistryAddress,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: 'ownerOf',
+            args: [BigInt(tokenId)],
+        });
         // Prefer reading the actual EIP-712 domain from the contract (if supported)
         // to avoid any future divergence in name/version.
         let domainName;
         let domainVersion;
         try {
-            const domainInfo = await this.sdk.web3Client.callContract(identityRegistry, 'eip712Domain');
+            const domainInfo = await this.sdk.chainClient.readContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'eip712Domain',
+                args: [],
+            });
             // eip712Domain() returns: (fields, name, version, chainId, verifyingContract, salt, extensions)
-            // In ethers v6 this is typically a Result array-like object.
             domainName = domainInfo?.name ?? domainInfo?.[1];
             domainVersion = domainInfo?.version ?? domainInfo?.[2];
         }
@@ -349,50 +365,41 @@ export class Agent {
         // deterministically from common candidates.
         let domainSeparatorOnChain;
         try {
-            domainSeparatorOnChain = await this.sdk.web3Client.callContract(identityRegistry, 'DOMAIN_SEPARATOR');
+            domainSeparatorOnChain = await this.sdk.chainClient.readContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'DOMAIN_SEPARATOR',
+                args: [],
+            });
         }
         catch {
             // ignore
         }
-        // Preflight estimateGas to catch signature/domain/type mismatches early.
-        const estimateSetAgentWallet = async (sig) => {
-            const fn = identityRegistry.getFunction
-                ? identityRegistry.getFunction('setAgentWallet')
-                : null;
-            if (fn?.estimateGas) {
-                await fn.estimateGas(BigInt(tokenId), newWallet, BigInt(deadlineValue), sig);
-            }
-            else if (identityRegistry.estimateGas?.setAgentWallet) {
-                await identityRegistry.estimateGas.setAgentWallet(BigInt(tokenId), newWallet, BigInt(deadlineValue), sig);
-            }
-        };
         // Determine signature
         let signature;
         if (opts?.signature) {
-            signature =
-                typeof opts.signature === 'string' ? opts.signature : ethers.hexlify(opts.signature);
-            if (!signature.startsWith('0x')) {
-                signature = `0x${signature}`;
-            }
+            const sig = typeof opts.signature === 'string'
+                ? (opts.signature.startsWith('0x') ? opts.signature : `0x${opts.signature}`)
+                : (() => {
+                    let hex = '0x';
+                    for (const b of opts.signature) {
+                        hex += b.toString(16).padStart(2, '0');
+                    }
+                    return hex;
+                })();
+            signature = normalizeEcdsaSignature(sig);
         }
         else {
             // The new wallet MUST sign (EOA path). Support a few domain/type variants to match deployed registries.
-            const signerForNewWallet = opts?.newWalletSigner;
-            const sdkSignerAddress = await this.sdk.web3Client.getAddress();
+            const sdkSignerAddress = await this.sdk.chainClient.getAddress();
             // If no explicit signer was provided, allow the one-wallet case (SDK signer == newWallet)
-            if (!signerForNewWallet) {
+            if (!opts?.newWalletPrivateKey) {
                 if (!sdkSignerAddress || sdkSignerAddress.toLowerCase() !== newWallet.toLowerCase()) {
                     throw new Error(`The new wallet must sign the EIP-712 message. ` +
-                        `Pass opts.newWalletSigner (private key or Signer) or opts.signature. ` +
+                        `Pass opts.newWalletPrivateKey or opts.signature. ` +
                         `SDK signer is ${sdkSignerAddress || 'unknown'}, newWallet is ${newWallet}.`);
                 }
             }
-            else {
-                const signerAddress = await this.sdk.web3Client.addressOf(signerForNewWallet);
-                if (signerAddress.toLowerCase() !== newWallet.toLowerCase()) {
-                    throw new Error(`newWalletSigner address (${signerAddress}) does not match newWallet (${newWallet}).`);
-                }
-            }
             const domainNames = [];
             if (domainName)
                 domainNames.push(domainName);
@@ -403,11 +410,11 @@ export class Agent {
             if (domainSeparatorOnChain) {
                 const match = domainNames.flatMap((dn) => domainVersions.map((dv) => ({ dn, dv }))).find(({ dn, dv }) => {
                     try {
-                        const computed = ethers.TypedDataEncoder.hashDomain({
+                        const computed = hashDomain({
                             name: dn,
                             version: dv,
                             chainId,
-                            verifyingContract,
+                            verifyingContract: verifyingContract,
                         });
                         return computed.toLowerCase() === String(domainSeparatorOnChain).toLowerCase();
                     }
@@ -424,55 +431,87 @@ export class Agent {
             const variants = [];
             for (const dn of domainNames) {
                 for (const dv of domainVersions) {
-                    variants.push(this.sdk.web3Client.buildAgentWalletSetTypedData({
-                        agentId: BigInt(tokenId),
-                        newWallet,
-                        owner,
-                        deadline: BigInt(deadlineValue),
-                        chainId,
-                        verifyingContract,
-                        domainName: dn,
-                        domainVersion: dv,
-                    }));
-                    variants.push(this.sdk.web3Client.buildAgentWalletSetTypedDataNoOwner({
-                        agentId: BigInt(tokenId),
-                        newWallet,
-                        deadline: BigInt(deadlineValue),
+                    const domain = {
+                        name: dn,
+                        version: dv,
                         chainId,
                         verifyingContract,
-                        domainName: dn,
-                        domainVersion: dv,
-                    }));
+                    };
+                    variants.push({
+                        domain,
+                        primaryType: 'AgentWalletSet',
+                        types: {
+                            AgentWalletSet: [
+                                { name: 'agentId', type: 'uint256' },
+                                { name: 'newWallet', type: 'address' },
+                                { name: 'owner', type: 'address' },
+                                { name: 'deadline', type: 'uint256' },
+                            ],
+                        },
+                        message: {
+                            agentId: BigInt(tokenId),
+                            newWallet,
+                            owner,
+                            deadline: BigInt(deadlineValue),
+                        },
+                    });
+                    variants.push({
+                        domain,
+                        primaryType: 'AgentWalletSet',
+                        types: {
+                            AgentWalletSet: [
+                                { name: 'agentId', type: 'uint256' },
+                                { name: 'newWallet', type: 'address' },
+                                { name: 'deadline', type: 'uint256' },
+                            ],
+                        },
+                        message: {
+                            agentId: BigInt(tokenId),
+                            newWallet,
+                            deadline: BigInt(deadlineValue),
+                        },
+                    });
                 }
             }
             let lastError;
-            const trySignAndEstimate = async (signerMode) => {
-                for (const v of variants) {
-                    try {
-                        const sig = signerMode === 'newWallet'
-                            ? signerForNewWallet
-                                ? await this.sdk.web3Client.signTypedDataWith(signerForNewWallet, v.domain, v.types, v.message)
-                                : await this.sdk.web3Client.signTypedData(v.domain, v.types, v.message)
-                            : await this.sdk.web3Client.signTypedData(v.domain, v.types, v.message);
-                        const recovered = this.sdk.web3Client.recoverTypedDataSigner(v.domain, v.types, v.message, sig);
-                        const expected = signerMode === 'newWallet' ? newWallet.toLowerCase() : (sdkSignerAddress || '').toLowerCase();
-                        if (!expected || recovered.toLowerCase() !== expected) {
-                            throw new Error(`EIP-712 signature recovery mismatch (${signerMode} signing): recovered ${recovered} but expected ${expected || 'unknown'}`);
-                        }
-                        await estimateSetAgentWallet(sig);
-                        signature = sig;
-                        return;
+            for (const v of variants) {
+                try {
+                    let sig;
+                    if (opts?.newWalletPrivateKey) {
+                        const acc = privateKeyToAccount((opts.newWalletPrivateKey.startsWith('0x')
+                            ? opts.newWalletPrivateKey
+                            : `0x${opts.newWalletPrivateKey}`));
+                        sig = normalizeEcdsaSignature((await acc.signTypedData({
+                            domain: v.domain,
+                            types: v.types,
+                            primaryType: v.primaryType,
+                            message: v.message,
+                        })));
                     }
-                    catch (e) {
-                        lastError = e;
+                    else {
+                        sig = await this.sdk.chainClient.signTypedData({
+                            domain: v.domain,
+                            types: v.types,
+                            primaryType: v.primaryType,
+                            message: v.message,
+                        });
                     }
+                    const recovered = await recoverTypedDataSigner({
+                        domain: v.domain,
+                        types: v.types,
+                        primaryType: v.primaryType,
+                        message: v.message,
+                        signature: sig,
+                    });
+                    if (recovered.toLowerCase() !== getAddress(newWallet).toLowerCase()) {
+                        throw new Error(`EIP-712 recovery mismatch: recovered ${recovered}, expected ${newWallet}`);
+                    }
+                    signature = sig;
+                    break;
+                }
+                catch (e) {
+                    lastError = e;
                 }
-            };
-            // Preferred: newWallet signs (spec-aligned)
-            await trySignAndEstimate('newWallet');
-            // Fallback: some legacy deployments may require the agent owner (tx sender) to sign instead.
-            if (!signature && sdkSignerAddress) {
-                await trySignAndEstimate('owner');
             }
             if (!signature) {
                 const msg = lastError instanceof Error ? lastError.message : String(lastError);
@@ -480,7 +519,12 @@ export class Agent {
             }
         }
         // Call contract function (tx sender is SDK signer: owner/operator)
-        const txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'setAgentWallet', {}, BigInt(tokenId), newWallet, BigInt(deadlineValue), signature);
+        const txHash = await this.sdk.chainClient.writeContract({
+            address: identityRegistryAddress,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: 'setAgentWallet',
+            args: [BigInt(tokenId), newWallet, BigInt(deadlineValue), signature],
+        });
         // Update local registration file
         this.registrationFile.walletAddress = newWallet;
         this.registrationFile.walletChainId = chainId;
@@ -560,7 +604,7 @@ export class Agent {
             // Agent already registered - update registration file and redeploy
             // Option 2D: Add logging and timeout handling
             const chainId = await this.sdk.chainId();
-            const identityRegistryAddress = await this.sdk.getIdentityRegistry().getAddress();
+            const identityRegistryAddress = this.sdk.identityRegistryAddress();
             const ipfsCid = await this.sdk.ipfsClient.addRegistrationFile(this.registrationFile, chainId, identityRegistryAddress);
             // Update metadata on-chain if changed
             // Only send transactions for dirty (changed) metadata to save gas
@@ -574,11 +618,16 @@ export class Agent {
             }
             // Update agent URI on-chain
             const { tokenId } = parseAgentId(this.registrationFile.agentId);
-            const txHash = await this.sdk.web3Client.transactContract(this.sdk.getIdentityRegistry(), 'setAgentURI', {}, BigInt(tokenId), `ipfs://${ipfsCid}`);
+            const txHash = await this.sdk.chainClient.writeContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'setAgentURI',
+                args: [BigInt(tokenId), `ipfs://${ipfsCid}`],
+            });
             // Wait for transaction to be confirmed (30 second timeout like Python)
             // If timeout, continue - transaction was sent and will eventually confirm
             try {
-                await this.sdk.web3Client.waitForTransaction(txHash, TIMEOUTS.TRANSACTION_WAIT);
+                await this.sdk.chainClient.waitForTransaction({ hash: txHash, timeoutMs: TIMEOUTS.TRANSACTION_WAIT });
             }
             catch {
                 // Transaction was sent and will eventually confirm - continue silently
@@ -596,13 +645,18 @@ export class Agent {
             await this._registerWithoutUri();
             // Step 2: Upload to IPFS
             const chainId = await this.sdk.chainId();
-            const identityRegistryAddress = await this.sdk.getIdentityRegistry().getAddress();
+            const identityRegistryAddress = this.sdk.identityRegistryAddress();
             const ipfsCid = await this.sdk.ipfsClient.addRegistrationFile(this.registrationFile, chainId, identityRegistryAddress);
             // Step 3: Set agent URI on-chain
             const { tokenId } = parseAgentId(this.registrationFile.agentId);
-            const txHash = await this.sdk.web3Client.transactContract(this.sdk.getIdentityRegistry(), 'setAgentURI', {}, BigInt(tokenId), `ipfs://${ipfsCid}`);
+            const txHash = await this.sdk.chainClient.writeContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'setAgentURI',
+                args: [BigInt(tokenId), `ipfs://${ipfsCid}`],
+            });
             // Wait for transaction to be confirmed
-            await this.sdk.web3Client.waitForTransaction(txHash);
+            await this.sdk.chainClient.waitForTransaction({ hash: txHash });
             // Clear dirty flags
             this._lastRegisteredWallet = this.walletAddress;
             this._lastRegisteredEns = this.ensEndpoint;
@@ -637,7 +691,13 @@ export class Agent {
             throw new Error('Agent must be registered before setting URI');
         }
         const { tokenId } = parseAgentId(this.registrationFile.agentId);
-        await this.sdk.web3Client.transactContract(this.sdk.getIdentityRegistry(), 'setAgentURI', {}, BigInt(tokenId), agentURI);
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
+        await this.sdk.chainClient.writeContract({
+            address: identityRegistryAddress,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: 'setAgentURI',
+            args: [BigInt(tokenId), agentURI],
+        });
         this.registrationFile.agentURI = agentURI;
         this.registrationFile.updatedAt = Math.floor(Date.now() / 1000);
     }
@@ -649,13 +709,10 @@ export class Agent {
             throw new Error('Agent must be registered before transfer');
         }
         const { tokenId } = parseAgentId(this.registrationFile.agentId);
-        const currentOwner = this.sdk.web3Client.address;
-        if (!currentOwner) {
-            throw new Error('No signer available');
-        }
+        const currentOwner = await this.sdk.chainClient.ensureAddress();
         // Validate address - normalize to lowercase first
         const normalizedAddress = newOwner.toLowerCase();
-        if (!this.sdk.web3Client.isAddress(normalizedAddress)) {
+        if (!this.sdk.chainClient.isAddress(normalizedAddress)) {
             throw new Error(`Invalid address: ${newOwner}`);
         }
         // Validate not zero address (check before expensive operations)
@@ -663,13 +720,18 @@ export class Agent {
             throw new Error('Cannot transfer agent to zero address');
         }
         // Convert to checksum format
-        const checksumAddress = this.sdk.web3Client.toChecksumAddress(normalizedAddress);
+        const checksumAddress = this.sdk.chainClient.toChecksumAddress(normalizedAddress);
         // Validate not transferring to self
         if (checksumAddress.toLowerCase() === currentOwner.toLowerCase()) {
             throw new Error('Cannot transfer agent to yourself');
         }
-        const identityRegistry = this.sdk.getIdentityRegistry();
-        const txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'transferFrom', {}, currentOwner, checksumAddress, BigInt(tokenId));
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
+        const txHash = await this.sdk.chainClient.writeContract({
+            address: identityRegistryAddress,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: 'transferFrom',
+            args: [currentOwner, checksumAddress, BigInt(tokenId)],
+        });
         return {
             txHash,
             from: currentOwner,
@@ -683,23 +745,28 @@ export class Agent {
     async _registerWithoutUri() {
         // Collect metadata for registration
         const metadataEntries = this._collectMetadataForRegistration();
-        // Mint agent with metadata
-        const identityRegistry = this.sdk.getIdentityRegistry();
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
         // If we have metadata, use register(string, tuple[])
         // Otherwise use register() with no args
         let txHash;
         if (metadataEntries.length > 0) {
-            txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'register', {}, // Transaction options
-            '', // Empty tokenUri
-            metadataEntries);
+            txHash = await this.sdk.chainClient.writeContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'register',
+                args: ['', metadataEntries],
+            });
         }
         else {
-            txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'register', {} // Transaction options
-            // No arguments - calls register()
-            );
+            txHash = await this.sdk.chainClient.writeContract({
+                address: identityRegistryAddress,
+                abi: IDENTITY_REGISTRY_ABI,
+                functionName: 'register',
+                args: [],
+            });
         }
         // Wait for transaction
-        const receipt = await this.sdk.web3Client.waitForTransaction(txHash);
+        const receipt = await this.sdk.chainClient.waitForTransaction({ hash: txHash });
         // Extract agent ID from events
         const agentId = this._extractAgentIdFromReceipt(receipt);
         // Update registration file
@@ -710,11 +777,15 @@ export class Agent {
     async _registerWithUri(agentUri) {
         // Collect metadata for registration
         const metadataEntries = this._collectMetadataForRegistration();
-        // Register with URI and metadata
-        const identityRegistry = this.sdk.getIdentityRegistry();
-        const txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'register', {}, agentUri, metadataEntries);
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
+        const txHash = await this.sdk.chainClient.writeContract({
+            address: identityRegistryAddress,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: 'register',
+            args: [agentUri, metadataEntries],
+        });
         // Wait for transaction
-        const receipt = await this.sdk.web3Client.waitForTransaction(txHash);
+        const receipt = await this.sdk.chainClient.waitForTransaction({ hash: txHash });
         // Extract agent ID from events
         const agentId = this._extractAgentIdFromReceipt(receipt);
         // Update registration file
@@ -727,16 +798,21 @@ export class Agent {
     async _updateMetadataOnChain() {
         const metadataEntries = this._collectMetadataForRegistration();
         const { tokenId } = parseAgentId(this.registrationFile.agentId);
-        const identityRegistry = this.sdk.getIdentityRegistry();
+        const identityRegistryAddress = this.sdk.identityRegistryAddress();
         // Update metadata one by one (like Python SDK)
         // Only send transactions for dirty (changed) metadata keys
         for (const entry of metadataEntries) {
             if (this._dirtyMetadata.has(entry.metadataKey)) {
-                const txHash = await this.sdk.web3Client.transactContract(identityRegistry, 'setMetadata', {}, BigInt(tokenId), entry.metadataKey, entry.metadataValue);
+                const txHash = await this.sdk.chainClient.writeContract({
+                    address: identityRegistryAddress,
+                    abi: IDENTITY_REGISTRY_ABI,
+                    functionName: 'setMetadata',
+                    args: [BigInt(tokenId), entry.metadataKey, entry.metadataValue],
+                });
                 // Wait with 30 second timeout (like Python SDK)
                 // If timeout, log warning but continue - transaction was sent and will eventually confirm
                 try {
-                    await this.sdk.web3Client.waitForTransaction(txHash, TIMEOUTS.TRANSACTION_WAIT);
+                    await this.sdk.chainClient.waitForTransaction({ hash: txHash, timeoutMs: TIMEOUTS.TRANSACTION_WAIT });
                 }
                 catch (error) {
                     // Transaction was sent and will eventually confirm - continue silently
@@ -770,19 +846,22 @@ export class Agent {
         return entries;
     }
     _extractAgentIdFromReceipt(receipt) {
-        // Parse events from receipt to find Registered event
-        const identityRegistry = this.sdk.getIdentityRegistry();
         const transferEventTopic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'; // Transfer(address,address,uint256)
         // Find the event in the logs
         for (const log of receipt.logs || []) {
             try {
-                // Try parsing as Registered event
-                const parsed = identityRegistry.interface.parseLog({
-                    topics: Array.isArray(log.topics) ? log.topics.map((t) => typeof t === 'string' ? t : ethers.hexlify(t)) : log.topics || [],
-                    data: typeof log.data === 'string' ? log.data : ethers.hexlify(log.data || '0x'),
+                if (!log.topics || log.topics.length === 0) {
+                    continue;
+                }
+                const parsed = decodeEventLog({
+                    abi: IDENTITY_REGISTRY_ABI,
+                    data: log.data,
+                    topics: log.topics,
                 });
-                if (parsed && parsed.name === 'Registered') {
-                    return BigInt(parsed.args.agentId.toString());
+                if (parsed && parsed.eventName === 'Registered') {
+                    const agentId = parsed.args?.agentId;
+                    if (agentId !== undefined)
+                        return BigInt(agentId);
                 }
             }
             catch {
@@ -791,10 +870,10 @@ export class Agent {
                     const topics = Array.isArray(log.topics) ? log.topics : [];
                     // Transfer event has topic[0] = Transfer signature, topic[3] = tokenId (if 4 topics)
                     if (topics.length >= 4) {
-                        const topic0 = typeof topics[0] === 'string' ? topics[0] : topics[0].toString();
+                        const topic0 = String(topics[0]);
                         if (topic0 === transferEventTopic || topic0.toLowerCase() === transferEventTopic.toLowerCase()) {
                             // Extract tokenId from topic[3]
-                            const tokenIdHex = typeof topics[3] === 'string' ? topics[3] : topics[3].toString();
+                            const tokenIdHex = String(topics[3]);
                             // Remove 0x prefix if present and convert
                             const tokenIdStr = tokenIdHex.startsWith('0x') ? tokenIdHex.slice(2) : tokenIdHex;
                             return BigInt('0x' + tokenIdStr);