Ens Primary Name

#!/bin/bash
# ENS Avatar - Set avatar for your ENS name
# Usage: ./set-avatar.sh <ens-name> <avatar-url>
# Example: ./set-avatar.sh myname.eth https://example.com/avatar.png
#
# Avatar URL formats:
# - HTTPS: https://example.com/image.png
# - IPFS: ipfs://QmHash
# - NFT: eip155:1/erc721:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/1234

set -e

ENS_NAME="${1:?Usage: set-avatar.sh <ens-name> <avatar-url>}"
AVATAR_URL="${2:?Usage: set-avatar.sh <ens-name> <avatar-url>}"

# Require Bankr CLI
if ! command -v bankr >/dev/null 2>&1; then
  echo "Bankr CLI not found. Install with: bun install -g @bankr/cli" >&2
  exit 1
fi

# Avatars are text records stored on L1
RPC_URL="https://eth.publicnode.com"
CHAIN_ID=1
EXPLORER="etherscan.io"

echo "=== ENS Avatar Setup ===" >&2
echo "Name: $ENS_NAME" >&2
echo "Avatar: $AVATAR_URL" >&2

# Step 1: Look up the resolver for this ENS name
echo "Looking up resolver..." >&2
RESOLVER=$(curl -s -X POST "https://api.thegraph.com/subgraphs/name/ensdomains/ens" \
  -H "Content-Type: application/json" \
  -d "{\"query\":\"{ domains(where:{name:\\\"$ENS_NAME\\\"}) { resolver { address } } }\"}" | \
  grep -oE '"address":"0x[a-fA-F0-9]{40}"' | grep -oE '0x[a-fA-F0-9]{40}')

if [ -z "$RESOLVER" ]; then
  echo "ERROR: Could not find resolver for $ENS_NAME" >&2
  echo "Make sure the name exists and has a resolver set." >&2
  exit 1
fi

echo "Resolver: $RESOLVER" >&2

# Step 2: Calculate namehash and encode calldata
CALLDATA=$(node -e "
const { keccak256, toBytes, concat } = require('viem');

// Namehash calculation
function namehash(name) {
  if (!name) return new Uint8Array(32);
  const labels = name.split('.');
  let node = new Uint8Array(32);
  for (let i = labels.length - 1; i >= 0; i--) {
    const labelHash = keccak256(toBytes(labels[i]));
    node = keccak256(concat([node, labelHash]));
  }
  return node;
}

const name = '$ENS_NAME';
const avatar = '$AVATAR_URL';
const node = namehash(name).slice(2); // remove 0x
const key = 'avatar';

// setText(bytes32 node, string key, string value)
// Selector: 0x10f13a8c
const selector = '10f13a8c';

// Encode ABI for setText(bytes32, string, string)
const keyOffset = '0000000000000000000000000000000000000000000000000000000000000060';
const keyLen = key.length.toString(16).padStart(64, '0');
const keyData = Buffer.from(key, 'utf8').toString('hex').padEnd(64, '0');
const valueLen = avatar.length.toString(16).padStart(64, '0');
const valueData = Buffer.from(avatar, 'utf8').toString('hex').padEnd(Math.ceil(avatar.length / 32) * 64, '0');

// Value offset = 0x60 + 0x20 + 0x20 = 0xa0
const valueOffset = '00000000000000000000000000000000000000000000000000000000000000a0';

console.log('0x' + selector + node + keyOffset + valueOffset + keyLen + keyData + valueLen + valueData);
")

echo "Submitting to resolver on Ethereum mainnet..." >&2
echo "⚠️  Note: This requires ETH on mainnet for gas" >&2

# Submit transaction via Bankr
RESULT=$(bankr prompt "Submit this transaction: {\"to\": \"$RESOLVER\", \"data\": \"$CALLDATA\", \"value\": \"0\", \"chainId\": $CHAIN_ID}" 2>/dev/null)

if echo "$RESULT" | grep -q "$EXPLORER"; then
  TX_HASH=$(echo "$RESULT" | grep -oE "$EXPLORER/tx/0x[a-fA-F0-9]{64}" | grep -oE '0x[a-fA-F0-9]{64}')
  echo "=== SUCCESS ===" >&2
  echo "Avatar set for: $ENS_NAME" >&2
  echo "TX: https://$EXPLORER/tx/$TX_HASH" >&2
  echo "{\"success\":true,\"name\":\"$ENS_NAME\",\"avatar\":\"$AVATAR_URL\",\"resolver\":\"$RESOLVER\",\"tx\":\"$TX_HASH\"}"
elif echo "$RESULT" | grep -q "reverted"; then
  echo "Transaction reverted. Make sure:" >&2
  echo "1. You own or control the ENS name" >&2
  echo "2. The resolver supports setText" >&2
  echo "3. You have permission to set records" >&2
  echo "Error: $RESULT" >&2
  exit 1
else
  echo "Failed: $RESULT" >&2
  exit 1
fi

#!/bin/bash
# ENS Primary Name - Set your primary ENS name on Base (or other L2s)
# Usage: ./set-primary.sh <ens-name> [chain]
# Example: ./set-primary.sh myname.eth base

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENS_NAME="${1:?Usage: set-primary.sh <ens-name> [chain]}"
CHAIN="${2:-base}"

# Require Bankr CLI
if ! command -v bankr >/dev/null 2>&1; then
  echo "Bankr CLI not found. Install with: bun install -g @bankr/cli" >&2
  exit 1
fi

# Reverse Registrar addresses by chain
case "$CHAIN" in
  base)
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    RPC_URL="https://mainnet.base.org"
    CHAIN_ID=8453
    EXPLORER="basescan.org"
    ;;
  arbitrum)
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    RPC_URL="https://arb1.arbitrum.io/rpc"
    CHAIN_ID=42161
    EXPLORER="arbiscan.io"
    ;;
  optimism)
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    RPC_URL="https://mainnet.optimism.io"
    CHAIN_ID=10
    EXPLORER="optimistic.etherscan.io"
    ;;
  ethereum|mainnet)
    REVERSE_REGISTRAR="0x283F227c4Bd38ecE252C4Ae7ECE650B0e913f1f9"
    RPC_URL="https://eth.llamarpc.com"
    CHAIN_ID=1
    EXPLORER="etherscan.io"
    ;;
  *)
    echo "Unsupported chain: $CHAIN" >&2
    echo "Supported: base, arbitrum, optimism, ethereum" >&2
    exit 1
    ;;
esac

echo "=== ENS Primary Name Setup ===" >&2
echo "Name: $ENS_NAME" >&2
echo "Chain: $CHAIN (ID: $CHAIN_ID)" >&2
echo "Reverse Registrar: $REVERSE_REGISTRAR" >&2
echo "" >&2

# Step 1: Check forward resolution
echo "Step 1: Checking forward resolution..." >&2

# Query ENS subgraph for resolver and resolved address
ENS_DATA=$(curl -s -X POST "https://api.thegraph.com/subgraphs/name/ensdomains/ens" \
  -H "Content-Type: application/json" \
  -d "{\"query\":\"{ domains(where:{name:\\\"$ENS_NAME\\\"}) { name resolvedAddress { id } resolver { address } } }\"}")

RESOLVED_ADDR=$(echo "$ENS_DATA" | grep -oE '"id":"0x[a-fA-F0-9]{40}"' | head -1 | grep -oE '0x[a-fA-F0-9]{40}')
RESOLVER_ADDR=$(echo "$ENS_DATA" | grep -oE '"address":"0x[a-fA-F0-9]{40}"' | head -1 | grep -oE '0x[a-fA-F0-9]{40}')

if [ -z "$RESOLVED_ADDR" ]; then
  echo "ERROR: $ENS_NAME does not resolve to any address!" >&2
  echo "Please set the address for this name first via app.ens.domains" >&2
  exit 1
fi

echo "Forward resolution (default): $ENS_NAME → $RESOLVED_ADDR" >&2
echo "Resolver: $RESOLVER_ADDR" >&2

# Check chain-specific address if not mainnet
if [ "$CHAIN_ID" != "1" ] && [ -n "$RESOLVER_ADDR" ]; then
  # Compute namehash for the name
  NAMEHASH=$(node -e "
    const { namehash } = require('viem/ens');
    console.log(namehash('$ENS_NAME'));
  " 2>/dev/null || echo "")
  
  if [ -n "$NAMEHASH" ] && [ -n "${THIRDWEB_SECRET_KEY:-}" ]; then
    CHAIN_ADDR=$(curl -s "https://api.thirdweb.com/v1/contracts/read" \
      -H "x-secret-key: ${THIRDWEB_SECRET_KEY}" \
      -H "Content-Type: application/json" \
      -d "{
        \"chainId\": 1,
        \"calls\": [{
          \"contractAddress\": \"$RESOLVER_ADDR\",
          \"method\": \"function addr(bytes32 node, uint256 coinType) view returns (bytes)\",
          \"params\": [\"$NAMEHASH\", $CHAIN_ID]
        }]
      }" 2>/dev/null | grep -oE '"data":"0x[a-fA-F0-9]+"' | grep -oE '0x[a-fA-F0-9]+' | tail -1)
    
    if [ -z "$CHAIN_ADDR" ] || [ "$CHAIN_ADDR" = "0x" ]; then
      echo "" >&2
      echo "⚠️  WARNING: Chain-specific address (cointype $CHAIN_ID) is NOT set!" >&2
      echo "   For full L2 primary name verification, you may need to set the $CHAIN address" >&2
      echo "   for $ENS_NAME on the L1 resolver via app.ens.domains" >&2
      echo "" >&2
    else
      echo "Forward resolution ($CHAIN cointype): $ENS_NAME → $CHAIN_ADDR" >&2
    fi
  fi
fi

# Step 2: Set reverse record
echo "" >&2
echo "Step 2: Setting reverse record..." >&2

# Encode setName(string) calldata
CALLDATA=$(node -e "
const name = '$ENS_NAME';
const selector = '0xc47f0027';
const offset = '0000000000000000000000000000000000000000000000000000000000000020';
const len = name.length.toString(16).padStart(64, '0');
const data = Buffer.from(name, 'utf8').toString('hex').padEnd(Math.ceil(name.length / 32) * 64, '0');
console.log(selector + offset + len + data);
")

echo "Calldata: $CALLDATA" >&2
echo "Submitting transaction..." >&2

RESULT=$(bankr prompt "Submit this transaction: {\"to\": \"$REVERSE_REGISTRAR\", \"data\": \"$CALLDATA\", \"value\": \"0\", \"chainId\": $CHAIN_ID}" 2>/dev/null)

if echo "$RESULT" | grep -q "$EXPLORER"; then
  TX_HASH=$(echo "$RESULT" | grep -oE "$EXPLORER/tx/0x[a-fA-F0-9]{64}" | grep -oE '0x[a-fA-F0-9]{64}')
  echo "" >&2
  echo "=== REVERSE RECORD SET ===" >&2
  echo "TX: https://$EXPLORER/tx/$TX_HASH" >&2
  
  # Step 3: Verify
  echo "" >&2
  echo "Step 3: Verifying primary name..." >&2
  sleep 3  # Wait for indexing
  
  "$SCRIPT_DIR/verify-primary.sh" "$RESOLVED_ADDR" "$CHAIN" 2>&1
  
  echo "{\"success\":true,\"name\":\"$ENS_NAME\",\"chain\":\"$CHAIN\",\"tx\":\"$TX_HASH\",\"address\":\"$RESOLVED_ADDR\"}"
elif echo "$RESULT" | grep -q "reverted"; then
  echo "Transaction reverted. Make sure:" >&2
  echo "1. The ENS name resolves to your address on $CHAIN" >&2
  echo "2. You own or control the name" >&2
  echo "Error: $RESULT" >&2
  exit 1
else
  echo "Failed: $RESULT" >&2
  exit 1
fi

#!/bin/bash
# Verify ENS primary name is correctly set
# Usage: ./verify-primary.sh <address> [chain]
# Example: ./verify-primary.sh 0x1234... base

set -e

ADDRESS="${1:?Usage: verify-primary.sh <address> [chain]}"
CHAIN="${2:-base}"

# Normalize address to lowercase
ADDRESS=$(echo "$ADDRESS" | tr '[:upper:]' '[:lower:]')

# Chain configuration
case "$CHAIN" in
  base)
    RPC_URL="https://mainnet.base.org"
    CHAIN_ID=8453
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    IS_L2=true
    ;;
  arbitrum)
    RPC_URL="https://arb1.arbitrum.io/rpc"
    CHAIN_ID=42161
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    IS_L2=true
    ;;
  optimism)
    RPC_URL="https://mainnet.optimism.io"
    CHAIN_ID=10
    REVERSE_REGISTRAR="0x0000000000D8e504002cC26E3Ec46D81971C1664"
    IS_L2=true
    ;;
  ethereum|mainnet)
    RPC_URL="https://eth.publicnode.com"
    CHAIN_ID=1
    REVERSE_REGISTRAR="0x283F227c4Bd38ecE252C4Ae7ECE650B0e913f1f9"
    IS_L2=false
    ;;
  *)
    echo "Unsupported chain: $CHAIN" >&2
    exit 1
    ;;
esac

echo "=== ENS Primary Name Verification ===" >&2
echo "Address: $ADDRESS" >&2
echo "Chain: $CHAIN (ID: $CHAIN_ID)" >&2
echo "" >&2

# Step 1: Check reverse record (address → name)
echo "Checking reverse record..." >&2

if [ "$IS_L2" = "true" ]; then
  # L2: Use nameForAddr(address) on the Reverse Registrar
  # Selector: 0x4ec3bd23
  SELECTOR="0x4ec3bd23"
  ADDR_PADDED="000000000000000000000000${ADDRESS:2}"
  
  REVERSE_RESULT=$(curl -s --max-time 10 -X POST "$RPC_URL" \
    -H "Content-Type: application/json" \
    -d "{
      \"jsonrpc\": \"2.0\",
      \"id\": 1,
      \"method\": \"eth_call\",
      \"params\": [{
        \"to\": \"$REVERSE_REGISTRAR\",
        \"data\": \"${SELECTOR}${ADDR_PADDED}\"
      }, \"latest\"]
    }" | grep -oE '"result":"[^"]*"' | sed 's/"result":"//;s/"$//')
  
  # Decode the result (ABI-encoded string)
  if [ -z "$REVERSE_RESULT" ] || [ "$REVERSE_RESULT" = "0x" ]; then
    REVERSE_NAME=""
  else
    REVERSE_NAME=$(node -e "
      const hex = '$REVERSE_RESULT';
      if (hex === '0x' || hex.length < 130) {
        process.exit(0);
      }
      try {
        const length = parseInt(hex.slice(66, 130), 16);
        if (length === 0) process.exit(0);
        const data = hex.slice(130, 130 + length * 2);
        console.log(Buffer.from(data, 'hex').toString('utf8'));
      } catch (e) {}
    " 2>/dev/null)
  fi
else
  # L1 (Ethereum mainnet): Use viem's getEnsName
  REVERSE_NAME=$(timeout 15 node -e "
    const { createPublicClient, http } = require('viem');
    const { mainnet } = require('viem/chains');
    
    const client = createPublicClient({
      chain: mainnet,
      transport: http('$RPC_URL'),
    });
    
    (async () => {
      try {
        const name = await client.getEnsName({ address: '$ADDRESS' });
        if (name) console.log(name);
      } catch (e) {}
    })();
  " 2>/dev/null || echo "")
fi

if [ -n "$REVERSE_NAME" ]; then
  echo "✅ Reverse record: $ADDRESS → $REVERSE_NAME" >&2
else
  echo "❌ No reverse record found" >&2
fi

# Step 2: Check forward resolution (name → address)
if [ -n "$REVERSE_NAME" ]; then
  echo "" >&2
  echo "Checking forward resolution..." >&2
  
  # Query ENS subgraph for forward resolution
  ENS_DATA=$(curl -s --max-time 10 -X POST "https://api.thegraph.com/subgraphs/name/ensdomains/ens" \
    -H "Content-Type: application/json" \
    -d "{\"query\":\"{ domains(where:{name:\\\"$REVERSE_NAME\\\"}) { resolvedAddress { id } } }\"}")
  
  FORWARD_ADDR=$(echo "$ENS_DATA" | grep -oE '"id":"0x[a-fA-F0-9]{40}"' | head -1 | grep -oE '0x[a-fA-F0-9]{40}' | tr '[:upper:]' '[:lower:]')
  
  if [ "$FORWARD_ADDR" = "$ADDRESS" ]; then
    echo "✅ Forward resolution: $REVERSE_NAME → $FORWARD_ADDR" >&2
    echo "" >&2
    echo "🎉 PRIMARY NAME VERIFIED: $REVERSE_NAME" >&2
    echo "{\"verified\":true,\"name\":\"$REVERSE_NAME\",\"address\":\"$ADDRESS\",\"chain\":\"$CHAIN\"}"
  else
    echo "⚠️  Forward resolution: $REVERSE_NAME → ${FORWARD_ADDR:-(none)}" >&2
    echo "" >&2
    echo "⚠️  Primary name PARTIALLY set" >&2
    echo "{\"verified\":\"partial\",\"name\":\"$REVERSE_NAME\",\"address\":\"$ADDRESS\",\"chain\":\"$CHAIN\"}"
  fi
else
  echo "" >&2
  echo "❌ PRIMARY NAME NOT SET" >&2
  echo "   No reverse record found for $ADDRESS on $CHAIN" >&2
  echo "{\"verified\":false,\"address\":\"$ADDRESS\",\"chain\":\"$CHAIN\"}"
fi