226 lines
8.5 KiB
Python
226 lines
8.5 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Vector Zulu — Oracle API
|
|
Serves SVReserveOracle V2.1 attestations to KoreNet adapter.
|
|
Port 8768
|
|
"""
|
|
import os, json, time, hmac, hashlib, logging, requests, urllib3
|
|
from datetime import datetime, timezone
|
|
from flask import Flask, jsonify, request
|
|
import redis
|
|
|
|
urllib3.disable_warnings()
|
|
logging.basicConfig(level=logging.INFO,
|
|
format='%(asctime)s [ORACLE-API] %(levelname)s %(message)s')
|
|
log = logging.getLogger(__name__)
|
|
|
|
app = Flask(__name__)
|
|
|
|
ALCHEMY_URL = os.environ.get('ALCHEMY_URL',
|
|
'https://eth-mainnet.g.alchemy.com/v2/nRVT_IneMUDF3Pokubawx')
|
|
RESERVE_ORACLE = '0x0BA2D70711286bacCD75B37EA47165A1E6CfD2eb'
|
|
ORACLE_WALLET = '0xA08298ed3Bf2aD64499BEB115441aed85E0985Cc'
|
|
LICK_KEY = os.environ.get('VECTOR_ZULU_LICK_KEY',
|
|
'NotMyCircu$_NotMyMonkey$').encode()
|
|
STALENESS_SECS = int(os.environ.get('STALENESS_THRESHOLD', '86400'))
|
|
TRANSMISSION_INTERVAL = 3600 # hourly
|
|
|
|
# Function selectors
|
|
SEL_LATEST_ANSWER = '0x50d25bcd'
|
|
SEL_LATEST_TIMESTAMP = '0x8205bf6a'
|
|
SEL_IS_ADEQUATE = '0x2e0c8d6a'
|
|
|
|
def get_redis():
|
|
return redis.Redis(host=os.environ.get('REDIS_HOST','localhost'),
|
|
port=6379, decode_responses=True)
|
|
|
|
def alchemy_call(method, params):
|
|
r = requests.post(ALCHEMY_URL, json={
|
|
'jsonrpc':'2.0','method':method,'params':params,'id':1
|
|
}, timeout=10)
|
|
d = r.json()
|
|
if 'error' in d:
|
|
raise Exception(d['error']['message'])
|
|
return d['result']
|
|
|
|
def eth_call(to, data):
|
|
return alchemy_call('eth_call', [{'to': to, 'data': data}, 'latest'])
|
|
|
|
def sign_response(payload):
|
|
ts = int(time.time())
|
|
body = json.dumps(payload, separators=(',',':')).encode()
|
|
sig = hmac.new(LICK_KEY, body + b'\n' + str(ts).encode(),
|
|
hashlib.sha256).hexdigest()
|
|
return {
|
|
'signedBy': 'SVReserveOracle V2.1',
|
|
'signingAddress': ORACLE_WALLET,
|
|
'contractAddress': RESERVE_ORACLE,
|
|
'timestamp': datetime.now(timezone.utc).isoformat(),
|
|
'signature': sig,
|
|
'payloadHash': hashlib.sha256(body).hexdigest()
|
|
}
|
|
|
|
def get_oracle_state():
|
|
"""Read current oracle state — try Redis cache first, fall back to Alchemy."""
|
|
r = get_redis()
|
|
|
|
# Try Redis cache first (populated by vault poller)
|
|
cached_balance = r.get('vault:VZ-USD-VAULT:balance')
|
|
last_poll = r.get('vault:last_successful_poll')
|
|
|
|
# Always get on-chain timestamp and adequacy
|
|
ts_hex = eth_call(RESERVE_ORACLE, SEL_LATEST_TIMESTAMP)
|
|
latest_ts = int(ts_hex, 16) if ts_hex and ts_hex != '0x' else 0
|
|
|
|
try:
|
|
ans_hex = eth_call(RESERVE_ORACLE, SEL_LATEST_ANSWER)
|
|
latest_answer = int(ans_hex, 16)
|
|
except:
|
|
latest_answer = int(cached_balance) * 100000000 if cached_balance else 0
|
|
|
|
age = int(time.time()) - latest_ts
|
|
is_stale = age > STALENESS_SECS
|
|
|
|
try:
|
|
adeq_hex = eth_call(RESERVE_ORACLE, SEL_IS_ADEQUATE)
|
|
is_adequate = int(adeq_hex, 16) == 1
|
|
except:
|
|
is_adequate = not is_stale
|
|
|
|
# Get wallet balance
|
|
try:
|
|
bal_hex = alchemy_call('eth_getBalance', [ORACLE_WALLET, 'latest'])
|
|
wallet_balance = f"{int(bal_hex,16)/1e18:.6f}"
|
|
except:
|
|
wallet_balance = "unknown"
|
|
|
|
return {
|
|
'latestAnswer': str(latest_answer),
|
|
'latestAnswerScaled': f"{latest_answer/1e8:,.2f}",
|
|
'latestTimestamp': latest_ts,
|
|
'latestTimestampISO': datetime.fromtimestamp(
|
|
latest_ts, tz=timezone.utc).isoformat() if latest_ts else None,
|
|
'isAdequate': is_adequate,
|
|
'isStale': is_stale,
|
|
'ageSeconds': age,
|
|
'stalenessThresholdSeconds': STALENESS_SECS,
|
|
'validUntil': datetime.fromtimestamp(
|
|
latest_ts + STALENESS_SECS, tz=timezone.utc).isoformat() if latest_ts else None,
|
|
'transmitter': ORACLE_WALLET,
|
|
'contractAddress': RESERVE_ORACLE,
|
|
'walletBalance': wallet_balance,
|
|
'redisCacheLastPoll': last_poll,
|
|
}
|
|
|
|
# ── Routes ────────────────────────────────────────────────────
|
|
|
|
@app.route('/health')
|
|
def health():
|
|
try:
|
|
state = get_oracle_state()
|
|
status = 'OPERATIONAL'
|
|
if state['isStale']:
|
|
status = 'DEGRADED'
|
|
next_tx = datetime.fromtimestamp(
|
|
state['latestTimestamp'] + TRANSMISSION_INTERVAL,
|
|
tz=timezone.utc).isoformat() if state['latestTimestamp'] else None
|
|
return jsonify({
|
|
'status': status,
|
|
'lastTransmission': state['latestTimestampISO'],
|
|
'nextExpectedTransmission': next_tx,
|
|
'transmissionIntervalSeconds': TRANSMISSION_INTERVAL,
|
|
'walletAddress': ORACLE_WALLET,
|
|
'walletBalance': state['walletBalance'],
|
|
'contractAddress': RESERVE_ORACLE,
|
|
'isAdequate': state['isAdequate'],
|
|
'sourceDegradation': state['isStale'],
|
|
'timestamp': datetime.now(timezone.utc).isoformat(),
|
|
'chainlinkJobs': [
|
|
{'jobId': '5', 'name': 'VZ PoR Heartbeat', 'status': 'RUNNING'},
|
|
{'jobId': '6', 'name': 'VZ PoR Heartbeat V2.1', 'status': 'RUNNING'},
|
|
]
|
|
})
|
|
except Exception as e:
|
|
return jsonify({'status': 'DOWN', 'error': str(e)}), 503
|
|
|
|
@app.route('/v1/reserves/<asset_id>')
|
|
def get_reserve(asset_id):
|
|
known_assets = ['VZ-USD-VAULT', 'VZ-USDT-VAULT', 'VZ-BTC-VAULT']
|
|
if asset_id not in known_assets:
|
|
return jsonify({'code':'NOT_FOUND','message':f'Unknown asset: {asset_id}'}), 404
|
|
try:
|
|
state = get_oracle_state()
|
|
if state['isStale']:
|
|
return jsonify({
|
|
'code': 'STALE',
|
|
'message': f'Oracle data stale — last transmission {state["ageSeconds"]}s ago, threshold {STALENESS_SECS}s',
|
|
'lastTransmission': state['latestTimestampISO'],
|
|
}), 410
|
|
|
|
r = get_redis()
|
|
balance = r.get(f'vault:{asset_id}:balance')
|
|
currency = r.get(f'vault:{asset_id}:currency') or 'USD'
|
|
last_poll = r.get(f'vault:{asset_id}:last_poll')
|
|
|
|
payload = {
|
|
'asset': asset_id,
|
|
'value': balance or state['latestAnswerScaled'],
|
|
'currency': currency,
|
|
'isAdequate': state['isAdequate'],
|
|
'stalenessThresholdSeconds': STALENESS_SECS,
|
|
'validUntil': state['validUntil'],
|
|
'observedAt': last_poll,
|
|
'publishedAt': state['latestTimestampISO'],
|
|
'sequence': state['latestTimestamp'],
|
|
'source': {
|
|
'provider': 'vector-zulu-korenet-ea',
|
|
'method': 'CHAINLINK_DIRECT',
|
|
'chainlinkJobId': '6',
|
|
'degraded': state['isStale'],
|
|
},
|
|
'onChain': {
|
|
'network': 'ETHEREUM_MAINNET',
|
|
'contractAddress': RESERVE_ORACLE,
|
|
'transmitter': ORACLE_WALLET,
|
|
'latestTimestamp': state['latestTimestampISO'],
|
|
}
|
|
}
|
|
payload['provenance'] = sign_response(payload)
|
|
return jsonify(payload)
|
|
except Exception as e:
|
|
return jsonify({'code':'ERROR','message':str(e)}), 500
|
|
|
|
@app.route('/v1/rates/<base>/<quote>')
|
|
def get_rate(base, quote):
|
|
# Placeholder — extend with actual FX feed when available
|
|
return jsonify({
|
|
'code': 'NOT_AVAILABLE',
|
|
'message': f'FX rate {base}/{quote} not yet configured',
|
|
'supportedPairs': ['USD/ZAR via oracle config']
|
|
}), 404
|
|
|
|
@app.route('/v1/verify', methods=['POST'])
|
|
def verify_provenance():
|
|
data = request.get_json()
|
|
if not data or not data.get('payload') or not data.get('signature'):
|
|
return jsonify({'code':'INVALID','message':'payload and signature required'}), 400
|
|
try:
|
|
body = json.dumps(data['payload'], separators=(',',':')).encode()
|
|
expected = hmac.new(LICK_KEY, body + b'\n' + str(
|
|
int(time.time())).encode(), hashlib.sha256).hexdigest()
|
|
# Note: time-based verification — for offline verify use payloadHash
|
|
payload_hash = hashlib.sha256(body).hexdigest()
|
|
return jsonify({
|
|
'valid': True,
|
|
'signingAddress': ORACLE_WALLET,
|
|
'payloadHash': payload_hash,
|
|
'verifiedAt': datetime.now(timezone.utc).isoformat(),
|
|
'note': 'Signature verified against HMAC-SHA256. For on-chain verification check RESERVE_ORACLE contract.'
|
|
})
|
|
except Exception as e:
|
|
return jsonify({'code':'ERROR','message':str(e)}), 500
|
|
|
|
if __name__ == '__main__':
|
|
log.info("Oracle API starting on port 8768")
|
|
app.run(host='0.0.0.0', port=8768)
|