Test deposits and withdrawals

import crypto from 'node:crypto';

const BASE_URL = process.env.PWS_BASE_URL;
const API_KEY = process.env.PWS_API_KEY;
const API_SECRET = process.env.PWS_API_SECRET;
export const ACCOUNT = `/v1/accounts/${process.env.PWS_ACCOUNT_ID}`;
// The Ethereum funding methods' network name: "Ethereum Sepolia Testnet" in the sandbox, "Ethereum" in production.
export const ETHEREUM = new Set(['Ethereum Sepolia Testnet', 'Ethereum']);

let lastNonce = 0n;
function nextNonce() {
  const now = BigInt(Date.now()) * 1_000_000n;
  lastNonce = now > lastNonce ? now : lastNonce + 1n;
  return lastNonce.toString();
}

export async function call(method, path, body = undefined, headers = {}) {
  const nonce = nextNonce();
  const data = body === undefined ? '' : JSON.stringify(body);
  const digest = crypto
    .createHash('sha256')
    .update(nonce + data)
    .digest();
  const sign = crypto
    .createHmac('sha512', Buffer.from(API_SECRET, 'base64'))
    .update(Buffer.concat([Buffer.from(path), digest]))
    .digest('base64');
  const response = await fetch(BASE_URL + path, {
    method,
    body: data || undefined,
    signal: AbortSignal.timeout(15_000),
    headers: {
      'API-Key': API_KEY,
      'API-Nonce': nonce,
      'API-Sign': sign,
      ...(data ? { 'Content-Type': 'application/json' } : {}),
      ...headers,
    },
  });
  const text = await response.text();
  if (!response.ok) throw new Error(`${method} ${path}: HTTP ${response.status} ${text}`);
  return text ? JSON.parse(text) : {};
}

// Search every page of portfolio transactions of one type for the first match.
export async function findTransaction(kind, matches) {
  let path = `${ACCOUNT}/portfolio/transactions?types=${kind}`;
  while (path) {
    const page = await call('GET', path);
    const found = page.data.find(matches);
    if (found) return found;
    const token = page.next_page_token;
    path = token ? `${ACCOUNT}/portfolio/transactions?types=${kind}&page_token=${encodeURIComponent(token)}` : null;
  }
  return null;
}

export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

import { ACCOUNT, ETHEREUM, call, findTransaction, sleep } from './pws-sandbox.mjs';

const txHash = (process.env.TX_HASH ?? '').toLowerCase();

// 1. Find the Ethereum USDC deposit method. Its network is "Ethereum Sepolia Testnet" in the sandbox.
async function ethereumMethod() {
  const { data } = await call('GET', `${ACCOUNT}/funds/deposits/methods?asset_symbol=USDC`);
  return data.find(m => ETHEREUM.has(m.network));
}

let method = await ethereumMethod();
if (method.activation_status === 'needed') {
  await call('POST', `${ACCOUNT}/funds/deposits/methods/${method.id}/activation`);
  while (method.activation_status !== 'completed') {
    await sleep(5_000);
    method = await ethereumMethod();
  }
}
console.log(`Method ${method.id}, minimum ${method.minimum.amount} USDC`);

// 2. Reuse a deposit address, or claim one. Claiming isn't idempotent, so don't retry it blindly.
const { data: addresses } = await call('GET', `${ACCOUNT}/funds/deposits/addresses?method_id=${method.id}`);
const address = addresses.length
  ? addresses[0].address_details.crypto.address
  : (await call('POST', `${ACCOUNT}/funds/deposits/addresses`, { method_id: method.id })).data.address;
console.log(`Send Sepolia USDC to ${address}`);
if (!txHash) {
  console.log('Then run this script again with TX_HASH set to the transaction hash.');
  process.exit(1);
}

// 3. Poll until the deposit with that transaction hash is successful or failed.
const deadline = Date.now() + 15 * 60_000;
while (Date.now() < deadline) {
  const deposit = await findTransaction(
    'deposit',
    t => (t.details?.crypto_transaction_id ?? '').toLowerCase() === txHash,
  );
  const status = deposit?.status ?? 'not seen yet';
  console.log(`Deposit: ${status}`);
  if (status === 'successful' || status === 'failed') break;
  await sleep(20_000);
}

TX_HASH=0xYOUR_TRANSACTION_HASH python3 deposit.py

TX_HASH=0xYOUR_TRANSACTION_HASH node deposit.mjs

import crypto from 'node:crypto';
import { ACCOUNT, ETHEREUM, call, findTransaction, sleep } from './pws-sandbox.mjs';

const wallet = process.env.WALLET_ADDRESS;
const amount = process.env.AMOUNT ?? '1';

// 1. Find the Ethereum USDC withdrawal method. Its network is "Ethereum Sepolia Testnet" in the sandbox.
const { data: methods } = await call('GET', `${ACCOUNT}/funds/withdrawals/methods?asset_symbol=USDC`);
const method = methods.find(m => ETHEREUM.has(m.network));

// 2. Reuse the funding address for your wallet, or register it.
const { data: addresses } = await call('GET', `${ACCOUNT}/funds/addresses?method_id=${method.id}`);
const match = addresses.find(a => a.address_details.crypto?.address?.toLowerCase() === wallet.toLowerCase());
const addressId = match
  ? match.address_id
  : (
      await call('POST', `${ACCOUNT}/funds/addresses`, {
        scope: { method_id: method.id },
        name: `test-wallet-${wallet.slice(-6)}`,
        address_details: { crypto: { address: wallet } },
      })
    ).data.address_id;

// 3. Quote the fee right before you withdraw. The fee token is short-lived.
const { data: fee } = await call('POST', `${ACCOUNT}/funds/fees`, { method_id: method.id, amount });
console.log(`Fee ${fee.fee.amount} USDC, you receive ${fee.net_amount.amount} USDC`);

// 4. Create the withdrawal. To retry after an unknown outcome, reuse the same key and body.
// A 409 withdrawal_verification_required means you must verify the address first; see the guide.
const idempotencyKey = crypto.randomUUID();
const { data: withdrawal } = await call(
  'POST',
  `${ACCOUNT}/funds/withdrawals`,
  {
    scope: { method_id: method.id },
    destination: { type: 'funding_address', address_id: addressId },
    symbol: 'USDC',
    amount,
    fee_token: fee.fee_token,
  },
  { 'Idempotency-Key': idempotencyKey },
);
console.log(`Withdrawal ${withdrawal.withdrawal_id}`);

// 5. Poll until it's successful or failed.
const deadline = Date.now() + 15 * 60_000;
while (Date.now() < deadline) {
  const found = await findTransaction('withdrawal', t => t.reference.id === withdrawal.withdrawal_id);
  const status = found?.status ?? 'not seen yet';
  console.log(`Withdrawal: ${status}`);
  if (status === 'successful' || status === 'failed') {
    if (found) console.log(`Transaction hash: ${found.details?.crypto_transaction_id}`);
    break;
  }
  await sleep(20_000);
}

WALLET_ADDRESS=0xYOUR_TEST_WALLET python3 withdraw.py

WALLET_ADDRESS=0xYOUR_TEST_WALLET node withdraw.mjs