Bonded 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_bonded_strategies_by_country(country, page_size=20, page_token=None):
    endpoint = "/v1/earn/bonded/strategies"
    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()


country_page_token = None
while True:
    catalog = list_bonded_strategies_by_country("US", page_token=country_page_token)
    for strategy in catalog["data"]:
        print(f"{strategy['id']}: {strategy['symbol']} {strategy['strategy_type']}, {strategy['apy']}% APY")
    country_page_token = catalog.get("next_page_token")
    if not country_page_token:
        break

async function listBondedStrategiesByCountry(country, pageSize = 20, pageToken = null) {
  const endpoint = '/v1/earn/bonded/strategies';
  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();
}

let countryPageToken = null;
do {
  const catalog = await listBondedStrategiesByCountry('US', 20, countryPageToken);
  for (const strategy of catalog.data) {
    console.log(`${strategy.id}: ${strategy.symbol} ${strategy.strategy_type}, ${strategy.apy}% APY`);
  }
  countryPageToken = catalog.next_page_token;
} while (countryPageToken);

import uuid


def allocate_bonded(account_id, strategy_id, amount, idempotency_key):
    endpoint = f"/v1/accounts/{account_id}/earn/bonded/strategies/{strategy_id}/allocate"
    body = {"amount": amount}
    nonce = next_nonce()

    signature = get_payward_signature(endpoint, body, API_SECRET, nonce)
    headers = pws_headers(signature, nonce)
    headers["Idempotency-Key"] = idempotency_key
    response = requests.post(BASE_URL + endpoint, headers=headers, json=body)
    return response.status_code, response.json()


# Keep this key until the request settles; reuse it on every retry.
key = str(uuid.uuid4())
status, body = allocate_bonded(account_id, "ESDQCOL-WTZEU-NU55QF", "2.0", key)
if status != 202:
    raise RuntimeError(f"Allocate rejected: {status} {body['error']['code']}")
request_id = body["data"]["request_id"]

async function allocateBonded(accountId, strategyId, amount, idempotencyKey) {
  const endpoint = `/v1/accounts/${accountId}/earn/bonded/strategies/${strategyId}/allocate`;
  const body = { amount };
  const nonce = nextNonce();

  const signature = getPaywardSignature(endpoint, body, API_SECRET, nonce);
  const headers = { ...pwsHeaders(signature, nonce), 'Idempotency-Key': idempotencyKey };
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
  });

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

// Keep this key until the request settles; reuse it on every retry.
const key = crypto.randomUUID();
const { status, body } = await allocateBonded(accountId, 'ESDQCOL-WTZEU-NU55QF', '2.0', key);
if (status !== 202) throw new Error(`Allocate rejected: ${status} ${body.error.code}`);
const requestId = body.data.request_id;

import time


def get_bonded_request(account_id, request_id):
    endpoint = f"/v1/accounts/{account_id}/earn/bonded/requests/{request_id}"
    nonce = next_nonce()

    signature = get_payward_signature(endpoint, None, API_SECRET, nonce)
    response = requests.get(BASE_URL + endpoint, headers=pws_headers(signature, nonce))
    body = response.json()
    if response.status_code != 200:
        raise RuntimeError(f"Get request failed: {response.status_code} {body['error']['code']}")
    return body["data"]


def wait_for_bonded_request(account_id, request_id, interval=3, timeout=300):
    deadline = time.monotonic() + timeout
    while True:
        request = get_bonded_request(account_id, request_id)
        if request["status"] != "pending" or time.monotonic() > deadline:
            return request
        time.sleep(interval)


request = wait_for_bonded_request(account_id, request_id)
if request["status"] == "failed":
    print(f"Failed: {request['error']['reason']}")

async function getBondedRequest(accountId, requestId) {
  const endpoint = `/v1/accounts/${accountId}/earn/bonded/requests/${requestId}`;
  const nonce = nextNonce();

  const signature = getPaywardSignature(endpoint, null, API_SECRET, nonce);
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: 'GET',
    headers: pwsHeaders(signature, nonce),
  });
  const body = await response.json();
  if (!response.ok) throw new Error(`Get request failed: ${response.status} ${body.error.code}`);
  return body.data;
}

async function waitForBondedRequest(accountId, requestId, intervalMs = 3000, timeoutMs = 300000) {
  const deadline = Date.now() + timeoutMs;
  for (;;) {
    const request = await getBondedRequest(accountId, requestId);
    if (request.status !== 'pending' || Date.now() > deadline) return request;
    await new Promise(resolve => setTimeout(resolve, intervalMs));
  }
}

const request = await waitForBondedRequest(accountId, requestId);
if (request.status === 'failed') console.log(`Failed: ${request.error.reason}`);

import uuid


def deallocate_bonded(account_id, strategy_id, amount, idempotency_key):
    endpoint = f"/v1/accounts/{account_id}/earn/bonded/strategies/{strategy_id}/deallocate"
    body = {"amount": amount}
    nonce = next_nonce()

    signature = get_payward_signature(endpoint, body, API_SECRET, nonce)
    headers = pws_headers(signature, nonce)
    headers["Idempotency-Key"] = idempotency_key
    response = requests.post(BASE_URL + endpoint, headers=headers, json=body)
    return response.status_code, response.json()


# Keep this key until the request settles; reuse it on every retry.
key = str(uuid.uuid4())
status, body = deallocate_bonded(account_id, "ESDQCOL-WTZEU-NU55QF", "2.0", key)
if status != 202:
    raise RuntimeError(f"Deallocate rejected: {status} {body['error']['code']}")
request_id = body["data"]["request_id"]

async function deallocateBonded(accountId, strategyId, amount, idempotencyKey) {
  const endpoint = `/v1/accounts/${accountId}/earn/bonded/strategies/${strategyId}/deallocate`;
  const body = { amount };
  const nonce = nextNonce();

  const signature = getPaywardSignature(endpoint, body, API_SECRET, nonce);
  const headers = { ...pwsHeaders(signature, nonce), 'Idempotency-Key': idempotencyKey };
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
  });

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

// Keep this key until the request settles; reuse it on every retry.
const deallocationKey = crypto.randomUUID();
const { status: deallocationStatus, body: deallocationBody } = await deallocateBonded(
  accountId,
  'ESDQCOL-WTZEU-NU55QF',
  '2.0',
  deallocationKey,
);
if (deallocationStatus !== 202) {
  throw new Error(`Deallocate rejected: ${deallocationStatus} ${deallocationBody.error.code}`);
}
const deallocationRequestId = deallocationBody.data.request_id;