Requests

import json, time, requests
from eth_account import Account
from eth_utils import keccak

BASE_URL = "https://dev.upsidemax.xyz"

# EIP-712 domain: Exchange / v1 / chainId 9767 / verifyingContract 0x0
_CHAIN_ID, _NAME, _VER, _SOURCE = 9767, "Exchange", "1", "b"

def _u(v):    return int(v).to_bytes(32, "big")
def _addr(s): return b"\x00" * 12 + bytes.fromhex(s[2:] if s[:2].lower() == "0x" else s)
def _s(v):    return keccak(str(v).encode())

_DOMAIN = keccak(
    keccak(b"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
    + keccak(_NAME.encode()) + keccak(_VER.encode()) + _u(_CHAIN_ID) + b"\x00" * 32)

# Funds / permission actions each sign a field-level typed struct; every other action
# uses the Agent path. Each struct's field names match the action's JSON keys, so the
# encoding is derived straight from the type string — no per-action code to maintain.
_TYPED = {
    "registerAccount":          "RegisterAccount(address address,uint64 nonce)",
    "approveAgent":             "ApproveAgent(address agentAddress,string agentName,uint64 validUntil,uint64 nonce)",
    "revokeAgent":              "RevokeAgent(address agentAddress,uint64 nonce)",
    "lockCollateral":           "LockCollateral(uint32 marketDeployerId,uint32 coinId,string amount,uint64 nonce)",
    "unlockCollateral":         "UnlockCollateral(uint32 marketDeployerId,uint32 coinId,string amount,uint64 nonce)",
    "transferBetweenDeployers": "TransferBetweenDeployers(uint32 fromMarketDeployerId,uint32 toMarketDeployerId,uint32 coinId,string amount,uint64 nonce)",
}

# Optional typed fields MUST still appear in the wire JSON — the server reads them by
# name to recompute the digest. Inject their defaults before signing so the signed
# struct and the sent JSON match; otherwise the server recovers a different address → 401.
_TYPED_DEFAULTS = {"approveAgent": {"agentName": "", "validUntil": 0}}

def _field(sol_type, value):                        # EIP-712 field encoding
    if sol_type == "address": return _addr(value)   # 20 bytes, left-padded to 32
    if sol_type == "string":  return _s(value)      # keccak256(utf8)
    return _u(value)                                # uintN -> 32-byte big-endian

def _typed_struct(type_str, action, nonce):
    fields = [f.split() for f in type_str[type_str.index("(") + 1 : -1].split(",")]
    enc = [_field(t, nonce if name == "nonce" else action[name]) for t, name in fields]
    return keccak(keccak(type_str.encode()) + b"".join(enc))

def eip712_digest(action, nonce):
    type_str = _TYPED.get(action["type"])
    if type_str:   # typed path — field-level EIP-712 encoding
        for k, v in _TYPED_DEFAULTS.get(action["type"], {}).items():
            action.setdefault(k, v)   # fill optional fields so the wire JSON matches the digest
        struct = _typed_struct(type_str, action, nonce)
    else:          # Agent path — canonical JSON folded into an actionHash
        canonical = json.dumps(action, sort_keys=True, separators=(",", ":")).encode()
        action_hash = keccak(canonical + int(nonce).to_bytes(8, "big"))
        struct = keccak(keccak(b"Agent(string source,bytes32 actionHash)")
                        + keccak(_SOURCE.encode()) + action_hash)
    return keccak(b"\x19\x01" + _DOMAIN + struct)

_last_nonce = 0
def _next_nonce():                     # strictly increasing — avoids sub-ms nonce collisions
    global _last_nonce
    _last_nonce = max(_last_nonce + 1, int(time.time() * 1000))
    return _last_nonce

def sign_and_send(action, private_key):
    """Sign an action with EIP-712 and POST it to /exchange."""
    nonce = _next_nonce()
    sig = Account._sign_hash(eip712_digest(action, nonce), private_key)
    envelope = {
        "action": action,
        "signature": {
            "r": "0x" + sig.r.to_bytes(32, "big").hex(),
            "s": "0x" + sig.s.to_bytes(32, "big").hex(),
            "v": sig.v if sig.v >= 27 else sig.v + 27,
        },
        "nonce": nonce,
    }
    resp = requests.post(f"{BASE_URL}/exchange", json=envelope, timeout=15)
    return resp.json()

// npm i ethers
import {
  keccak256, getBytes, concat, toUtf8Bytes, zeroPadValue, toBeArray,
  hexlify, SigningKey,
} from "ethers";

const BASE_URL = "https://dev.upsidemax.xyz";

// EIP-712 domain: Exchange / v1 / chainId 9767 / verifyingContract 0x0
const CHAIN_ID = 9767n, NAME = "Exchange", VER = "1", SOURCE = "b";
const kb   = (d: Uint8Array) => getBytes(keccak256(d));
const u256 = (v: bigint | number) => getBytes(zeroPadValue(toBeArray(BigInt(v)), 32));
const be8  = (v: bigint | number) => getBytes(zeroPadValue(toBeArray(BigInt(v)), 8));
const a32  = (s: string) => getBytes(zeroPadValue(s, 32));
const hs   = (s: string) => kb(toUtf8Bytes(s));
const cat  = (a: Uint8Array[]) => getBytes(concat(a));

const DOMAIN = kb(cat([
  hs("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
  hs(NAME), hs(VER), u256(CHAIN_ID), u256(0),
]));

// Funds / permission actions each sign a field-level typed struct; every other action
// uses the Agent path. Each struct's field names match the action's JSON keys, so the
// encoding is derived straight from the type string — no per-action code to maintain.
const TYPED: Record<string, string> = {
  registerAccount:          "RegisterAccount(address address,uint64 nonce)",
  approveAgent:             "ApproveAgent(address agentAddress,string agentName,uint64 validUntil,uint64 nonce)",
  revokeAgent:              "RevokeAgent(address agentAddress,uint64 nonce)",
  lockCollateral:           "LockCollateral(uint32 marketDeployerId,uint32 coinId,string amount,uint64 nonce)",
  unlockCollateral:         "UnlockCollateral(uint32 marketDeployerId,uint32 coinId,string amount,uint64 nonce)",
  transferBetweenDeployers: "TransferBetweenDeployers(uint32 fromMarketDeployerId,uint32 toMarketDeployerId,uint32 coinId,string amount,uint64 nonce)",
};

// Optional typed fields must still appear in the wire JSON — inject defaults before signing.
const TYPED_DEFAULTS: Record<string, Record<string, any>> = { approveAgent: { agentName: "", validUntil: 0 } };

const encodeField = (solType: string, value: any): Uint8Array =>  // EIP-712 field encoding
  solType === "address" ? a32(value)          // 20 bytes, left-padded to 32
  : solType === "string" ? hs(String(value))  // keccak256(utf8)
  : u256(value);                              // uintN -> 32-byte big-endian

function typedStruct(typeStr: string, action: any, nonce: bigint): Uint8Array {
  const fields = typeStr.slice(typeStr.indexOf("(") + 1, -1).split(",").map(f => f.split(" "));
  const enc = fields.map(([t, name]) => encodeField(t, name === "nonce" ? nonce : action[name]));
  return kb(cat([hs(typeStr), ...enc]));
}

// Canonical JSON: keys sorted at every level, compact separators (Agent path only).
const canon = (o: any): string =>
  Array.isArray(o) ? "[" + o.map(canon).join(",") + "]"
  : o && typeof o === "object" ? "{" + Object.keys(o).sort().map(k => JSON.stringify(k) + ":" + canon(o[k])).join(",") + "}"
  : JSON.stringify(o);

function eip712Digest(action: any, nonce: bigint): Uint8Array {
  const typeStr = TYPED[action.type];
  let struct: Uint8Array;
  if (typeStr) {          // typed path — field-level EIP-712 encoding
    for (const [k, v] of Object.entries(TYPED_DEFAULTS[action.type] ?? {}))
      if (action[k] === undefined) action[k] = v;   // fill optional fields so wire JSON matches the digest
    struct = typedStruct(typeStr, action, nonce);
  } else {                // Agent path — canonical JSON folded into an actionHash
    const actionHash = kb(cat([toUtf8Bytes(canon(action)), be8(nonce)]));
    struct = kb(cat([hs("Agent(string source,bytes32 actionHash)"), hs(SOURCE), actionHash]));
  }
  return kb(cat([Uint8Array.from([0x19, 0x01]), DOMAIN, struct]));
}

let lastNonce = 0;
const nextNonce = () => (lastNonce = Math.max(lastNonce + 1, Date.now()));   // strictly increasing

export async function signAndSend(action: any, privateKey: string) {
  const nonce = BigInt(nextNonce());
  const sig = new SigningKey(privateKey).sign(hexlify(eip712Digest(action, nonce)));
  const envelope = {
    action,
    signature: { r: sig.r, s: sig.s, v: sig.v },   // v is 27 or 28
    nonce: Number(nonce),
  };
  const resp = await fetch(`${BASE_URL}/exchange`, {
    method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(envelope),
  });
  return resp.json();
}