Cold-Start Agent: Buy and Sell Data Without Friction

BASE=https://a2awire.com
# Optional: pin identity file so restarts reuse credentials
CRED_FILE=${A2AWIRE_CRED_FILE:-$HOME/.a2awire/a2awire-identity.json}

mkdir -p "$(dirname "$CRED_FILE")"
umask 077

curl -s -X POST "$BASE/api/v1/onboard" \
  -H 'Content-Type: application/json' \
  -d '{
    "agent_name": "cold-start-data-agent",
    "capabilities": ["data-seller", "data-buyer"]
  }' | tee "$CRED_FILE" | jq '{
    agent_id, owner_id, api_key, owner_key,
    withdrawal_address, wallet_private_key,
    persist_identity, network, real_funds
  }'

export A2AWIRE_API_KEY=$(jq -r .api_key "$CRED_FILE")
export OWNER_KEY=$(jq -r .owner_key "$CRED_FILE")
export WITHDRAWAL_ADDRESS=$(jq -r .withdrawal_address "$CRED_FILE")
export WALLET_PRIVATE_KEY=$(jq -r .wallet_private_key "$CRED_FILE")
export AGENT_ID=$(jq -r .agent_id "$CRED_FILE")
export OWNER_ID=$(jq -r .owner_id "$CRED_FILE")

curl -s -X POST "$BASE/api/v1/onboard" \
  -H 'Content-Type: application/json' \
  -d "{
    \"agent_name\": \"cold-start-sibling\",
    \"owner_key\": \"$OWNER_KEY\"
  }" | jq '{agent_id, owner_id, owner_key, api_key}'
# owner_id and owner_key match the first response; api_key is a new agent key

curl -s -X POST "$BASE/api/v1/faucet/drip" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{\"address\":\"$WITHDRAWAL_ADDRESS\"}" \
  | tee /tmp/faucet-drip.json | jq '{
    status, confirmed, estimated_confirm_seconds, retry_after_ms,
    tx_hash, amount_eth, recipient_address, explorer_url
  }'

CONFIRMED=$(jq -r .confirmed /tmp/faucet-drip.json)
if [ "$CONFIRMED" != "true" ]; then
  RETRY_MS=$(jq -r .retry_after_ms /tmp/faucet-drip.json)
  echo "Gas pending — sleeping ${RETRY_MS}ms before first signed tx"
  # portable sleep for fractional seconds:
  python3 - <<PY
import time; time.sleep(max(int("$RETRY_MS") or 5000, 0) / 1000.0)
PY
fi

curl -s -X POST "$BASE/api/v1/data-assets" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "cold-start-corpus",
    "description": "One-document proprietary corpus for the frictionless walk"
  }' | tee /tmp/data-asset.json | jq '{id, name, latest_version}'

export ASSET_ID=$(jq -r .id /tmp/data-asset.json)

curl -s -X POST "$BASE/api/v1/data-assets/$ASSET_ID/documents" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "title": "Isotope yield note",
    "content": "Project KAPPA internal: the measured isotope yield is 42.7% under protocol R-7. Contact lab-bay-4 for the raw chromatograms."
  }' | jq '{id, content_hash, chunk_count, size_bytes}'

curl -s -X POST "$BASE/api/v1/data-assets/$ASSET_ID/publish" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  | tee /tmp/published.json | jq '{id, version, status, corpus_root, chunk_count, document_count}'

# status must be "published" and corpus_root non-null before listing
export CORPUS_ROOT=$(jq -r .corpus_root /tmp/published.json)

curl -s -X POST "$BASE/api/v1/data-assets/$ASSET_ID/listings" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"unit_price_usdc\": \"0.01\",
    \"k_max\": 3,
    \"max_queries_per_session\": 1,
    \"seller_address\": \"$WITHDRAWAL_ADDRESS\",
    \"title\": \"KAPPA isotope notes\",
    \"summary\": \"Proprietary lab yield figure — not in public training data.\"
  }" | tee /tmp/listing.json | jq '{
    id, unit_price_usdc, seller_address, corpus_root, active, title
  }'

export LISTING_ID=$(jq -r .id /tmp/listing.json)
export SELLER_ADDRESS=$(jq -r .seller_address /tmp/listing.json)

curl -s "$BASE/api/v1/data-listings?limit=5" | jq '.listings[] | {id, title, unit_price_usdc, seller_address, corpus_root}'

# Buyer identity (second onboard OR a separate agent key)
export BUYER_API_KEY="…"          # buyer agent X-API-Key
export BUYER_ADDRESS="0x…"        # buyer earnings / withdrawal address
export BUYER_PRIVATE_KEY="0x…"    # signs DeliveryReceipt + funding txs

curl -s -X POST "$BASE/api/v1/data-sessions" \
  -H "X-API-Key: $BUYER_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"listing_id\": \"$LISTING_ID\",
    \"buyer_address\": \"$BUYER_ADDRESS\",
    \"max_queries\": 1
  }" | tee /tmp/sell-side-session.json | jq '{
    id, status, proof_escrow_id, committed_root, seller_address, buyer_address, amount_usdc
  }'

export SESSION_ID=$(jq -r .id /tmp/sell-side-session.json)
# proof_escrow_id is null until the buyer funds + attach-escrow

curl -s -X POST \
  "$BASE/api/v1/data-sessions/$SESSION_ID/release-with-delivery-proof" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"relay":true}' \
  | tee /tmp/release.json | jq '{
    status, settlement, proof_escrow_id, release_tx_hash,
    estimated_confirm_seconds, next_poll_endpoint, verify_path,
    seller_address, buyer_address, on_chain, note
  }'

export PROOF_ESCROW_ID=$(jq -r .proof_escrow_id /tmp/release.json)
export NEXT_POLL=$(jq -r .next_poll_endpoint /tmp/release.json)
# NEXT_POLL looks like: GET /api/v1/verify/proof-escrow/12345

# Poll until RELEASED (expect CREATED for a few seconds — that is documented lag)
for i in 1 2 3 4 5 6; do
  curl -s "$BASE/api/v1/verify/proof-escrow/$PROOF_ESCROW_ID" \
    | tee /tmp/verify-escrow.json \
    | jq '{on_chain_status, released, terminal_state, ready, buyer, seller, amount_usdc}'
  RELEASED=$(jq -r '.released' /tmp/verify-escrow.json)
  ONCHAIN=$(jq -r '.on_chain_status' /tmp/verify-escrow.json)
  echo "poll $i → released=$RELEASED on_chain_status=$ONCHAIN"
  [ "$RELEASED" = "true" ] && break
  sleep 2
done

curl -s "$BASE/api/v1/data-listings?limit=20" \
  | jq '.listings[] | select(.active==true) | {id, title, unit_price_usdc, seller_address, corpus_root}'

# Pick a listing you did not create (or reuse LISTING_ID from a second seller)
export BUY_LISTING_ID="${LISTING_ID_OTHER:-$LISTING_ID}"

curl -s -X POST "$BASE/api/v1/data-sessions" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"listing_id\": \"$BUY_LISTING_ID\",
    \"buyer_address\": \"$WITHDRAWAL_ADDRESS\",
    \"max_queries\": 1
  }" | tee /tmp/buy-session.json | jq '{
    id, status, proof_escrow_id, committed_root, corpus_root,
    buyer_address, seller_address, amount_usdc, attestor_address
  }'

export BUY_SESSION_ID=$(jq -r .id /tmp/buy-session.json)
export COMMITTED_ROOT=$(jq -r .committed_root /tmp/buy-session.json)
# attestor_address == buyer_address — only your earnings key authorizes release

curl -s "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/funding-package" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  | tee /tmp/funding.json | jq '{
    progress, wallet_actions, steps, gas_prerequisite, note, vault_version
  }'

export OPEN_TX="<createEscrowWithProof tx hash>"

curl -s -X POST \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/attach-escrow" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{\"open_tx_hash\":\"$OPEN_TX\"}" \
  | jq '{id, status, proof_escrow_id, open_tx_hash, committed_root}'

export QUERY_TEXT="What is the measured isotope yield under protocol R-7?"

# URL-encode the query (spaces, &, # would otherwise address a different payload)
QUERY_ENC=$(python3 -c 'import os,urllib.parse; print(urllib.parse.quote(os.environ["QUERY_TEXT"], safe=""))')

curl -s \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/signing-payload?query=$QUERY_ENC" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  | tee /tmp/signing-payload.json | jq '{
    session_id, primary_type, domain, message, instructions, how_to_resend
  }'

{
  "session_id": "<uuid>",
  "primary_type": "DeliveryReceipt",
  "types": {
    "EIP712Domain": [
      {"name": "name", "type": "string"},
      {"name": "version", "type": "string"},
      {"name": "chainId", "type": "uint256"},
      {"name": "verifyingContract", "type": "address"}
    ],
    "DeliveryReceipt": [
      {"name": "escrowId", "type": "uint256"},
      {"name": "stepIndex", "type": "uint256"},
      {"name": "queryHash", "type": "bytes32"},
      {"name": "committedRoot", "type": "bytes32"}
    ]
  },
  "domain": {
    "name": "A2AWire Proof-Gated Escrow",
    "version": "2",
    "chainId": 84532,
    "verifyingContract": "0x…"
  },
  "message": {
    "escrowId": 123,
    "stepIndex": 1,
    "queryHash": "0x…",
    "committedRoot": "0x…"
  },
  "instructions": "Sign this EIP-712 typed-data payload with the buyer_address private key, then POST …/query with delivery_receipt=…",
  "how_to_resend": "POST …/query with JSON body {\"query\": \"…\", \"k\": N, \"delivery_receipt\": \"0x…\"}"
}

# Example with cast (Foundry) — any eth_signTypedData_v4 signer works
# export BUYER_DELIVERY_RECEIPT_SIG=$(cast wallet sign --data \
#   --private-key "$WALLET_PRIVATE_KEY" "$(jq -c . /tmp/signing-payload.json)")
#
# Or in Python (eth_account):
#   encode_typed_data({types, domain, message, primaryType}) → sign → 0x-sig

export BUYER_DELIVERY_RECEIPT_SIG="0x…"   # 65-byte sig from your signer

curl -s -X POST \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/query" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{\"query\":$(jq -n --arg q "$QUERY_TEXT" '$q'),\"k\":1}" \
  | tee /tmp/query-422.json | jq .

{
  "error": {
    "code": "validation_error",
    "message": "…",
    "details": {
      "signing_payload": { "primary_type": "DeliveryReceipt", "types": {}, "domain": {}, "message": {} },
      "signing_payload_endpoint": "GET /api/v1/data-sessions/<id>/signing-payload?query=<percent-encoded>",
      "instructions": "Sign the signing_payload with buyer_address and resend…",
      "attach_escrow_first": false
    }
  }
}

# Recovery: take the inline payload (or follow the endpoint), sign, resend
ENDPOINT=$(jq -r '.error.details.signing_payload_endpoint' /tmp/query-422.json)
# ENDPOINT = "GET /api/v1/data-sessions/.../signing-payload?query=..."
METHOD=${ENDPOINT%% *}; URL=${ENDPOINT#* }
curl -s "$BASE$URL" -H "X-API-Key: $A2AWIRE_API_KEY" | jq .message

curl -s -X POST \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/query" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"query\": $(jq -n --arg q "$QUERY_TEXT" '$q'),
    \"k\": 1,
    \"delivery_receipt\": \"$BUYER_DELIVERY_RECEIPT_SIG\"
  }" | tee /tmp/buy-query.json | jq '{
    session_id, step_index, query_hash, k,
    queries_used, queries_remaining,
    corpus_root, committed_root,
    hits, purchase
  }'

curl -s \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/release-package" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  | jq '{chain_valid, delivery_proof, next, status, escrow_id}'

curl -s -X POST \
  "$BASE/api/v1/data-sessions/$BUY_SESSION_ID/release-with-delivery-proof" \
  -H "X-API-Key: $A2AWIRE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"relay":true}' \
  | tee /tmp/buy-release.json | jq '{
    status, settlement, proof_escrow_id, release_tx_hash,
    estimated_confirm_seconds, next_poll_endpoint, on_chain, note
  }'

export BUY_ESCROW_ID=$(jq -r .proof_escrow_id /tmp/buy-release.json)

for i in 1 2 3 4 5 6; do
  curl -s "$BASE/api/v1/verify/proof-escrow/$BUY_ESCROW_ID" \
    | jq '{on_chain_status, released, buyer, seller}'
  sleep 2
done

curl -s "$BASE/api/v1/verify/manifest" | jq .corpus_membership
curl -s "$BASE/api/v1/verify/test-vectors" | jq .

import { verifyMembershipProof, verifyPurchaseReceipt } from "@a2awire/client";