Pay-as-you-go#

require github.com/okx/payments/go/mpp v0.1.0

package main

import (
    "log"
    "math/big"
    "net/http"
    "os"

    "github.com/gin-gonic/gin"

    "github.com/okx/payments/go/mpp/evm"
    mppgin "github.com/okx/payments/go/mpp/http/gin"
    "github.com/okx/payments/go/mpp/saclient"
    "github.com/okx/payments/go/mpp/server"
    "github.com/okx/payments/go/mpp/store"
)

func main() {
    saClient := saclient.NewOKXSAClient(
        os.Getenv("OKX_BASE_URL"),
        os.Getenv("OKX_API_KEY"),
        os.Getenv("OKX_SECRET_KEY"),
        os.Getenv("OKX_PASSPHRASE"),
    )

    // Payee signer for settle/close — any evm.Signer implementation.
    // PrivateKeySigner / KMS / custom remote signer.
    signer, err := evm.NewPrivateKeySignerFromHex(os.Getenv("PRIVATE_KEY"))
    if err != nil {
        log.Fatalf("signer: %v", err)
    }

    // Default in-memory store; swap via FileStore / custom Store for persistence.
    channelStore, err := store.NewFileStore[store.ChannelState]("mpp-data")
    if err != nil {
        log.Fatalf("store: %v", err)
    }

    sessionMethod, err := evm.NewEVMSessionMethod(evm.EVMSessionMethodConfig{
        ChainID:         196,                                      // X Layer
        Recipient:       "0x...378211",
        SAClient:        saClient,
        Signer:          signer,
        Store:           channelStore,
        EscrowContract:  os.Getenv("ESCROW_CONTRACT"),
        PerRequestCost:  big.NewInt(100),
        MinVoucherDelta: big.NewInt(0),
        FeePayer:        true,
    })
    if err != nil {
        log.Fatalf("session method: %v", err)
    }

    mpp := server.NewMpp(server.EVMConfig{
        ChainID:   196,
        Recipient: "0x...378211",
        SecretKey: os.Getenv("MPP_SECRET_KEY"),
        Realm:     "test realm",
    }, nil, sessionMethod)

    r := gin.Default()

    // /session/manage routes by payload.action: open / voucher / topUp / close.
    r.GET("/session/manage",
        mppgin.SessionMiddleware(mpp, server.SessionRouteConfig{
            Amount:           "100",            // 0.0001 of a 6-decimal token
            Currency:         "0x...adb21711",
            Decimals:         6,
            Description:      "Premium streaming data",
            UnitType:         "request",
            SuggestedDeposit: "10000",          // 100x unit price
        }),
        func(c *gin.Context) {
            receipt := mppgin.GetReceipt(c)
            c.JSON(http.StatusOK, gin.H{
                "data":    "streaming content",
                "receipt": receipt,
            })
        },
    )

    log.Fatal(r.Run(":4023"))
}

[dependencies]
mpp-evm = { git = "https://github.com/okx/payments" } # tag configurable
mpp     = { version = "0.10", features = ["server", "evm", "tower", "axum"] }

use std::sync::Arc;

use alloy_primitives::Address;
use alloy_signer_local::PrivateKeySigner;
use axum::{
    extract::State,
    http::{header, HeaderMap, StatusCode},
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};
use mpp::protocol::core::{format_www_authenticate, parse_authorization};
use mpp::protocol::traits::SessionMethod;
use mpp_evm::challenge::{build_session_challenge, session_request_with};
use mpp_evm::sa_client::SaApiClient;
use mpp_evm::types::SessionMethodDetails;
use mpp_evm::{handlers, CredentialExt, EvmSessionMethod, OkxSaApiClient};
use serde_json::{json, Value};

const UNIT_PRICE_BASE_UNITS: &str = "100";   // 0.0001 of a 6-decimal token
const UNIT_TYPE: &str = "request";
const SUGGESTED_DEPOSIT: &str = "10000";     // 100× unit price

#[derive(Clone)]
struct AppState {
    session_method: Arc<EvmSessionMethod>,
    realm: String,
    currency: String,
    recipient: String,
    escrow: String,
    secret_key: String,
}

#[tokio::main]
async fn main() {
    let okx_api_key      = std::env::var("OKX_API_KEY").unwrap();
    let okx_secret_key   = std::env::var("OKX_SECRET_KEY").unwrap();
    let okx_pass_pharse     = std::env::var("OKX_PASSPHRASE").unwrap();
    let secret_key  = std::env::var("MPP_SECRET_KEY").unwrap();
    let escrow      = std::env::var("MPP_ESCROW").unwrap();
    let merchant_pk = std::env::var("MPP_MERCHANT_PRIVATE_KEY").unwrap();

    // `with_signer` takes any `alloy::signers::Signer` — PrivateKeySigner / AwsSigner /
    // LedgerSigner / custom remote signer. `verify_payee` fast-fails on startup if
    // signer.address() != expected_payee.
    let signer: PrivateKeySigner = merchant_pk.parse().unwrap();
    let expected_payee: Address = recipient.parse().unwrap();

    let sa_client: Arc<dyn SaApiClient> =
        Arc::new(OkxSaApiClient::new(okx_api_key, okx_secret_key, okx_pass_pharse));

    // Default in-memory store; swap via `with_store(...)` for SQLite / Redis / Postgres.
    let session_method = Arc::new(
        EvmSessionMethod::new(sa_client)
            .with_escrow(&escrow)
            .with_signer(signer)
            .verify_payee(expected_payee)
            .unwrap(),
    );

    let state = Arc::new(AppState {
        session_method: session_method.clone(),
        realm: "test realm",// realm
        currency: "0x...adb21711", //currency
        receipt: "0x...378211", //receipt
        escrow,
        secret_key,
    });

    // /session/manage routes by `payload.action`: open / voucher / topUp / close.
    // /session/{settle,status} are SDK drop-in handlers.
    let app = Router::new()
        .route("/session/manage", post(manage))
        .route("/session/settle", post(handlers::session_settle))
        .route("/session/status", get(handlers::session_status))
        .with_state(state)
        .with_state(session_method);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:4023").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// With Authorization → verify_session + respond. Without → issue a 402 challenge.
async fn manage(State(state): State<Arc<AppState>>, headers: HeaderMap) -> impl IntoResponse {
    if let Some(auth) = headers.get(header::AUTHORIZATION).and_then(|v| v.to_str().ok()) {
        let credential = match parse_authorization(auth) {
            Ok(c) => c,
            Err(e) => return (StatusCode::BAD_REQUEST,
                              Json(json!({ "error": format!("parse: {e}") }))).into_response(),
        };
        let request = match credential.decode_request() {
            Ok(r) => r,
            Err(e) => return (StatusCode::BAD_REQUEST,
                              Json(json!({ "error": e.to_string() }))).into_response(),
        };
        return match state.session_method.verify_session(&credential, &request).await {
            Ok(receipt) => {
                let body = state.session_method.respond(&credential, &receipt)
                    .unwrap_or_else(|| json!({ "status": "ok" }));
                (StatusCode::OK, Json(body)).into_response()
            }
            Err(e) => (StatusCode::PAYMENT_REQUIRED,
                      Json(json!({ "error": e.to_string() }))).into_response(),
        };
    }

    let mut request = session_request_with(
        UNIT_PRICE_BASE_UNITS,
        &state.currency,
        &state.recipient,
        SessionMethodDetails {
            chain_id: 196,
            escrow_contract: state.escrow.clone(),
            fee_payer: Some(true),
            min_voucher_delta: Some("0".into()),
            ..Default::default()
        },
    ).unwrap();
    request.suggested_deposit = Some(SUGGESTED_DEPOSIT.into());
    request.unit_type = Some(UNIT_TYPE.into());

    let challenge = build_session_challenge(&state.secret_key, &state.realm, &request, None).unwrap();
    let www_auth = format_www_authenticate(&challenge).unwrap();

    let mut headers = HeaderMap::new();
    headers.insert(header::WWW_AUTHENTICATE, www_auth.parse().unwrap());
    (
        StatusCode::PAYMENT_REQUIRED,
        headers,
        Json(json!({
            "error": "Payment Required",
            "unitPrice": UNIT_PRICE_BASE_UNITS,
            "unitType": UNIT_TYPE,
            "suggestedDeposit": SUGGESTED_DEPOSIT,
        })),
    ).into_response()
}