How OpenVPP is Exploring Realtime Energy Settlement on Arc

OpenVPP, a Circle grantee and Circle Alliance member, is an energy coordination protocol focused on distributed energy resources. The team is building consumer and enterprise payment flows on Arc testnet, combining stablecoin settlement, gas abstracted wallets, and machine to machine payments to explore how EVs, electric utilities, and grid connected devices could participate in programmable energy markets.

Here’s what OpenVPP has built so far and why the team is building on Arc.

Summary

• OpenVPP’s web app is live on Arc testnet at arc.openvpp.energy, with 450+ unique EVs onboarded.
• The team has developed a proof of concept autonomous grid balancing agent that pays $0.0001 testnet USDC every 4 seconds via Circle Nanopayments to access grid frequency and pricing data.
• OpenVPP is using Circle Wallets, gas sponsored transactions, and social login flows to simplify onboarding for non crypto native users.
• The team sees Arc as a potential settlement layer for future stablecoin based payment flows between regulated utilities, third party operators, and consumers.

The Opportunity

As distributed energy resources such as EVs, batteries, solar systems, and smart meters become more connected, the energy ecosystem increasingly depends on software driven coordination and payments.

OpenVPP is investigating how programmable payment infrastructure could better support energy programs where device activity, incentives, and settlement need to be coordinated across different participants and systems. The team is particularly interested in whether programmable payments can connect measured energy activity more directly to the financial workflows that follow, and whether doing so improves customer retention rates in demand response programs as well as eases grid congestion during peak demand seasons.

OpenVPP’s view is that enabling more dynamic energy participation will require payment infrastructure that supports:

• High frequency settlement
• Programmable payouts
• Consumer friendly onboarding
• Compliance and reporting requirements expected by enterprise counterparties

Use Cases 

OpenVPP is testing how programmable payments and connected energy devices could support new coordination models between grid operators, program operators, and end customers.

Distributed energy resources such as EVs, smart thermostats, batteries, and solar systems can provide flexibility by adjusting when they consume, store, or supply energy. OpenVPP is building infrastructure intended to connect that participation with programmable incentive and settlement workflows.

The team is focused on several potential use cases:

• Customer Programs / Demand Response: Programmable payment workflows could give program operators a more automated way to calculate and deliver eligible participant incentives based on measured participation.
• Customer Credits and Incentives: For customers with distributed energy assets such as EVs, batteries, and solar systems, OpenVPP is testing models where program participation can translate into credits or incentives.
• Energy Market Settlement: OpenVPP is investigating how measured device activity could feed into programmable reconciliation and settlement workflows between market participants.

Across these use cases, the broader goal is to test whether payments can become a more integrated part of energy coordination: connected to device activity, governed by program rules, and settled through programmable infrastructure.

Why Arc

OpenVPP selected Arc because of its focus on stablecoin utility, programmable payments, and developer experience.

Areas the team is particularly focused on include:

• Stablecoin based settlement for consumer and enterprise payment flows
• Nanopayments for machine-to-machine interactions and data access
• Wallet infrastructure that abstracts blockchain complexity from end users
• Programmable transaction flows and gas abstraction
• Infrastructure designed to support compliance oriented applications

OpenVPP’s work demonstrates how Arc can support a new class of applications where software agents, connected devices, enterprises, and consumers all participate in the same financial network. By combining stablecoin settlement, programmable payments, wallet infrastructure, and nanopayments, Arc enables developers to build systems that may be difficult to implement on traditional payment rails.

As OpenVPP continues to develop its platform, the team sees Arc as a core component of its architecture and a foundation for exploring how energy markets, connected devices, and financial infrastructure can operate together in realtime.

What OpenVPP Has Built on Arc Testnet

OpenVPP’s application is currently live on Arc testnet, where users can connect EVs and participate in different workflows.

The current implementation includes:

• ERC-1155 contracts representing EVs, charging events, and participation rights
• Circle Wallet integration to simplify wallet creation and management
• Gas sponsored transactions to reduce friction for end users
• Social login onboarding flows designed for non crypto native participants

The goal is to create an experience where users can connect a vehicle, opt into grid programs, and participate in incentive systems without needing to manage private keys or interact directly with blockchain infrastructure.

Nanopayments for Grid Coordination

OpenVPP is testing what high-frequency machine-to-machine settlement looks like in practice.

We built an autonomous grid-balancing agent modeled on the Electric Reliability Council of Texas (ERCOT) frequency response. Every four seconds it pays $0.0001 in testnet USDC over Circle Nanopayments to pull grid data - frequency, regulation, and pricing signals - runs a battery dispatch decision, and books the result against its own data costs. That's roughly 21,600 settled payments a day, each one a real onchain testnet transaction.

1. Each query is priced as a nanopayment

The per-query price is fractions of a cent because settlement is automated and inexpensive on Arc.

// server/config.ts
paymentAmountUsdc: '0.0004',
facilitatorUrl: 'https://gateway-api-testnet.circle.com',

‍
2. Seller advertises the nanopayment terms

The seller publishes supported payment requirements using Circle Gateway.

// server/services/circleGatewaySeller.service.ts
const kinds = (await this.facilitator.getSupported()).kinds.filter(
  kind => kind.network === `eip155:${this.config.chainId}` &&
    Boolean(kind.extra?.verifyingContract),
);

private mapRequirement(kind: SupportedKind) {
  return {
    scheme: kind.scheme,
    network: kind.network,
    asset: getUsdcAddress(kind),
    amount: parsePriceToAtomicUnits(this.config.paymentAmountUsdc),
    payTo: this.config.paymentRecipient,
    maxTimeoutSeconds: GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS,
    extra: { name: 'GatewayWalletBatched', version: '1', verifyingContract },
  };
}

3. Buyer signs and replays the request

The agent signs the payment payload and resends the request with the payment header.

// server/services/operatorDataInlinePayment.service.ts
const batchingOption = accepts.find(
  o => o.extra?.name === 'GatewayWalletBatched' &&
    o.extra?.version === '1',
);

const paymentPayload = await gatewayClient.createPaymentPayload(x402Version, batchingOption);

const paymentHeader = Buffer.from(
  JSON.stringify({ ...paymentPayload, resource, accepted: batchingOption }),
).toString('base64');

const settled = await settleOperatorDataInline(RESOURCE_URL, input, paymentHeader);

4. The payment is verified and settled

Only a successfully verified and settled payment unlocks the data.

// server/services/circleGatewaySeller.service.ts
const verifyResult = await this.facilitator.verify(payload, requirements);
if (!verifyResult.isValid) return reject(verifyResult.invalidReason);

const settleResult = await this.facilitator.settle(payload, requirements);
if (!settleResult.success) return reject(settleResult.errorReason);

return {
  ok: true,
  context: {
    txHash: settleResult.transaction,
    payer: settleResult.payer,
    network,
  },
};

5. Automatically maintaining gateway liquidity

The agent checks the Gateway balance before every paid query and deposits additional USDC when needed.

// server/services/circleNanopayment.service.ts
private async ensureGatewayLiquidity() {
  const balances = await this.gatewayClient.getBalances();

  if (toNumber(balances.gateway.formattedAvailable) >= requiredAmount)
    return null;

  const topUp = Math.max(
    toNumber(this.config.autoDepositAmountUsdc),
    requiredAmount
  );

  return this.gatewayClient.deposit(formatUsdcAmount(topUp));
}

6. Metering every nanopayment into the agent P&L

Each payment updates the running cost and query count.

// server/services/walletSimulator.service.ts
const payment = await this.circleNanopaymentService.queryOperatorData(input);

return {
  ...economics,
  queriesPaid: economics.queriesPaid + 1,
  dataCostsUsdc: round(economics.dataCostsUsdc + payment.amountUsdc, 4),
  gatewayDepositsUsdc: round(payment.gatewayAvailableBalanceUsdc, 4),
  latestBatchTx: payment.txHash,
  latestPaymentStatus: 'SETTLED',
};

That's the layer OpenVPP is building toward - devices that don't just talk to each other, but transact with each other.

Conclusion

OpenVPP's testnet work on Arc is an early look at what realtime energy settlement can look like once payments move at the same speed as the devices generating them. A grid balancing agent settling many nanopayments a day, EVs onboarding through social login instead of seed phrases, the potential for faster incentive payout workflows: these aren't isolated experiments so much as pieces of the same underlying shift, moving energy markets from batch reconciliation to programmable, machine speed settlement.

The next phase of this work focuses on expanding the device set beyond EVs to batteries and smart thermostats, deepening the compliance and reporting tooling utility partners will need, and testing these flows with real utility and grid operator counterparties as Arc moves toward mainnet.

If you own an EV, battery, solar system, or smart thermostat, you can add your device to the network today and start participating in these programs as they roll out. Try the testnet app, connect your device, and see the flow firsthand at arc.openvpp.energy.

For updates on the mainnet roadmap and new grid programs as they go live, follow OpenVPP on Twitter/X and LinkedIn, or visit openvpp.energy.

OpenVPP is a Circle Grant Recipient.