Merge #387: erc8004 wait for read-side consistency before setMetadata

Pulls in the WaitForAgent / AgentWallet helpers + post-Register wait
in the CLI register paths, ahead of v0.9.0-rc1.

Author: bussyjd

cmd/obol/sell.go

@@ -1937,6 +1937,14 @@ func registerDirectViaSigner(ctx context.Context, cfg *config.Config, u *ui.UI,
 	u.Printf("    Agent ID: %s", agentID.String())
 	u.Printf("    Owner:    %s", addr.Hex())
 
+	// The Register tx is mined on the WRITE upstream, but a follow-up
+	// setMetadata estimateGas goes through the READ upstream which can lag
+	// (we observed ERC721NonexistentToken reverts when a stale eRPC route was
+	// pinned to a parallel Anvil fork). Block until the reader sees the token.
+	if _, err := client.WaitForAgent(ctx, agentID, 30*time.Second); err != nil {
+		u.Warnf("agent not visible to reader after register: %v", err)
+	}
+
 	// Set x402 metadata.
 	x402Meta := []byte(`{"x402":true}`)
 	if err := client.SetMetadataWithOpts(ctx, opts, agentID, "x402", x402Meta); err != nil {
@@ -1971,6 +1979,12 @@ func registerDirectWithKey(ctx context.Context, cfg *config.Config, u *ui.UI, ne
 	u.Printf("    Agent ID: %s", agentID.String())
 	u.Printf("    Owner:    %s", txAddr.Hex())
 
+	// Wait for the chain READER to catch up to the freshly-minted agent id;
+	// see comment in registerWithRemoteSigner for the rationale.
+	if _, err := client.WaitForAgent(ctx, agentID, 30*time.Second); err != nil {
+		u.Warnf("agent not visible to reader after register: %v", err)
+	}
+
 	x402Meta := []byte(`{"x402":true}`)
 	if err := client.SetMetadata(ctx, key, agentID, "x402", x402Meta); err != nil {
 		u.Warnf("failed to set x402 metadata: %v", err)

internal/erc8004/client.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math/big"
 	"strings"
+	"time"
 
 	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
@@ -294,6 +295,57 @@ func (c *Client) SetMetadata(ctx context.Context, key *ecdsa.PrivateKey, agentID
 	return nil
 }
 
+// AgentWallet returns the registered wallet for an agent id via the ERC-8004
+// `getAgentWallet` view, or an error if the READER reports a revert (the
+// pre-mint case appears as ERC721NonexistentToken). Used by WaitForAgent to
+// confirm the chain READER has caught up to a recent register tx before
+// follow-up calls (setMetadata, setAgentURI) try to estimate gas against a
+// state where the token id is still unknown.
+func (c *Client) AgentWallet(ctx context.Context, agentID *big.Int) (common.Address, error) {
+	var out []interface{}
+	if err := c.contract.Call(&bind.CallOpts{Context: ctx}, &out, "getAgentWallet", agentID); err != nil {
+		return common.Address{}, fmt.Errorf("erc8004: getAgentWallet: %w", err)
+	}
+	if len(out) == 0 {
+		return common.Address{}, fmt.Errorf("erc8004: getAgentWallet: empty return")
+	}
+	addr, ok := out[0].(common.Address)
+	if !ok {
+		return common.Address{}, fmt.Errorf("erc8004: getAgentWallet: unexpected type %T", out[0])
+	}
+	return addr, nil
+}
+
+// WaitForAgent polls AgentWallet until the chain READER reports the agent id
+// as owned (any address). Returns when it does, or err on timeout. This closes
+// the read-side staleness window after Register: the Register tx confirms via
+// WaitMined on the WRITE upstream, but a subsequent setMetadata estimateGas
+// goes through the READ upstream which may still be a block or two behind
+// (we hit this in production when a stale eRPC route was pinned to a
+// parallel Anvil fork — the simulation reverted with ERC721NonexistentToken).
+func (c *Client) WaitForAgent(ctx context.Context, agentID *big.Int, timeout time.Duration) (common.Address, error) {
+	if timeout <= 0 {
+		timeout = 30 * time.Second
+	}
+	deadline := time.Now().Add(timeout)
+	var lastErr error
+	for {
+		addr, err := c.AgentWallet(ctx, agentID)
+		if err == nil {
+			return addr, nil
+		}
+		lastErr = err
+		if time.Now().After(deadline) {
+			return common.Address{}, fmt.Errorf("erc8004: waitForAgent %s timed out after %s: %w", agentID, timeout, lastErr)
+		}
+		select {
+		case <-ctx.Done():
+			return common.Address{}, ctx.Err()
+		case <-time.After(2 * time.Second):
+		}
+	}
+}
+
 // GetMetadata reads metadata for the given key from the agent NFT.
 func (c *Client) GetMetadata(ctx context.Context, agentID *big.Int, k string) ([]byte, error) {
 	var out []interface{}

internal/erc8004/client_test.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
@@ -633,3 +634,93 @@ func TestGetMetadata_EmptyResult(t *testing.T) {
 func parseABI() (abi.ABI, error) {
 	return abi.JSON(strings.NewReader(identityRegistryABI))
 }
+
+// TestWaitForAgent_RetriesUntilOwnerVisible verifies that WaitForAgent keeps
+// polling ownerOf until the reader returns a successful result, simulating
+// the read-side staleness window between Register's WaitMined (write upstream)
+// and a subsequent setMetadata estimateGas (read upstream).
+func TestWaitForAgent_RetriesUntilOwnerVisible(t *testing.T) {
+	var attempts int
+	owner := common.HexToAddress("0x2FbFe6cF08Ac224f97915ecF07eE29Be0b213f51")
+
+	parsedABI, err := parseABI()
+	if err != nil {
+		t.Fatalf("parseABI: %v", err)
+	}
+
+	handlers := map[string]func([]json.RawMessage) (json.RawMessage, error){
+		"eth_chainId": func(_ []json.RawMessage) (json.RawMessage, error) {
+			return json.RawMessage(`"0x14a34"`), nil
+		},
+		"eth_call": func(_ []json.RawMessage) (json.RawMessage, error) {
+			attempts++
+			if attempts < 3 {
+				// Simulate ERC721NonexistentToken on first two calls (read
+				// upstream not yet caught up).
+				return nil, fmt.Errorf("execution reverted")
+			}
+			// Third call: encode owner as ownerOf return.
+			ownerBytes, encErr := parsedABI.Methods["getAgentWallet"].Outputs.Pack(owner)
+			if encErr != nil {
+				return nil, encErr
+			}
+			return json.RawMessage(fmt.Sprintf("%q", "0x"+common.Bytes2Hex(ownerBytes))), nil
+		},
+	}
+
+	srv := mockRPC(t, handlers)
+	defer srv.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	client, err := NewClient(ctx, srv.URL)
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	defer client.Close()
+
+	got, err := client.WaitForAgent(ctx, big.NewInt(5196), 20*time.Second)
+	if err != nil {
+		t.Fatalf("WaitForAgent: %v after %d attempts", err, attempts)
+	}
+	if got != owner {
+		t.Errorf("expected owner %s, got %s", owner, got)
+	}
+	if attempts < 3 {
+		t.Errorf("expected at least 3 attempts (2 reverts + 1 success), got %d", attempts)
+	}
+}
+
+// TestWaitForAgent_TimeoutReturnsError verifies that persistent reverts
+// surface as a timeout error.
+func TestWaitForAgent_TimeoutReturnsError(t *testing.T) {
+	handlers := map[string]func([]json.RawMessage) (json.RawMessage, error){
+		"eth_chainId": func(_ []json.RawMessage) (json.RawMessage, error) {
+			return json.RawMessage(`"0x14a34"`), nil
+		},
+		"eth_call": func(_ []json.RawMessage) (json.RawMessage, error) {
+			return nil, fmt.Errorf("execution reverted")
+		},
+	}
+
+	srv := mockRPC(t, handlers)
+	defer srv.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	client, err := NewClient(ctx, srv.URL)
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	defer client.Close()
+
+	_, err = client.WaitForAgent(ctx, big.NewInt(5196), 3*time.Second)
+	if err == nil {
+		t.Fatal("expected timeout error, got nil")
+	}
+	if !strings.Contains(err.Error(), "timed out") {
+		t.Errorf("expected 'timed out' in error, got: %v", err)
+	}
+}