B2B Integration
API Reference

// Step A: Retail capture (your domain — happens BEFORE ExergyNet)
retail_price = estimate.wholesale_usdc * YOUR_MARKUP_MULTIPLIER
charge_user(retail_price)  // Stripe, Web3 checkout — to YOUR treasury
// $23.75 profit stays in your treasury

// Step B: Wholesale escrow (ExergyNet domain)
await client.openJob(
    job_id_bytes,
    sha256_hash_bytes,
    estimate.wholesale_micro_usdc   // ONLY the wholesale amount
)
// $1.25 locked in LNES-04 escrow

// Step C: Tri-partite settlement (automatic)
// Siphon Daemon sees verified proof on L0 and triggers settleExergy()
// 30% ($0.37) → Prover's payment_address (electricity coverage)
// 70% ($0.88) → EDT Architect Vault (architect tax)

import { ExergyNetClient } from "@exergynet/agent-sdk";
import fs from "fs";

// ── 1. Initialize SDK with your surplus agent wallet ──
const client = new ExergyNetClient({
  rpcUrl: "https://sepolia.base.org",
  contractAddress: "0x3241941beBE7D7f0c42097D8646DF50992B272FB",
  surplusAgentKey: process.env.MD_SURPLUS_AGENT_KEY,
  baseUrl: "https://explorer-api.exergynet.org",
});

async function runSimulation(filePath, simulationType) {
  // ── 2. Get wholesale cost estimate ──
  const fileBuffer = fs.readFileSync(filePath);
  const fileStat   = fs.statSync(filePath);

  const estimate = await fetch("https://explorer-api.exergynet.org/api/v1/estimate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      simulation_type: simulationType,
      blueprint_data: { file_size_bytes: fileStat.size, molecular_weight: 820, atom_count: 90 },
    }),
  }).then(r => r.json());

  // ── 3. Upload compound file ──
  const formData = new FormData();
  formData.append("file", new Blob([fileBuffer]), "compound.sdf");
  const upload = await fetch("https://explorer-api.exergynet.org/api/v1/compute/upload",
    { method: "POST", body: formData }).then(r => r.json());

  // ── 4. Lock wholesale toll in escrow ──
  const signature = await client.openJob(
    hexToBytes(upload.blueprint_id),
    hexToBytes(upload.sha256_hash),
    estimate.wholesale_usdc_micro_units
  );

  // ── 5. Poll for ZK-STARK proof ──
  const result = await pollForProof(upload.blueprint_id);
  console.log(`Proof: ${result.proof_hash}`);
  return result;
}

async function pollForProof(jobId, maxAttempts = 60, intervalMs = 15000) {
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(
      `https://explorer-api.exergynet.org/api/l0/transactions?job_id=${jobId}`
    ).then(r => r.json());
    if (res.status === "ZK-STARK VERIFIED") return res;
    if (res.status === "FAILED") throw new Error(`Job failed: ${res.error}`);
    await new Promise(r => setTimeout(r, intervalMs));
  }
  throw new Error("Proof timeout after 15 minutes");
}

import time, hashlib, os
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

def sign_request(body_json: str, private_key_hex: str) -> dict:
    nonce = str(int(time.time()))
    body_hash = hashlib.sha256((nonce + body_json).encode()).hexdigest()
    key_bytes = bytes.fromhex(private_key_hex.replace("0x", ""))
    private_key = Ed25519PrivateKey.from_private_bytes(key_bytes)
    signature = "0x" + private_key.sign(body_hash.encode()).hex()
    return {
        "X-Exergy-Wallet": os.environ["MD_SURPLUS_AGENT_WALLET"],
        "X-Exergy-Sig": signature,
        "X-Exergy-Nonce": nonce,
        "Content-Type": "application/json",
    }

npm install @exergynet/agent-sdk

const signature: string = await client.openJob(
  jobIdBytes:  Uint8Array,  // 32-byte job identifier
  sha256Bytes: Uint8Array,  // SHA-256 hash of the uploaded file
  microUsdc:   number,     // from /estimate endpoint
);
// Returns: Base L2 transaction signature
// Effect:  Locks USDC in LNES-04 escrow
// Event:   JobOpened emitted → broadcast to prover swarm

// LNES-04 (Base Sepolia testnet): 0x3241941beBE7D7f0c42097D8646DF50992B272FB

function settleExergy(
    bytes32 jobId,
    address proverPaymentAddress,
    bytes32 proofHash
) external onlySiphonDaemon {
    uint256 escrow = escrows[jobId];
    uint256 proverYield = (escrow * 30) / 100;  // 30% → prover
    USDC.transfer(proverPaymentAddress, proverYield);
    USDC.transfer(EDT_VAULT, escrow - proverYield); // 70% → architect vault
    emit ExergySettled(jobId, proverPaymentAddress, proverYield);
}

# ExergyNet Prover Configuration — DO NOT commit to version control

MINER_ID=Node_YOURNAME_01
PAYMENT_ADDRESS=0xYOUR_EVM_WALLET   # Base L2 wallet for 30% USDC yield
PROVER_PRIVATE_KEY=0xYOUR_ED25519_PRIVATE_KEY
EXERGYNET_L0_URL=https://explorer-api.exergynet.org
POLL_INTERVAL_SECONDS=30
MAX_CONCURRENT_JOBS=2

git clone https://github.com/exergynet/moleculogic-prover
cd moleculogic-prover
cp .env.example .env   # edit with your wallet
pip install -r requirements.txt
python3 moleculogic_prover.py

# 1. Export .pdb from alphafoldserver.com
# 2. Upload to Metaldrug / ExergyNet
upload = requests.post(
    "https://platform.metaldrug.com/api/v1/compute/upload",
    files={"file": open("TP53_alphafold.pdb", "rb")},
)
blueprint_id = upload.json()["blueprint_id"]

# 3. Analyze binding pocket + contradiction check
analysis = requests.post(
    "https://platform.metaldrug.com/api/v1/alphafold/analyze",
    json={"blueprint_id": blueprint_id, "run_admet": True,
          "candidate_smiles": "CC1=CC=C(C=C1)S(=O)(=O)N"}
)
viable = analysis.json()["contradictions"]["viable"]

if viable:
    await client.openJob(job_id, sha256, micro_usdc)
else:
    print(analysis.json()["contradictions"]["contradiction_flags"])