Offramp Integration

import os
import json
import hmac
import hashlib
import time
import uuid
import requests

BASE_URL = "https://ramp.hexarails.ai"
API_KEY = os.environ["COINUT_API_KEY"]
API_SECRET = os.environ["COINUT_API_SECRET"]


def create_signature(method: str, path: str, body: dict = None):
    timestamp = str(int(time.time()))
    nonce = str(uuid.uuid4())
    host = "ramp.hexarails.ai"
    request_body = "" if method.upper() == "GET" else json.dumps(body or {}, separators=(",", ":"))
    body_hash = hashlib.sha256(request_body.encode()).hexdigest() if request_body else ""
    payload = "\n".join([method.upper(), host, path, "", body_hash, timestamp, nonce])
    signature = hmac.new(API_SECRET.encode(), payload.encode(), hashlib.sha256).hexdigest()
    return timestamp, nonce, signature


def coinut_request(method: str, path: str, body: dict = None):
    timestamp, nonce, signature = create_signature(method, path, body)

    headers = {
        "Content-Type": "application/json",
        "X-API-Key": API_KEY,
        "X-Timestamp": timestamp,
        "X-Nonce": nonce,
        "X-Signature": signature,
    }

    resp = requests.request(method, f"{BASE_URL}{path}", json=body, headers=headers)
    resp.raise_for_status()
    return resp.json()


def create_customer(name: str, email: str, external_id: str) -> str:
    data = coinut_request("POST", "/customer/create", {
        "name": name,
        "email": email,
        "type": "DEPOSITOR",
        "isIndividual": True,
        "externalId": external_id,
    })
    return data["customerId"]


def add_bank_account(
    customer_id: str,
    currency: str,
    bank_name: str,
    account_no: str,
    **kwargs
) -> str:
    """Add a bank account. Required fields vary by currency."""
    body = {
        "customerId": customer_id,
        "currency": currency,
        "bankName": bank_name,
        "accountNo": account_no,
        **kwargs,
    }
    data = coinut_request("POST", "/bank-account/add", body)
    return data["bankAccountId"]


def create_offramp_flow(customer_id: str, network: str, bank_account_id: str):
    return coinut_request("POST", "/autoramp-flow/offramp", {
        "from": {
            "customerId": customer_id,
            "currency": "USDT", # "USDT" or "USDC"
            "network": network,  # "ETH","MATIC" or "TRX"
        },
        "to": bank_account_id,
    })


def execute_offramp(user: dict, bank_details: dict):
    """Full offramp flow for a user."""
    # Step 1: Create customer (wait for CUSTOMER_APPROVED webhook)
    customer_id = create_customer(user["name"], user["email"], user["id"])

    # Step 2: Add bank account
    bank_account_id = add_bank_account(
        customer_id=customer_id,
        currency=bank_details["currency"],
        bank_name=bank_details["bank_name"],
        account_no=bank_details["account_no"],
        swift=bank_details.get("swift"),
        iban=bank_details.get("iban"),
        bsb=bank_details.get("bsb"),
        aba=bank_details.get("aba"),
        accountName=user["name"],
    )

    # Step 3: Create offramp flow
    flow = create_offramp_flow(customer_id, bank_details["network"], bank_account_id)

    return {
        "customerId": customer_id,
        "bankAccountId": bank_account_id,
        "flowId": flow["flowId"],
        "depositAddress": flow["data"]["depositAddress"],
    }


# ── Webhook Handler (Flask) ──────────────────────────
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhooks/coinut", methods=["POST"])
def handle_webhook():
    event = request.json.get("event")
    data = request.json.get("data")

    handlers = {
        "DEPOSIT_RECEIVED": handle_deposit_received,
        "DEPOSIT_APPROVED": handle_deposit_approved,
        "TRADE_CREATED": handle_trade_created,
        "TRADE_SETTLED": handle_trade_settled,
    }

    handler = handlers.get(event)
    if handler:
        handler(data)

    return jsonify({"status": "ok"})


def handle_deposit_received(data):
    print(f"Deposit received: {data['amount']} {data['currency']}")
    # Notify customer that funds are being processed


def handle_deposit_approved(data):
    print(f"Deposit approved. Trade will execute shortly.")


def handle_trade_created(data):
    print(f"Trade created: {data['tradeId']}")


def handle_trade_settled(data):
    print(f"Trade settled! Fiat sent to bank account.")
    # Send customer notification


if __name__ == "__main__":
    app.run(port=3000)