Web app: connect wallet to an order

[dependencies]
polynode = { version = "0.17.1", features = ["trading"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
chrono = "0.4"
anyhow = "1"

import os
from polynode.trading import ExecutionMode, PolyNodeTrader, TraderConfig

trader = PolyNodeTrader(TraderConfig(
    polynode_key=os.environ["POLYNODE_API_KEY"],
    execution_mode=ExecutionMode.USER_OWNED,
    db_path=":memory:",
))
try:
    challenge = await trader.begin_user_relayer_authorization(expected_address)

    await pending_authorizations.put_once(
        challenge.challenge_id,
        {
            "application_user_id": application_user_id,
            "expected_address": expected_address,
            "challenge": challenge,
        },
        expires_at=challenge.expires_at,
    )

    return {
        "authorizationId": challenge.challenge_id,
        "address": challenge.address,
        "expiresAt": challenge.expires_at,
        "message": challenge.message,
    }
finally:
    trader.close()

use polynode::trading::{Address, ExecutionMode, PolyNodeTrader, TraderConfig};

let expected_address: Address = input.address.parse()?;

let mut trader = PolyNodeTrader::new(TraderConfig {
    polynode_key: std::env::var("POLYNODE_API_KEY")?,
    execution_mode: ExecutionMode::UserOwned,
    db_path: ":memory:".into(),
    ..Default::default()
})?;

let challenge = trader
    .begin_user_relayer_authorization(expected_address)
    .await?;

// expires_at is canonical RFC 3339 UTC with millisecond precision.
let expires_at = chrono::DateTime::parse_from_rfc3339(&challenge.expires_at)?
    .with_timezone(&chrono::Utc);
let ttl = expires_at
    .signed_duration_since(chrono::Utc::now())
    .to_std()?;

pending_authorizations.put_once(
    &challenge.challenge_id,
    &application_user_id,
    &expected_address,
    &challenge,
    ttl,
).await?;

// Return only the ID, expected address, expiry, and display message.
trader.close();

pending = await pending_authorizations.take_once_for_owner(
    input.authorization_id,
    application_user_id=application_user_id,
    expected_address=expected_address,  # both come from the authenticated server session
)
if pending is None:
    raise ValueError("Unknown, expired, or already-used authorization")
assert_application_user(pending["application_user_id"])
assert_expected_wallet(pending["expected_address"], input.address)

try:
    credential = await trader.complete_user_relayer_authorization(
        pending["challenge"],
        input.signature,
        pending["expected_address"],
    )

    return {
        "userRelayerCredentials": {
            "key": credential.key,
            "address": credential.address,
        }
    }
finally:
    trader.close()

let pending = pending_authorizations
    .take_once_for_owner(
        &input.authorization_id,
        &application_user_id,
        expected_address,
    )
    .await?
    .ok_or("unknown, expired, or already-used authorization")?;

assert_application_user(&pending.application_user_id)?;
assert_expected_wallet(pending.expected_address, input.address)?;

let credential = trader
    .complete_user_relayer_authorization(
        &pending.challenge,
        &input.signature,
        pending.expected_address,
    )
    .await?;

let response_body = serde_json::json!({
    "userRelayerCredentials": credential,
});
trader.close();

from polynode.trading import UserOwnedBrowserBundle

validated = UserOwnedBrowserBundle.from_dict(bundle)
trader = PolyNodeTrader(TraderConfig(
    polynode_key=os.environ["POLYNODE_API_KEY"],
    execution_mode=ExecutionMode.USER_OWNED,
    db_path=":memory:",
))
try:
    await trader.import_user_owned_browser_bundle(validated)
    await encrypted_wallet_vault.put(expected_address, bundle)
finally:
    trader.close()

use polynode::trading::UserOwnedBrowserBundle;

let bundle: UserOwnedBrowserBundle = serde_json::from_slice(&bounded_body)?;
trader.import_user_owned_browser_bundle(bundle).await?;
encrypted_wallet_vault.put(expected_address, &bounded_body).await?;
trader.close();

from polynode.trading import OrderParams

bundle = await encrypted_wallet_vault.get(expected_address)
trader = PolyNodeTrader(TraderConfig(
    polynode_key=os.environ["POLYNODE_API_KEY"],
    execution_mode=ExecutionMode.USER_OWNED,
    db_path=":memory:",
))
prepared = None
try:
    await trader.import_user_owned_browser_bundle(bundle)

    prepared = await trader.prepare_user_owned_order(OrderParams(
        token_id=input.token_id,
        side=input.side,
        price=input.price,
        size=input.size,
        type=input.type or "GTC",
        post_only=bool(input.post_only),
    ))

    signing_request = prepared.signing_request.to_dict()
    order_hash = prepared.order_hash
    server_state = trader.export_prepared_user_owned_order(prepared)

    await pending_orders.put_once(
        signing_request["requestId"],
        {
            "application_user_id": application_user_id,
            "expected_address": expected_address,
            "order_hash": order_hash,
            "order": signing_request["order"],
            "server_state": server_state,
        },
        expires_at=signing_request["expiresAt"],
    )

    return signing_request
finally:
    if prepared is not None:
        trader.discard_prepared_user_owned_order(prepared)
    trader.close()

use polynode::trading::{
    ExecutionMode, OrderParams, PolyNodeTrader, TraderConfig,
    UserOwnedBrowserBundle,
};

let bundle: UserOwnedBrowserBundle = encrypted_wallet_vault
    .get(expected_address)
    .await?;
let mut trader = PolyNodeTrader::new(TraderConfig {
    polynode_key: std::env::var("POLYNODE_API_KEY")?,
    execution_mode: ExecutionMode::UserOwned,
    db_path: ":memory:".into(),
    ..Default::default()
})?;
trader.import_user_owned_browser_bundle(bundle).await?;

let prepared = trader.prepare_user_owned_order(OrderParams {
    token_id: input.token_id,
    side: input.side,
    price: input.price,
    size: input.size,
    order_type: input.order_type.unwrap_or_default(),
    post_only: input.post_only,
    ..Default::default()
}).await?;

let signing_request = prepared.signing_request().clone();
let order_hash = prepared.order_hash()?;
let server_state = prepared.to_server_store_json()?;

pending_orders.put_once(
    &signing_request.request_id,
    &application_user_id,
    expected_address,
    &order_hash,
    &signing_request.order,
    &server_state,
    signing_request.expires_at,
).await?;

drop(prepared);
trader.close();
// Return signing_request.

from datetime import datetime, timezone

pending = await pending_orders.take_once_for_owner(
    input.request_id,
    application_user_id=application_user_id,
    expected_address=expected_address,  # authenticated server-session values
)
if pending is None:
    raise ValueError("Unknown, expired, or already-used order")
assert_application_user(pending["application_user_id"])
assert_expected_wallet(pending["expected_address"], input.address)

bundle = await encrypted_wallet_vault.get(pending["expected_address"])
trader = PolyNodeTrader(TraderConfig(
    polynode_key=os.environ["POLYNODE_API_KEY"],
    execution_mode=ExecutionMode.USER_OWNED,
    db_path=":memory:",
))
try:
    await trader.import_user_owned_browser_bundle(bundle)

    prepared = trader.import_prepared_user_owned_order(pending["server_state"])
    if prepared.order_hash.lower() != pending["order_hash"].lower():
        raise ValueError("Prepared order identity mismatch")
    await order_attempts.put_once(pending["order_hash"], {
        "request_id": input.request_id,
        "application_user_id": application_user_id,
        "expected_address": expected_address,
        "order": pending["order"],
        "status": "submitting",
        "started_at": datetime.now(timezone.utc).isoformat(),
    })
    return await trader.submit_prepared_user_owned_order(
        prepared,
        request_id=input.request_id,
        address=input.address,
        signature=input.signature,
    )
finally:
    trader.close()

use polynode::trading::{
    ExecutionMode, PolyNodeTrader, PreparedUserOwnedOrder, TraderConfig,
};

let pending = pending_orders
    .take_once_for_owner(
        &input.request_id,
        &application_user_id,
        expected_address,
    )
    .await?
    .ok_or("unknown, expired, or already-used order")?;
assert_application_user(&pending.application_user_id)?;
assert_expected_wallet(pending.expected_address, input.address)?;

let bundle = encrypted_wallet_vault
    .get(pending.expected_address)
    .await?;
let mut trader = PolyNodeTrader::new(TraderConfig {
    polynode_key: std::env::var("POLYNODE_API_KEY")?,
    execution_mode: ExecutionMode::UserOwned,
    db_path: ":memory:".into(),
    ..Default::default()
})?;
trader.import_user_owned_browser_bundle(bundle).await?;

let prepared = PreparedUserOwnedOrder::from_server_store_json(
    &pending.server_state,
)?;
if prepared.order_hash()?.to_lowercase() != pending.order_hash.to_lowercase() {
    return Err("prepared order identity mismatch".into());
}
order_attempts.put_once(
    &pending.order_hash,
    &input.request_id,
    &application_user_id,
    expected_address,
    &pending.order,
    "submitting",
).await?;
let result = trader.submit_prepared_user_owned_order(
    prepared,
    &input.request_id,
    &input.address,
    &input.signature,
).await?;

trader.close();