Deposits and withdrawals

def list_deposit_methods(account_id, asset_symbol):
    params = {"asset_symbol": asset_symbol}
    path = f"/v1/accounts/{account_id}/funds/deposits/methods?{urlencode(params)}"

    response = requests.get(
        BASE_URL + path, headers=signed_headers("GET", path), timeout=10
    )
    response.raise_for_status()
    return response.json()


methods = list_deposit_methods(account_id, "BTC")
for m in methods["data"]:
    print(f"{m['network']} (id: {m['id']})")

async function listDepositMethods(accountId, assetSymbol) {
  const params = new URLSearchParams({ asset_symbol: assetSymbol });
  const path = `/v1/accounts/${accountId}/funds/deposits/methods?${params}`;

  const response = await fetch(BASE_URL + path, {
    method: 'GET',
    headers: signedHeaders('GET', path),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const methods = await listDepositMethods(accountId, 'BTC');
for (const m of methods.data) {
  console.log(`${m.network} (id: ${m.id})`);
}

def activate_deposit_method(account_id, method_id):
    path = (
        f"/v1/accounts/{account_id}/funds/deposits/methods/" f"{method_id}/activation"
    )

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path),
        timeout=10,
    )
    response.raise_for_status()


activate_deposit_method(
    account_id,
    "5e764f4c-f924-47f0-9fcb-6f98c37d1575",
)

async function activateDepositMethod(accountId, methodId) {
  const path = `/v1/accounts/${accountId}/funds/deposits/methods/${methodId}/activation`;

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
}

await activateDepositMethod(accountId, '5e764f4c-f924-47f0-9fcb-6f98c37d1575');

def list_deposit_addresses(account_id, method_id, page_token=None):
    params = {
        "method_id": method_id,
    }
    if page_token:
        params["page_token"] = page_token
    path = f"/v1/accounts/{account_id}/funds/deposits/addresses?{urlencode(params)}"

    response = requests.get(
        BASE_URL + path, headers=signed_headers("GET", path), timeout=10
    )
    response.raise_for_status()
    return response.json()


addresses = list_deposit_addresses(account_id, "2fa11f79-eeba-4d4e-afda-029abff6e29e")
for item in addresses["data"]:
    details = item["address_details"]
    if "crypto" in details:
        crypto = details["crypto"]
        print(f"Crypto address: {crypto['address']}")
    else:
        fiat = details["fiat"]
        print(f"Fiat instructions: {fiat}")

async function listDepositAddresses(accountId, methodId, pageToken = null) {
  const params = new URLSearchParams({ method_id: methodId });
  if (pageToken) params.set('page_token', pageToken);
  const path = `/v1/accounts/${accountId}/funds/deposits/addresses?${params}`;

  const response = await fetch(BASE_URL + path, {
    method: 'GET',
    headers: signedHeaders('GET', path),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const addresses = await listDepositAddresses(accountId, '2fa11f79-eeba-4d4e-afda-029abff6e29e');
for (const item of addresses.data) {
  if (item.address_details.crypto) {
    console.log('Crypto address:', item.address_details.crypto.address);
  } else {
    console.log('Fiat instructions:', item.address_details.fiat);
  }
}

def claim_deposit_address(account_id, method_id):
    path = f"/v1/accounts/{account_id}/funds/deposits/addresses"
    body = json.dumps({"method_id": method_id})

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body),
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


address = claim_deposit_address(
    account_id,
    "2fa11f79-eeba-4d4e-afda-029abff6e29e",
)
print(f"Deposit address: {address['data']['address']}")

async function claimDepositAddress(accountId, methodId) {
  const path = `/v1/accounts/${accountId}/funds/deposits/addresses`;
  const body = JSON.stringify({ method_id: methodId });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const address = await claimDepositAddress(accountId, '2fa11f79-eeba-4d4e-afda-029abff6e29e');
console.log('Deposit address:', address.data.address);

def create_lightning_invoice(account_id, amount):
    path = f"/v1/accounts/{account_id}/funds/deposits/lightning-invoices"
    body = json.dumps({"asset_symbol": "BTC", "amount": amount})

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body),
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


lightning = create_lightning_invoice(account_id, "0.0005")
print(f"Invoice: {lightning['data']['invoice']}")
print(f"Expires at: {lightning['data'].get('expires_at')}")

async function createLightningInvoice(accountId, amount) {
  const path = `/v1/accounts/${accountId}/funds/deposits/lightning-invoices`;
  const body = JSON.stringify({ asset_symbol: 'BTC', amount });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const lightning = await createLightningInvoice(accountId, '0.0005');
console.log('Invoice:', lightning.data.invoice);
console.log('Expires at:', lightning.data.expires_at);

def list_funding_addresses(account_id, method_id=None, page_size=20, page_token=None):
    params = {"page_token": page_token} if page_token else {"page_size": page_size}
    if method_id is not None:
        params["method_id"] = method_id
    path = f"/v1/accounts/{account_id}/funds/addresses?{urlencode(params)}"

    response = requests.get(
        BASE_URL + path, headers=signed_headers("GET", path), timeout=10
    )
    response.raise_for_status()
    return response.json()

async function listFundingAddresses(accountId, methodId = null, pageSize = 20, pageToken = null) {
  const params = new URLSearchParams(pageToken ? { page_token: pageToken } : { page_size: pageSize });
  if (methodId !== null) params.set('method_id', methodId);
  const path = `/v1/accounts/${accountId}/funds/addresses?${params}`;

  const response = await fetch(BASE_URL + path, { method: 'GET', headers: signedHeaders('GET', path) });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

def create_funding_address(account_id, scope, name, address, tag=None, memo=None):
    path = f"/v1/accounts/{account_id}/funds/addresses"
    crypto = {"address": address}
    if tag:
        crypto["tag"] = tag
    if memo:
        crypto["memo"] = memo

    body = json.dumps(
        {
            "scope": scope,
            "name": name,
            "address_details": {"crypto": crypto},
        }
    )

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body),
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()

async function createFundingAddress(accountId, scope, name, address, tag = null, memo = null) {
  const path = `/v1/accounts/${accountId}/funds/addresses`;
  const crypto = { address };
  if (tag) crypto.tag = tag;
  if (memo) crypto.memo = memo;

  const body = JSON.stringify({
    scope,
    name,
    address_details: { crypto },
  });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

def calculate_funding_fees(account_id, method_id, amount):
    path = f"/v1/accounts/{account_id}/funds/fees"
    body = json.dumps(
        {
            "method_id": method_id,
            "amount": amount,
        }
    )

    response = requests.post(
        BASE_URL + path,
        headers=signed_headers("POST", path, body),
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


quote = calculate_funding_fees(
    account_id,
    "2fa11f79-eeba-4d4e-afda-029abff6e29e",
    "0.01000000",
)

async function calculateFundingFees(accountId, methodId, amount) {
  const path = `/v1/accounts/${accountId}/funds/fees`;
  const body = JSON.stringify({
    method_id: methodId,
    amount,
  });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: signedHeaders('POST', path, body),
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

const quote = await calculateFundingFees(accountId, '2fa11f79-eeba-4d4e-afda-029abff6e29e', '0.01000000');

def create_withdrawal(
    account_id, scope, destination, symbol, amount, fee_token=None, idempotency_key=None
):
    path = f"/v1/accounts/{account_id}/funds/withdrawals"
    payload = {
        "scope": scope,
        "destination": destination,
        "symbol": symbol,
        "amount": amount,
    }
    if fee_token is not None:
        payload["fee_token"] = fee_token
    body = json.dumps(payload)

    headers = signed_headers("POST", path, body)
    if idempotency_key is not None:
        headers["Idempotency-Key"] = idempotency_key
    response = requests.post(
        BASE_URL + path,
        headers=headers,
        data=body,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


create_withdrawal(
    account_id,
    {"method_id": "2fa11f79-eeba-4d4e-afda-029abff6e29e"},
    {"type": "funding_address", "address_id": "AB12345-6789A-BCDEFG"},
    "BTC",
    "0.01000000",
    fee_token=quote["data"].get("fee_token"),
    idempotency_key="550e8400-e29b-41d4-a716-446655440000",
)

async function createWithdrawal(accountId, scope, destination, symbol, amount, feeToken, idempotencyKey) {
  const path = `/v1/accounts/${accountId}/funds/withdrawals`;
  const body = JSON.stringify({
    scope,
    destination,
    symbol,
    amount,
    ...(feeToken ? { fee_token: feeToken } : {}),
  });

  const response = await fetch(BASE_URL + path, {
    method: 'POST',
    headers: {
      ...signedHeaders('POST', path, body),
      ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}),
    },
    body,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

await createWithdrawal(
  accountId,
  { method_id: '2fa11f79-eeba-4d4e-afda-029abff6e29e' },
  { type: 'funding_address', address_id: 'AB12345-6789A-BCDEFG' },
  'BTC',
  '0.01000000',
  quote.data.fee_token,
  '550e8400-e29b-41d4-a716-446655440000',
);