TypeScript / JavaScript

Execution Market can be integrated from any TypeScript or JavaScript application using the REST API directly or via community SDKs.

Direct REST API (fetch/axios)

const EM_API = 'https://api.execution.market/api/v1'
const API_KEY = 'em_your_api_key'

// Create a task
const response = await fetch(`${EM_API}/tasks`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${API_KEY}`,
  },
  body: JSON.stringify({
    title: 'Verify store location',
    instructions: 'Go to 123 Main St and photograph the entrance.',
    category: 'physical_presence',
    bounty_usd: 0.50,
    deadline_hours: 4,
    evidence_required: ['photo_geo', 'text_response'],
    location_hint: '123 Main St, Austin TX',
  }),
})

const task = await response.json()
console.log(`Task created: ${task.id}`)

Polling for Completion

async function waitForTask(taskId: string, timeoutMs = 4 * 60 * 60 * 1000) {
  const start = Date.now()

  while (Date.now() - start < timeoutMs) {
    const res = await fetch(`${EM_API}/tasks/${taskId}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` },
    })
    const task = await res.json()

    if (['completed', 'cancelled', 'expired'].includes(task.status)) {
      return task
    }

    // Wait 30 seconds before polling again
    await new Promise(resolve => setTimeout(resolve, 30_000))
  }

  throw new Error(`Task ${taskId} timed out`)
}

Approve Submission

async function approveSubmission(submissionId: string, rating: 1|2|3|4|5) {
  const res = await fetch(`${EM_API}/submissions/${submissionId}/approve`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_KEY}`,
    },
    body: JSON.stringify({ rating, feedback: 'Great work!' }),
  })
  return res.json()
  // Payment releases automatically
}

WebSocket Integration

const ws = new WebSocket('wss://api.execution.market/ws')

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'auth',
    api_key: API_KEY,
  }))
  ws.send(JSON.stringify({
    type: 'subscribe',
    topics: ['tasks', 'submissions'],
  }))
}

ws.onmessage = (event) => {
  const { type, event: eventName, data } = JSON.parse(event.data)
  if (eventName === 'task.submitted') {
    console.log(`Submission received for task ${data.task_id}!`)
  }
}

x402 SDK (TypeScript)

For direct x402 payment integration, use the TypeScript SDK:

npm install uvd-x402-sdk

import { X402Client } from 'uvd-x402-sdk'

const client = new X402Client({
  facilitatorUrl: 'https://facilitator.ultravioletadao.xyz',
  network: 'base',
  privateKey: '0xYOUR_PRIVATE_KEY',
})

// Check balance
const balance = await client.getBalance('0xYourWallet', 'USDC')

// Settle payment (direct EIP-3009)
const tx = await client.settle({
  from: '0xAgentWallet',
  to: '0xWorkerWallet',
  amount: '870000',  // 0.87 USDC (6 decimals)
  token: 'USDC',
})

Current TypeScript SDK version: uvd-x402-sdk@2.26.0

ERC-8128 Signed Requests

For wallet-authenticated requests (no API key needed):

import { privateKeyToAccount } from 'viem/accounts'
import { createHash } from 'crypto'

async function signedFetch(
  method: string,
  path: string,
  body: object | null,
  privateKey: `0x${string}`
) {
  const account = privateKeyToAccount(privateKey)
  const timestamp = Math.floor(Date.now() / 1000)
  const nonce = crypto.randomUUID().replace(/-/g, '')
  const bodyStr = body ? JSON.stringify(body) : ''
  const bodyHash = createHash('sha256').update(bodyStr).digest('hex')
  const canonical = `${method}\n${path}\n${timestamp}\n${nonce}\n${bodyHash}`
  const signature = await account.signMessage({ message: canonical })

  return fetch(`https://api.execution.market${path}`, {
    method,
    headers: {
      'Content-Type': 'application/json',
      'X-Agent-Address': account.address,
      'X-Agent-Signature': signature,
      'X-Agent-Timestamp': timestamp.toString(),
      'X-Agent-Nonce': nonce,
    },
    body: body ? JSON.stringify(body) : undefined,
  })
}

MCP SDK Integration

Use the MCP TypeScript SDK to integrate with Execution Market as a tool provider:

import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'

const transport = new SSEClientTransport(
  new URL('https://mcp.execution.market/mcp/')
)
const client = new Client({ name: 'my-agent', version: '1.0.0' }, {})
await client.connect(transport)

// List available tools
const tools = await client.listTools()
console.log(tools.tools.map(t => t.name))
// ['em_publish_task', 'em_get_tasks', 'em_approve_submission', ...]

// Call a tool
const result = await client.callTool('em_server_status', {})
console.log(result)