Earn

import os
import json
import time
import uuid
import hashlib
import hmac
import base64
import urllib.parse
import requests

API_KEY = os.environ["PWS_API_KEY"]
API_SECRET = os.environ["PWS_API_SECRET"]
BASE_URL = "https://api.services.payward.com"


def get_payward_signature(urlpath, data, secret, nonce, params=None):
    encoded = (
        str(nonce).encode("utf-8")
        if data is None
        else (str(nonce) + json.dumps(data)).encode("utf-8")
    )

    sign_path = urlpath
    if params:
        sign_path += "?" + urllib.parse.urlencode(params)

    message = sign_path.encode() + hashlib.sha256(encoded).digest()
    mac = hmac.new(base64.b64decode(secret), message, hashlib.sha512)
    return base64.b64encode(mac.digest()).decode()


def pws_headers(signature, nonce, idempotent=False):
    headers = {
        "API-Key": API_KEY,
        "API-Sign": signature,
        "API-Nonce": str(nonce),
        "Content-Type": "application/json",
    }
    if idempotent:
        headers["Idempotency-Key"] = str(uuid.uuid4())
    return headers

def list_auto_earn_assets_by_country(country, page_size=20, page_token=None):
    endpoint = "/v1/earn/auto/assets"
    nonce = time.time_ns()
    params = {"country": country, "page_size": str(page_size)}
    if page_token:
        params["page_token"] = page_token

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce, params=params)
    response = requests.get(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce),
        params=params,
    )
    return response.json()


catalog = list_auto_earn_assets_by_country("US")
for asset in catalog["data"]:
    print(f"{asset['symbol']} ({asset['name']}): {asset['apy']}% APY, cap {asset['user_cap']} {asset['symbol']}")

def list_account_auto_earn_assets(account_id, page_size=20, page_token=None):
    endpoint = f"/v1/accounts/{account_id}/earn/auto/assets"
    nonce = time.time_ns()
    params = {"page_size": str(page_size)}
    if page_token:
        params["page_token"] = page_token

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce, params=params)
    response = requests.get(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce),
        params=params,
    )
    return response.json()


account_id = "PW43ACME0000000000000001"
account_assets = list_account_auto_earn_assets(account_id)
for asset in account_assets["data"]:
    print(f"{asset['symbol']}: {asset['apy']}% APY (cap {asset['user_cap']} {asset['symbol']})")

def set_auto_earn_preferences(account_id, preferences):
    endpoint = f"/v1/accounts/{account_id}/earn/auto"
    nonce = time.time_ns()

    signature = get_payward_signature(endpoint, preferences, API_SECRET, nonce)
    response = requests.put(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce, idempotent=True),
        json=preferences,
    )
    return response.status_code, response.json()


status, body = set_auto_earn_preferences(account_id, {"staking": "enabled"})
print(f"Toggle accepted: HTTP {status}")

def get_auto_earn_preferences(account_id):
    endpoint = f"/v1/accounts/{account_id}/earn/auto"
    nonce = time.time_ns()

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce)
    response = requests.get(BASE_URL + endpoint, headers=pws_headers(signature, nonce))
    return response.json()


def wait_for_settled(account_id, source, max_attempts=60):
    pending = {"pending_enabled", "pending_disabled"}
    for _ in range(max_attempts):
        prefs = get_auto_earn_preferences(account_id)
        state = prefs.get(source)
        print(f"{source}: {state}")
        if state is None or state not in pending:
            return prefs
        time.sleep(2)
    raise RuntimeError(f"{source} did not settle in time")


prefs = wait_for_settled(account_id, "staking")

def list_auto_earn_allocations(account_id, quote_symbol="USD", page_token=None, page_size=20):
    endpoint = f"/v1/accounts/{account_id}/earn/auto/allocations"
    nonce = time.time_ns()
    params = {
        "quote_symbol": quote_symbol,
        "quote_type": "fiat",
        "page_size": str(page_size),
    }
    if page_token:
        params["page_token"] = page_token

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce, params=params)
    response = requests.get(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce),
        params=params,
    )
    return response.json()


allocations = list_auto_earn_allocations(account_id, quote_symbol="EUR")
quote = allocations["quote_symbol"]
print(f"Total allocated: {allocations['total_allocated_in_quote']} {quote}")
for entry in allocations["data"]:
    print(
        f"  {entry['allocated']} {entry['symbol']} "
        f"(~{entry['allocated_in_quote']} {quote})"
    )

def list_auto_earn_rewards(account_id, quote_symbol="USD", page_token=None, page_size=20):
    endpoint = f"/v1/accounts/{account_id}/earn/auto/rewards"
    nonce = time.time_ns()
    params = {
        "quote_symbol": quote_symbol,
        "quote_type": "fiat",
        "page_size": str(page_size),
    }
    if page_token:
        params["page_token"] = page_token

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce, params=params)
    response = requests.get(
        BASE_URL + endpoint,
        headers=pws_headers(signature, nonce),
        params=params,
    )
    return response.json()


rewards = list_auto_earn_rewards(account_id, quote_symbol="EUR")
quote = rewards["quote_symbol"]
print(f"Total rewarded: {rewards['total_rewarded_in_quote']} {quote}")
if rewards.get("next_reward_date"):
    print(f"Next payout: {rewards['next_reward_date']}")

for entry in rewards["data"]:
    line = f"  {entry['symbol']}: rewarded {entry['rewarded']} {entry['symbol']}"
    if "estimated_next_reward" in entry:
        line += f", next ~{entry['estimated_next_reward']} {entry['symbol']}"
    print(line)
    for side in entry.get("other_assets", []):
        print(
            f"    + {side['rewarded']} {side['symbol']} "
            f"(~{side['rewarded_in_quote']} {quote})"
        )