Architecture

Technical architecture and design principles of the Molt402 transaction infrastructure.

System overview

Molt402 implements a layered architecture that separates concerns between agent intent, transaction construction, and protocol execution.

┌─────────────────────────────────────────────────────────────┐
│                 Application Layer                           │
│         (Agent frameworks, custom applications)             │
└────────────────────────┬────────────────────────────────────┘
                         │
                         │ SDK / REST API
                         │
┌────────────────────────▼────────────────────────────────────┐
│                   Molt402 Engine                            │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │   Intent     │  │  Transaction │  │  Execution   │     │
│  │   Parser     │→ │   Builder    │→ │   Monitor    │     │
│  └──────────────┘  └──────────────┘  └──────────────┘     │
│                                                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │     Gas      │  │    State     │  │   Security   │     │
│  │  Optimizer   │  │   Manager    │  │   Validator  │     │
│  └──────────────┘  └──────────────┘  └──────────────┘     │
└────────────────────────┬────────────────────────────────────┘
                         │
                         │ Protocol Adapter
                         │
┌────────────────────────▼────────────────────────────────────┐
│                    x402 Protocol                            │
│              (Blockchain network layer)                     │
└─────────────────────────────────────────────────────────────┘

Core components

Intent parser

Translates high-level instructions into structured transaction intents.

Input formats:

• Natural language: "Transfer 50 USDC to 0xabcd...ef01"

• Structured JSON: { action: "transfer", asset: "USDC", amount: "50", recipient: "0xabcd..." }

Processing pipeline:

1. Tokenization: Extract entities (amounts, addresses, assets)

2. Semantic analysis: Map tokens to protocol operations

3. Validation: Verify intent completeness and coherence

4. Normalization: Convert to standardized internal format

Output: Validated transaction intent object

{
  action: "transfer",
  params: {
    asset: "0x1234...",  // Resolved contract address
    amount: "50000000",  // Atomic units
    recipient: "0xabcd...",
    decimals: 6
  },
  metadata: {
    urgency: "standard",
    policies: ["auto_approve_small_transfers"]
  }
}

Transaction builder

Constructs protocol-compliant transactions from parsed intents.

Responsibilities:

• ABI encoding for contract calls

• Parameter validation and type checking

• Calldata optimization

• Multi-step workflow orchestration

Transaction types:

Simple transfer:

{
  from: "0xaaaa...",
  to: "0xbbbb...",
  value: "1000000000000000000",  // 1 ETH
  data: "0x",
  nonce: 42,
  gasLimit: "21000",
  maxFeePerGas: "50000000000",
  maxPriorityFeePerGas: "2000000000"
}

Contract interaction:

{
  from: "0xaaaa...",
  to: "0x1234...",  // Contract address
  value: "0",
  data: "0xa9059cbb...",  // Encoded method call
  nonce: 43,
  gasLimit: "65000",
  maxFeePerGas: "50000000000",
  maxPriorityFeePerGas: "2000000000"
}

Execution monitor

Tracks transaction lifecycle from submission to finalization.

State transitions:

┌─────────┐
│ Created │
└────┬────┘
     │
     ▼
┌─────────┐     ┌─────────┐
│ Pending │────→│ Dropped │ (timeout/replaced)
└────┬────┘     └─────────┘
     │
     ▼
┌─────────┐     ┌─────────┐
│Included │────→│ Reverted│ (contract failure)
└────┬────┘     └─────────┘
     │
     ▼
┌─────────┐
│Confirmed│
└─────────┘

Monitoring operations:

• Mempool tracking (pending state)

• Block inclusion detection

• Confirmation depth counting

• Reorg handling

• Automatic resubmission on failure

Gas optimizer

Calculates optimal gas parameters using network analysis.

Data sources:

• Last 100 blocks for base fee analysis

• Mempool pending transactions for priority fees

• Historical confirmation times

Prediction models:

EIP-1559 base fee:

baseFee[n+1] = baseFee[n] * (1 + (gasUsed - gasTarget) / gasTarget / 8)

Exponential weighted moving average:

EWMA[n] = α * baseFee[n] + (1 - α) * EWMA[n-1]

Priority fee percentiles:

Instant:  95th percentile
Fast:     75th percentile
Standard: 50th percentile
Economy:  25th percentile

State manager

Maintains consistent view of transaction state across asynchronous operations.

State storage:

interface TransactionState {
  txHash: string
  nonce: number
  from: string
  to: string
  value: string
  data: string
  status: 'pending' | 'included' | 'confirmed' | 'failed'
  blockNumber?: number
  blockHash?: string
  gasUsed?: string
  confirmations: number
  createdAt: number
  updatedAt: number
}

Nonce management:

• Pessimistic locking: Reserve nonce before transaction construction

• Sequential allocation: Ensure no gaps in nonce sequence

• Recovery: Handle dropped transactions and nonce reuse

Concurrency handling:

// Acquire nonce lock
const nonce = await stateManager.acquireNonce(address)

try {
  // Build and submit transaction
  const tx = await buildTransaction({ nonce })
  const txHash = await submitTransaction(tx)

  // Mark nonce as used
  await stateManager.commitNonce(address, nonce, txHash)
} catch (error) {
  // Release nonce on failure
  await stateManager.releaseNonce(address, nonce)
}

Security validator

Validates transactions before submission to prevent failures and exploits.

Validation checks:

Balance verification:

const required = transaction.value + (transaction.gasLimit * transaction.maxFeePerGas)
const available = await getBalance(transaction.from)

if (available < required) {
  throw new Error("Insufficient funds")
}

Allowance checking:

if (transaction.to === erc20Contract) {
  const allowance = await getAllowance(owner, spender)
  if (allowance < amount) {
    throw new Error("Insufficient allowance")
  }
}

Simulation:

const result = await eth_call({
  from: transaction.from,
  to: transaction.to,
  value: transaction.value,
  data: transaction.data
})

if (result.error) {
  throw new Error(`Simulation failed: ${result.error.reason}`)
}

Policy evaluation:

const matchedPolicy = evaluatePolicies(transaction, policyConfig)

if (matchedPolicy.action === 'reject') {
  throw new Error(`Rejected by policy: ${matchedPolicy.name}`)
} else if (matchedPolicy.action === 'require_human_approval') {
  await requestApproval(transaction, matchedPolicy)
}

Protocol adapter

Standardized interface for blockchain protocol integration.

Adapter interface

interface ProtocolAdapter {
  // Transaction operations
  buildTransaction(intent: Intent): Promise<UnsignedTransaction>
  signTransaction(tx: UnsignedTransaction, wallet: Wallet): Promise<SignedTransaction>
  submitTransaction(tx: SignedTransaction): Promise<TransactionHash>
  estimateGas(tx: UnsignedTransaction): Promise<string>

  // State queries
  getBalance(address: string, asset?: string): Promise<Balance>
  getNonce(address: string): Promise<number>
  getTransactionStatus(txHash: string): Promise<TransactionStatus>
  getBlock(blockNumber: number): Promise<Block>

  // Network information
  getChainId(): Promise<number>
  getGasPrice(): Promise<GasPrice>
  getFeeHistory(blockCount: number): Promise<FeeHistory>
}

x402 adapter implementation

class X402Adapter implements ProtocolAdapter {
  private provider: JsonRpcProvider

  constructor(config: X402Config) {
    this.provider = new JsonRpcProvider(config.rpcUrl)
  }

  async buildTransaction(intent: Intent): Promise<UnsignedTransaction> {
    // Map intent to x402-specific transaction format
    const tx: UnsignedTransaction = {
      from: intent.from,
      to: intent.params.recipient,
      value: intent.params.amount,
      data: intent.params.data || "0x",
      nonce: await this.getNonce(intent.from),
      chainId: await this.getChainId(),
      type: 2  // EIP-1559
    }

    // Estimate gas
    tx.gasLimit = await this.estimateGas(tx)

    // Calculate gas prices
    const gasPrice = await this.getGasPrice()
    tx.maxFeePerGas = gasPrice.maxFeePerGas
    tx.maxPriorityFeePerGas = gasPrice.maxPriorityFeePerGas

    return tx
  }

  async submitTransaction(tx: SignedTransaction): Promise<string> {
    const response = await this.provider.send('eth_sendRawTransaction', [tx.serialized])
    return response
  }

  // ... other methods
}

Data flow

Transaction execution flow

1. Intent Reception
   └─→ Parse natural language or structured input
       └─→ Validate intent structure
           └─→ Resolve asset addresses

2. Policy Evaluation
   └─→ Match transaction against policies
       └─→ Determine action (auto_approve, require_approval, reject)
           └─→ Send notifications if needed

3. Transaction Construction
   └─→ Acquire nonce lock
       └─→ Build unsigned transaction
           └─→ Estimate gas limit
               └─→ Calculate gas prices

4. Security Validation
   └─→ Verify balance sufficiency
       └─→ Check ERC-20 allowances
           └─→ Simulate transaction
               └─→ Validate policy compliance

5. Signing
   └─→ Sign transaction with wallet
       └─→ Generate transaction hash

6. Submission
   └─→ Submit to network
       └─→ Mark nonce as used
           └─→ Initialize monitoring

7. Monitoring
   └─→ Track mempool status
       └─→ Detect block inclusion
           └─→ Count confirmations
               └─→ Update state
                   └─→ Emit completion event

State synchronization

┌─────────────────┐
│  Molt402 Engine │
│                 │
│  ┌───────────┐  │     ┌──────────────┐
│  │   State   │◄─┼─────┤ Block Events │
│  │  Manager  │  │     └──────────────┘
│  └─────┬─────┘  │
│        │        │
│        ▼        │
│  ┌───────────┐  │     ┌──────────────┐
│  │ Postgres  │◄─┼─────┤ Transaction  │
│  │ Database  │  │     │  Receipts    │
│  └───────────┘  │     └──────────────┘
│                 │
│  ┌───────────┐  │     ┌──────────────┐
│  │   Redis   │◄─┼─────┤   Mempool    │
│  │   Cache   │  │     │   Updates    │
│  └───────────┘  │     └──────────────┘
└─────────────────┘

Scalability

Horizontal scaling

Multiple Molt402 instances can run concurrently:

┌──────────┐     ┌──────────┐     ┌──────────┐
│ Engine 1 │     │ Engine 2 │     │ Engine 3 │
└────┬─────┘     └────┬─────┘     └────┬─────┘
     │                │                │
     └────────┬───────┴────────┬───────┘
              │                │
         ┌────▼─────┐    ┌────▼─────┐
         │PostgreSQL│    │  Redis   │
         │(Shared)  │    │ (Shared) │
         └──────────┘    └──────────┘

Coordination:

• Distributed nonce locks via Redis

• Shared transaction state in PostgreSQL

• Leader election for monitoring tasks

Performance characteristics

Latency targets:

• Intent validation: <100ms

• Transaction construction: <200ms

• Simulation: <500ms

• Submission to network: <1000ms

• End-to-end (standard priority): <60s

Throughput:

• Sequential execution: 30-50 tx/minute

• Parallel execution: 200-300 tx/minute

• Batch operations: 1000+ recipients/batch

Security architecture

Non-custodial design

┌──────────────────────────────────────┐
│      Agent Infrastructure            │
│  ┌────────────────────────────────┐  │
│  │       Private Keys             │  │
│  │  (Never leave this boundary)   │  │
│  └──────────────┬─────────────────┘  │
│                 │                     │
│                 ▼                     │
│  ┌────────────────────────────────┐  │
│  │    Transaction Signing         │  │
│  │  (Client-side only)            │  │
│  └──────────────┬─────────────────┘  │
│                 │                     │
└─────────────────┼─────────────────────┘
                  │ Signed Transaction
                  ▼
┌──────────────────────────────────────┐
│       Molt402 Engine                 │
│  (Receives only signed transactions) │
│  (Never has access to private keys)  │
└──────────────────────────────────────┘

Defense in depth

Layer 1: Input validation

• Intent structure validation

• Parameter type checking

• Address format verification

Layer 2: Policy enforcement

• Declarative approval rules

• Spending limits

• Rate limiting

Layer 3: Simulation

• Pre-flight execution

• Balance verification

• Reversion detection

Layer 4: Monitoring

• Anomaly detection

• Alert thresholds

• Audit logging

Technology stack

Core infrastructure

Runtime: Node.js 20 LTS Language: TypeScript 5.3+ Protocol library: ethers.js v6

Database: PostgreSQL 15 Time-series: TimescaleDB extension Cache: Redis 7

Queue: BullMQ for async jobs Logging: Winston with JSON format Metrics: Prometheus

Agent integration

SDK: TypeScript/JavaScript (@molt402/sdk) Python bindings: molt402-python MCP server: Model Context Protocol support REST API: HTTP/2 with OpenAPI spec

Deployment

Container: Docker Orchestration: Kubernetes Service mesh: Istio (optional) Monitoring: Grafana + Prometheus Alerting: PagerDuty integration

Next steps

• API Reference: Complete SDK documentation

• Security: Security model and best practices

• Guides: Implementation tutorials

Support

Questions about architecture?

• Documentation: docs.molt402.dev

• GitHub: github.com/molt402

• Discord: discord.gg/molt402

• Email: [email protected]