Auto 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()


last_nonce = 0


# Returns nanoseconds since the Unix epoch. time.time_ns() can repeat a value
# or step back with the system clock, so if it hasn't advanced since the last
# call, next_nonce() returns the last nonce plus 1.
def next_nonce():
    global last_nonce
    last_nonce = max(time.time_ns(), last_nonce + 1)
    return last_nonce


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

import crypto from 'crypto';

const API_KEY = process.env.PWS_API_KEY;
const API_SECRET = process.env.PWS_API_SECRET;
const BASE_URL = 'https://api.services.payward.com';

function getPaywardSignature(urlpath, data, secret, nonce, params = null) {
  const encoded = data === null ? String(nonce) : String(nonce) + JSON.stringify(data);

  let signPath = urlpath;
  if (params) {
    signPath += '?' + new URLSearchParams(params).toString();
  }

  const sha256Hash = crypto.createHash('sha256').update(encoded).digest();
  const message = Buffer.concat([Buffer.from(signPath), sha256Hash]);

  const secretBuffer = Buffer.from(secret, 'base64');
  const hmac = crypto.createHmac('sha512', secretBuffer);
  hmac.update(message);
  return hmac.digest('base64');
}

let lastNonce = 0n;

// Returns nanoseconds since the Unix epoch. Date.now() has only millisecond
// resolution, so if the clock hasn't advanced since the last call, or has
// stepped back, nextNonce() returns the last nonce plus 1.
function nextNonce() {
  const now = BigInt(Date.now()) * 1_000_000n;
  lastNonce = now > lastNonce ? now : lastNonce + 1n;
  return lastNonce.toString();
}

function pwsHeaders(signature, nonce, { idempotent = false } = {}) {
  const headers = {
    'API-Key': API_KEY,
    'API-Sign': signature,
    'API-Nonce': String(nonce),
    'Content-Type': 'application/json',
  };
  if (idempotent) {
    headers['Idempotency-Key'] = crypto.randomUUID();
  }
  return headers;
}

def list_auto_earn_assets_by_country(country, page_size=20, page_token=None):
    endpoint = "/v1/earn/auto/assets"
    nonce = next_nonce()
    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']}")

async function listAutoEarnAssetsByCountry(country, pageSize = 20, pageToken = null) {
  const endpoint = '/v1/earn/auto/assets';
  const nonce = nextNonce();
  const params = new URLSearchParams({ country, page_size: String(pageSize) });
  if (pageToken) params.set('page_token', pageToken);

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce, params);
  const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

const catalog = await listAutoEarnAssetsByCountry('US');
for (const asset of catalog.data) {
  console.log(`${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 = next_nonce()
    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 = "WFFGB6Z8AK5WF9JL"
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']})")

async function listAccountAutoEarnAssets(accountId, pageSize = 20, pageToken = null) {
  const endpoint = `/v1/accounts/${accountId}/earn/auto/assets`;
  const nonce = nextNonce();
  const params = new URLSearchParams({ page_size: String(pageSize) });
  if (pageToken) params.set('page_token', pageToken);

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce, params);
  const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

const accountId = 'WFFGB6Z8AK5WF9JL';
const accountAssets = await listAccountAutoEarnAssets(accountId);
for (const asset of accountAssets.data) {
  console.log(`${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 = next_nonce()

    signature = get_payward_signature(endpoint, preferences, API_SECRET, nonce)
    response = requests.patch(
        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}")

async function setAutoEarnPreferences(accountId, preferences) {
  const endpoint = `/v1/accounts/${accountId}/earn/auto`;
  const nonce = nextNonce();

  const signature = getPaywardSignature(endpoint, preferences, API_SECRET, nonce);
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: 'PATCH',
    headers: pwsHeaders(signature, nonce, { idempotent: true }),
    body: JSON.stringify(preferences),
  });

  return { status: response.status, body: await response.json() };
}

const { status } = await setAutoEarnPreferences(accountId, { staking: 'enabled' });
console.log(`Toggle accepted: HTTP ${status}`);

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

    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["data"].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")

async function getAutoEarnPreferences(accountId) {
  const endpoint = `/v1/accounts/${accountId}/earn/auto`;
  const nonce = nextNonce();

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce);
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

async function waitForSettled(accountId, source, maxAttempts = 60) {
  const pending = new Set(['pending_enabled', 'pending_disabled']);
  for (let i = 0; i < maxAttempts; i++) {
    const prefs = await getAutoEarnPreferences(accountId);
    const state = prefs.data[source];
    console.log(`${source}: ${state}`);
    if (state === undefined || !pending.has(state)) return prefs;
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
  throw new Error(`${source} did not settle in time`);
}

const prefs = await waitForSettled(accountId, '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 = next_nonce()
    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})"
    )

async function listAutoEarnAllocations(accountId, quoteSymbol = 'USD', pageToken = null, pageSize = 20) {
  const endpoint = `/v1/accounts/${accountId}/earn/auto/allocations`;
  const nonce = nextNonce();
  const params = new URLSearchParams({
    quote_symbol: quoteSymbol,
    quote_type: 'fiat',
    page_size: String(pageSize),
  });
  if (pageToken) params.set('page_token', pageToken);

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce, params);
  const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

const allocations = await listAutoEarnAllocations(accountId, 'EUR');
const quote = allocations.quote_symbol;
console.log(`Total allocated: ${allocations.total_allocated_in_quote} ${quote}`);
for (const entry of allocations.data) {
  console.log(`  ${entry.allocated} ${entry.symbol} (~${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 = next_nonce()
    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")
for entry in rewards["data"]:
    print(
        f"  {entry['symbol']}: rewarded {entry['rewarded']} {entry['symbol']}"
        f" ({entry['rewarded_in_quote']} {rewards['quote_symbol']})"
    )

async function listAutoEarnRewards(accountId, quoteSymbol = 'USD', pageToken = null, pageSize = 20) {
  const endpoint = `/v1/accounts/${accountId}/earn/auto/rewards`;
  const nonce = nextNonce();
  const params = new URLSearchParams({
    quote_symbol: quoteSymbol,
    quote_type: 'fiat',
    page_size: String(pageSize),
  });
  if (pageToken) params.set('page_token', pageToken);

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce, params);
  const response = await fetch(`${BASE_URL}${endpoint}?${params}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });

  return response.json();
}

const rewards = await listAutoEarnRewards(accountId, 'EUR');
for (const entry of rewards.data) {
  console.log(
    `  ${entry.symbol}: rewarded ${entry.rewarded} ${entry.symbol} (${entry.rewarded_in_quote} ${rewards.quote_symbol})`,
  );
}