#!/bin/bash
set -eu
# Verify helper presence and permissions
test -f .husky/_/h && echo "found .husky/_/h" || (echo "missing .husky/_/h" && exit 1)
# Show first lines for sanity (should include set -e or similar)
head -n 5 .husky/_/h || true

#!/bin/bash
set -eu
f=tokens/token-list.json

# 1) Duplicate ids
echo "Duplicate ids:"
jq -r '.tokens[].id' "$f" | sort | uniq -d || true

# 2) Duplicate (network,address) combos
echo "Duplicate (network,address) pairs:"
jq -r '.tokens[] | "\(.network)|\(.address|ascii_downcase)"' "$f" | sort | uniq -d || true

# 3) Check that every token has required fields and correct types
echo "Schema spot-check (count missing):"
jq '[.tokens[] | select((.id|type!="string") or (.name|type!="string") or (.symbol|type!="string") or (.decimals|type!="number") or (.address|type!="string") or (.network|type!="string") or (.type|type!="string") or (.hash|type!="string") or (.chainId|type!="number"))] | length' "$f"

# 4) Show any symbol/id collisions (same id with different address)
echo "Same id with multiple addresses:"
jq -r '.tokens[] | [.id, (.address|ascii_downcase)] | @tsv' "$f" | sort | uniq -f1 -d || true

#!/bin/bash
set -euo pipefail
f=tokens/token-list.json

echo "File exists:" [ -f "$f" ] && echo "$f"
echo

echo "Total tokens:"
jq '.tokens | length' "$f"
echo

echo "Duplicate ids (counts >1):"
jq -r '.tokens[].id' "$f" | sort | uniq -c | awk '$1>1{print $2" ("$1" occurrences)"}' || true
echo

echo "Full entries for id == 'mUSD-mainnet':"
jq -c 'to_entries[] | select(.value.id=="mUSD-mainnet") | {index:.key, token:.value}' "$f" || true
echo

echo "Duplicate (network,address) pairs (case-insensitive):"
jq -r '.tokens[] | "\(.network)|\(.address|ascii_downcase)"' "$f" | sort | uniq -c | awk '$1>1{print $2" ("$1" entries)"}' || true
echo

echo "Show any ids that map to multiple distinct addresses:"
jq -r '.tokens[] | [.id, (.address|ascii_downcase)] | @tsv' "$f" | \
  python3 - <<'PY'
import sys
from collections import defaultdict
d=defaultdict(set)
for line in sys.stdin:
    line=line.rstrip("\n")
    if not line: continue
    id_, addr = line.split("\t")
    d[id_].add(addr)
for id_, addrs in d.items():
    if len(addrs)>1:
        print(id_, list(addrs))
PY
echo

echo "Schema/type spot-check using Python (lists tokens with missing/invalid fields):"
python3 - <<'PY'
import json,sys
f='tokens/token-list.json'
with open(f) as fh:
    data=json.load(f)
tokens=data.get('tokens',[])
req_str_fields=['id','name','symbol','address','network','type','hash']
req_num_fields=['decimals','chainId']
issues=[]
for idx,t in enumerate(tokens):
    cur=[]
    for k in req_str_fields:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k], str):
            cur.append(f"{k}:not-str")
    for k in req_num_fields:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k], (int,float)):
            cur.append(f"{k}:not-number")
    if cur:
        issues.append((idx, t.get('id'), cur))
print("Total tokens:", len(tokens))
print("Tokens with schema/type issues:", len(issues))
for i, id_, cur in issues[:200]:
    print(i, id_, ";".join(cur))
PY

#!/bin/bash
set -euo pipefail
f=tokens/token-list.json
echo "File:" "$f"
python3 - <<'PY'
import json
from collections import defaultdict
f='tokens/token-list.json'
with open(f) as fh:
    data=json.load(f)
tokens=data.get('tokens',[])
print("Total tokens:", len(tokens))

# duplicate ids
id_map=defaultdict(list)
for i,t in enumerate(tokens):
    id_map.get(t.get('id'))  # ensure key exists even if None
    id_map[t.get('id')].append((i,t))
dups=[(id_, len(v)) for id_,v in id_map.items() if id_ is not None and len(v)>1]
if dups:
    print("\nDuplicate ids:")
    for id_,cnt in sorted(dups, key=lambda x: x[0] or ""):
        print(f"{id_} ({cnt} occurrences)")
else:
    print("\nDuplicate ids: none")

# details for mUSD-mainnet
print()
if 'mUSD-mainnet' in id_map:
    print("Entries for id 'mUSD-mainnet':")
    for idx,t in id_map['mUSD-mainnet']:
        addr = t.get('address')
        network = t.get('network')
        name = t.get('name')
        symbol = t.get('symbol')
        chainId = t.get('chainId')
        print(f" index={idx} network={network} address={addr} name={name} symbol={symbol} chainId={chainId}")
else:
    print("No entries for id 'mUSD-mainnet'")

# ids with multiple distinct addresses
multi_addr=[]
for id_, lst in id_map.items():
    addrs=set()
    for idx,t in lst:
        a=(t.get('address') or '').lower()
        addrs.add(a)
    if len(addrs)>1:
        multi_addr.append((id_, list(addrs)))
print()
if multi_addr:
    print("Ids mapping to multiple distinct addresses:")
    for id_, addrs in multi_addr:
        print(id_, addrs)
else:
    print("No ids mapping to multiple distinct addresses")

# duplicate (network,address) pairs
pair_map=defaultdict(list)
for i,t in enumerate(tokens):
    net=t.get('network')
    addr=(t.get('address') or '').lower()
    pair_map[(net,addr)].append((i,t))
dups_pairs=[(k,len(v)) for k,v in pair_map.items() if k[0] and k[1] and len(v)>1]
print()
if dups_pairs:
    print("Duplicate (network,address) pairs:")
    for (net,addr),cnt in dups_pairs:
        print(f"{net}|{addr} ({cnt} entries)")
else:
    print("Duplicate (network,address) pairs: none")

# schema/type checks
req_str=['id','name','symbol','address','network','type','hash']
req_num=['decimals','chainId']
issues=[]
for i,t in enumerate(tokens):
    cur=[]
    for k in req_str:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k],str):
            cur.append(f"{k}:not-str")
    for k in req_num:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k], (int,float)):
            cur.append(f"{k}:not-number")
    if cur:
        issues.append((i,t.get('id'),cur))
print()
print("Tokens with schema/type issues:", len(issues))
for idx,id_,cur in issues[:100]:
    print(idx, id_, ";".join(cur))
PY

#!/bin/bash
set -euo pipefail
f=tokens/token-list.json
echo "Checking file:" "$f"
echo

python3 - <<'PY'
import json
from collections import defaultdict, Counter
f='tokens/token-list.json'
with open(f) as fh:
    data=json.load(f)

tokens = data.get('tokens') if isinstance(data, dict) else None
if tokens is None:
    print("ERROR: top-level 'tokens' array not found or JSON root is not an object")
    raise SystemExit(1)

print("Total tokens:", len(tokens))

# Build maps
id_map = defaultdict(list)
pair_map = defaultdict(list)
for idx, t in enumerate(tokens):
    if not isinstance(t, dict):
        id_map[None].append((idx, t))
        continue
    id_map[t.get('id')].append((idx, t))
    net = t.get('network')
    addr = (t.get('address') or '').lower()
    pair_map[(net, addr)].append((idx, t))

# Duplicate ids
dups = [(id_, len(v)) for id_, v in id_map.items() if id_ is not None and len(v) > 1]
print("\nDuplicate ids (id, count):")
if dups:
    for id_,cnt in sorted(dups):
        print(id_, cnt)
else:
    print("none")

# Show full entries for 'mUSD-mainnet' if present
if 'mUSD-mainnet' in id_map:
    print("\nEntries for id 'mUSD-mainnet':")
    for idx, t in id_map['mUSD-mainnet']:
        addr = t.get('address')
        net = t.get('network')
        name = t.get('name')
        symbol = t.get('symbol')
        chainId = t.get('chainId')
        print(f" index={idx} network={net} address={addr} name={name} symbol={symbol} chainId={chainId}")
        # print raw JSON snippet (compact)
        import json as _j
        print("  raw:", _j.dumps(t, separators=(',',':')))
else:
    print("\nNo entries with id 'mUSD-mainnet' found")

# Duplicate (network,address) pairs
dup_pairs = [ (k,len(v)) for k,v in pair_map.items() if k[0] and k[1] and len(v)>1 ]
print("\nDuplicate (network|address) pairs:")
if dup_pairs:
    for (net,addr),cnt in dup_pairs:
        print(f"{net}|{addr} ({cnt} entries)")
else:
    print("none")

# IDs mapping to multiple distinct addresses
multi_addr=[]
for id_, entries in id_map.items():
    if id_ is None: continue
    addrs = set()
    for _,t in entries:
        if isinstance(t, dict):
            addrs.add((t.get('address') or '').lower())
    addrs = {a for a in addrs if a}
    if len(addrs) > 1:
        multi_addr.append((id_, list(addrs)))
print("\nIDs mapping to multiple distinct addresses:")
if multi_addr:
    for id_, addrs in multi_addr:
        print(id_, addrs)
else:
    print("none")

# Schema/type spot-check
req_str=['id','name','symbol','address','network','type','hash']
req_num=['decimals','chainId']
issues=[]
for i,t in enumerate(tokens):
    cur=[]
    if not isinstance(t, dict):
        cur.append('not-object')
        issues.append((i, None, cur)); continue
    for k in req_str:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k], str):
            cur.append(f"{k}:not-str")
    for k in req_num:
        if k not in t:
            cur.append(f"missing:{k}")
        elif not isinstance(t[k], (int,float)):
            cur.append(f"{k}:not-number")
    if cur:
        issues.append((i, t.get('id'), cur))

print("\nTokens with schema/type issues count:", len(issues))
for idx, id_, cur in issues[:200]:
    print(idx, id_, ";".join(cur))
PY