Set up local development

import base64
import hashlib
import hmac
import json
import os
import time
from urllib.parse import quote, urlparse

import requests

base_url = os.environ["PWS_BASE_URL"]
api_key = os.environ.get("PWS_API_KEY", "")
secret = os.environ.get("PWS_API_SECRET", "")
client_id = os.environ.get("PWS_CLIENT_ID", "").replace(" ", "")

if any(not value or "replace_with" in value.lower() for value in (api_key, secret, client_id)):
    raise SystemExit("Replace every configuration placeholder before running the example.")
if urlparse(base_url).hostname != "api.sandbox.services.payward.com":
    raise SystemExit("This example runs only against the sandbox.")

# Nonces must increase for each API key. Use nanoseconds since the Unix epoch, and never repeat a value.
last_nonce = 0


def next_nonce():
    global last_nonce
    last_nonce = max(time.time_ns(), last_nonce + 1)
    return str(last_nonce)


def sign(path, nonce, body=""):
    digest = hashlib.sha256((nonce + body).encode()).digest()
    mac = hmac.new(base64.b64decode(secret), path.encode() + digest, hashlib.sha512)
    return base64.b64encode(mac.digest()).decode()


def signed_get(path):
    nonce = next_nonce()
    response = requests.get(
        base_url.rstrip("/") + path,
        headers={"API-Key": api_key, "API-Nonce": nonce, "API-Sign": sign(path, nonce)},
        allow_redirects=False,
        timeout=15,
    )
    print(f"GET {path}: HTTP {response.status_code}")
    if not response.ok:
        raise SystemExit(response.text)
    return response.json()


print(signed_get("/v1/webhooks"))
user = signed_get(f"/v1/users/{quote(client_id)}")
main = next(account for account in user["data"]["accounts"] if account["name"] == "main")
print(f"Accounts: {json.dumps(user['data']['accounts'])}")
print(f"Set PWS_ACCOUNT_ID={main['id']}")
print(json.dumps(signed_get(f"/v1/accounts/{quote(main['id'])}/portfolio")))

import crypto from 'node:crypto';

const baseUrl = new URL(process.env.PWS_BASE_URL);
const apiKey = process.env.PWS_API_KEY;
const secret = process.env.PWS_API_SECRET;
const clientId = process.env.PWS_CLIENT_ID?.replaceAll(' ', '');

if ([apiKey, secret, clientId].some(value => !value || /replace_with/i.test(value))) {
  throw new Error('Replace every configuration placeholder before running the example.');
}
if (baseUrl.hostname !== 'api.sandbox.services.payward.com') {
  throw new Error('This example runs only against the sandbox.');
}

// Nonces must increase for each API key. Use nanoseconds since the Unix epoch, and never repeat a value.
let lastNonce = 0n;
function nextNonce() {
  const now = BigInt(Date.now()) * 1_000_000n;
  lastNonce = now > lastNonce ? now : lastNonce + 1n;
  return lastNonce.toString();
}

function sign(path, nonce, body = '') {
  const digest = crypto
    .createHash('sha256')
    .update(nonce + body)
    .digest();
  const message = Buffer.concat([Buffer.from(path), digest]);
  return crypto.createHmac('sha512', Buffer.from(secret, 'base64')).update(message).digest('base64');
}

async function signedGet(path) {
  const nonce = nextNonce();
  const response = await fetch(`${baseUrl.origin}${path}`, {
    redirect: 'error',
    signal: AbortSignal.timeout(15_000),
    headers: { 'API-Key': apiKey, 'API-Nonce': nonce, 'API-Sign': sign(path, nonce) },
  });
  const text = await response.text();
  console.log(`GET ${path}: HTTP ${response.status}`);
  if (!response.ok) throw new Error(text);
  return JSON.parse(text);
}

console.log(await signedGet('/v1/webhooks'));
const user = await signedGet(`/v1/users/${encodeURIComponent(clientId)}`);
const main = user.data.accounts.find(account => account.name === 'main');
console.log(`Accounts: ${JSON.stringify(user.data.accounts)}`);
console.log(`Set PWS_ACCOUNT_ID=${main.id}`);
console.log(JSON.stringify(await signedGet(`/v1/accounts/${encodeURIComponent(main.id)}/portfolio`)));

python3 check_credentials.py

node check-credentials.mjs