Building on VeChain: Developer Resources, Pro Tips & Tools

A practical guide for builders across the Web3-verse looking to get started with applications on VeChainThor.

Whether you’re porting a Solidity project from Ethereum, spinning up your first blockchain application, or architecting enterprise-grade infrastructure, VeChainThor gives you battle-tested foundations that have been running at scale since 2018 — with 100% uptime, over 530 million transactions processed, and more than 300 enterprise applications deployed.

This guide is your orientation. It covers where everything lives, the core concepts you’ll use on day one, the tooling that will accelerate your workflow, and the best practices that separate a working prototype from a production-ready application.

Who This Guide Is For

This resource is designed for Web2 and Web3 engineers, solution partners, hackathon teams, and technical product managers. Whether you’re an experienced VeChain developer or exploring this EVM-compatible blockchain for the first time, you’ll find familiar Solidity patterns alongside VeChain-specific capabilities that solve real problems Ethereum can’t. If you’re new to blockchain development entirely, VeChain’s tooling is specifically designed to flatten that learning curve.

1. Orientation: Where Everything Lives

Before writing a single line of code, get familiar with the landscape. VeChain’s developer ecosystem is organised around a central documentation hub with purpose-built tools branching from it.

The Developer Resources Hub

Your starting point is docs.vechain.org/developer-resources. This is the single source of truth for concepts, how-to guides, SDK references, and example dApps. It’s structured around the tasks you’ll actually perform: reading data, writing data, deploying contracts, and connecting front-ends.

From here, you’ll find direct paths to:

• Core concepts — transactions, accounts, blocks, and the two-token model
• How to build — step-by-step guides for reading and writing on-chain data
• SDKs and providers — the VeChain SDK, Thor Client, and integration patterns
• Frameworks and IDEs — Hardhat plugin, Remix integration, and development environments
• EVM compatibility — detailed RPC method breakdowns and migration guidance

Bookmark it. You’ll come back often.

2. Core Concepts You’ll Use on Day One

VeChainThor is EVM-compatible, but it was never a copy-paste of Ethereum. The protocol made deliberate engineering decisions to solve problems Ethereum couldn’t — particularly around transaction costs, enterprise scalability, and user onboarding. Understanding these differences early will save you significant debugging time later.

The Two-Token Model: VET and VTHO

Unlike single-token blockchains where gas costs fluctuate with market speculation, VeChainThor separates value transfer from transaction execution.

VET is the native token — used for value transfer, staking, and governance. VTHO (VeThor) is the gas token — consumed when executing transactions and smart contract calls. VTHO is generated by staking VET and, following the Renaissance upgrades, is distributed to node holders who stake via the StarGate platform.

This separation is a deliberate design choice. It decouples application costs from token market volatility, giving developers and enterprises predictable, stable transaction pricing. For builders coming from Ethereum, think of it this way: your users’ transaction costs don’t spike because of an NFT mint happening elsewhere on the network.

EVM Compatibility: What Works, What Differs

VeChainThor runs a fully compatible EVM, meaning your Solidity contracts deploy and execute as expected. The Galactica upgrade (Phase 1 of the Renaissance roadmap, live on mainnet) brought Shanghai EVM alignment and EIP-1559-inspired dynamic fee mechanics.

Where things diverge is at the interface layer. VeChainThor was originally built around Thor’s RESTful API rather than Ethereum’s JSON-RPC standard. This matters when you’re choosing how to interact with the chain.

Thor REST API — The native interface. Offers full access to VeChainThor-specific features including multi-clause transactions, fee delegation, and block subscription. Use this when you need the complete feature set.

JSON-RPC via SDK RPC Proxy — A compatibility bridge (@vechain/sdk-rpc-proxy) that translates Ethereum JSON-RPC calls into Thor REST calls. This lets you use familiar tools like Remix, MetaMask, and standard ethers.js providers with VeChainThor. Use this when porting existing Ethereum tooling or when your team is most comfortable with the JSON-RPC interface.

How to choose: If you’re building a VeChain-native application and want access to features like multi-clause transactions, start with the Thor REST API via the SDK’s ThorClient. If you’re migrating an existing Ethereum project or want the fastest path to a working prototype using familiar tooling, use the RPC Proxy. Both are production-ready.

A key nuance to be aware of: eth_getTransactionCount via the RPC Proxy returns a random value rather than the actual transaction count. This is a known divergence from Ethereum behaviour — consult the RPC Methods Detailed Breakdown for the full list of method-level differences.

Multi-Clause Transactions: Do More with Less

This is one of VeChainThor’s most powerful features and one that has no direct equivalent on Ethereum. A single transaction can contain multiple clauses — each clause being an independent operation (a token transfer, a contract call, a deployment) bundled into one atomic transaction.

Why this matters in practice:

• Batch operations — transfer tokens to 50 addresses in a single transaction
• Atomic workflows — approve a token and execute a swap in one transaction, with guaranteed atomicity
• Gas efficiency — one base fee covers multiple operations, reducing total cost versus sending individual transactions

The base transaction fee is 5,000 gas, with each additional clause costing 16,000 gas. This is substantially cheaper than submitting each operation as a separate transaction on Ethereum.

VIP-191 Fee Delegation: Remove the Gas Barrier

If there’s one feature that makes VeChainThor uniquely suited to consumer-facing applications, it’s fee delegation. VIP-191 (the Designated Gas Payer protocol) allows a third party — typically the application developer or a sponsor — to pay the VTHO gas fees on behalf of end users.

This means your users never need to hold cryptocurrency to interact with your application. They don’t need to understand gas. They don’t need to acquire tokens before they can start using what you’ve built. The blockchain becomes invisible infrastructure — exactly as it should be for mainstream adoption.

How it works: VIP-191 uses a co-signature model. The user signs the transaction as normal. A designated gas payer then co-signs, agreeing to cover the fees. Both signatures are included in the transaction, and the protocol deducts VTHO from the gas payer’s balance instead of the user’s.

Practical implementation patterns:

• Backend delegation service — Deploy a web service that receives unsigned transactions, validates them against your business rules, and returns co-signed transactions with gas covered. This is the most common production pattern, specified in VIP-201.
• Event-based sponsorship — Cover gas for specific actions (first 100 transactions for new users, promotional campaigns, onboarding flows)
• Enterprise sponsorship — Businesses sponsor all transaction fees for their application users, making the blockchain layer entirely invisible

The VeChain Docs provide a three-part integration tutorial that walks through the full implementation. The VeChain Kit documentation also covers fee delegation patterns for modern dApp architectures.

3. Tooling & SDKs

VeChain’s tooling has been consolidated around the official VeChain SDK — a unified development experience that replaces the earlier fragmented ecosystem of standalone packages. Here’s what to use and when.

VeChain SDK (@vechain/sdk-*)

The VeChain SDK is the primary development toolkit. It’s a TypeScript monorepo containing everything you need for end-to-end blockchain development.

Key packages:

@vechain/sdk-core - Cryptography, transaction building, encoding/decoding

@vechain/sdk-network - Network interactions, provider management, blockchain queries

@vechain/sdk-rpc-proxy - Thor REST → JSON-RPC bridge for Ethereum tool compatibility

@vechain/sdk-hardhat-plugin - Hardhat integration for Solidity workflows

The SDK’s ThorClient is your primary interface for direct blockchain interaction — querying accounts, reading transactions, simulating contract calls, and estimating gas. Refer to the Thor Client documentation for the full API surface.

Hardhat Plugin

If Hardhat is your preferred development environment (and for most Solidity developers, it is), the @vechain/sdk-hardhat-plugin gives you seamless integration. Compile, test, and deploy contracts to VeChainThor using the same workflows you’d use for Ethereum — with access to VeChain-specific features underneath.

The plugin bridges Hardhat’s standard Ethereum tooling with VeChainThor’s unique capabilities. Configure your hardhat.config.js with VeChain network settings, and your existing Solidity workflow largely stays the same.

Getting started:

npm install: @vechain/sdk-hardhat-plugin

The SDK repository includes a complete Hardhat example application under the ./apps directory.

Connex: Browser-Based dApp Interface

Connex is the standard interface for connecting browser-based dApps with VeChainThor and user wallets. If you’re building a front-end that needs to interact with the blockchain through the user’s wallet (VeWorld, Sync2), Connex is the bridge.

Connex provides APIs for:

• Reading blockchain state (accounts, blocks, transactions)
• Subscribing to new blocks via connex.thor.ticker
• Interacting with smart contracts through connex.thor.account
• Requesting transaction signatures from the user’s wallet

For modern dApp development, the VeChain DApp Kit (vechain-dapp-kit) provides a higher-level TypeScript library that facilitates wallet interaction with VeWorld and Sync2, handling connection management and transaction signing with a cleaner developer experience.

Using ethers.js with VeChain

If your team is deeply invested in the ethers.js ecosystem, you can interact with VeChainThor through the SDK RPC Proxy. Start the proxy pointed at a VeChainThor node, and use standard ethers.js providers against the proxy endpoint. This is particularly useful when migrating existing Ethereum front-ends.

Note that VeChainThor’s chain IDs differ from Ethereum: Mainnet is 100009 and Testnet is 100010. Configure your providers accordingly.

4. Networks, Explorer & Faucet

Networks

Production deployment: https://mainnet.vechain.org

Testnet

Development and testing: https://testnet.vechain.org

Solo

Local development node: localhost (via Docker)

The testnet mirrors mainnet functionality and is the recommended environment for all development and integration testing. Testnet assets carry no monetary value — experiment freely.

Testnet Faucet

Need testnet VET and VTHO? The VeChain Testnet Faucet provides free tokens for development. If you have testnet VET and need to convert some to VTHO, use the Energy Station.

Explorer

The VeChain Explorer (available for both mainnet and testnet) lets you verify transactions, inspect contract deployments, view account balances, and trace execution. Use it to validate your deployments and debug transaction failures.

Insight, VeChain’s serverless explorer, offers an additional lightweight option for exploring blocks, transactions, and accounts.

5. Ship Without Code: VORJ

Not every project needs to start with a Solidity compiler. VORJ is VeChain’s no-code Web3-as-a-Service platform — a click-configure-deploy interface for creating and managing smart contracts without writing code.

What VORJ offers:

• Token creation — Deploy ERC-20 fungible tokens and ERC-721 NFT contracts through a guided interface
• OpenZeppelin foundations — All contracts are built on audited, EVM-compatible OpenZeppelin standards
• Zero transaction fees — VORJ handles gas costs during contract deployment
• Management APIs — Interact with your deployed contracts programmatically via VORJ’s API layer
• Additional tooling — Blockchain data APIs, NFT APIs, contract push notifications, and a transaction executor

VORJ is particularly valuable for prototyping, hackathons, and scenarios where a technical PM or business stakeholder needs to validate a concept before committing engineering resources. It’s also useful for non-technical teams within enterprises who need to deploy standard token contracts as part of a broader VeChain integration.

Important note: Contracts deployed through VORJ are owned by the VORJ deployment wallet by default. Transfer ownership to your own wallet for production use.

Explore the VORJ documentation and the VeChain Docs VORJ section to get started.

6. Best Practices & Production Considerations

Building on VeChainThor rewards careful attention to a few areas where the protocol’s design differs from what Ethereum developers may expect. Whether you’re handling smart contract deployment on VeChainThor for the first time or scaling an existing application, these patterns will keep you out of trouble.

Gas Estimation for Multi-Clause Transactions

Standard Ethereum eth_estimateGas calls will produce inaccurate results for multi-clause transactions — this is a VeChainThor-specific feature with no Ethereum equivalent. Use the SDK’s native gas estimation instead:

____

javascript

const gasResult = await thorClient.gas.estimateGas(

clauses,

senderAddress,

{ gasPadding: 0.2 } // 20% buffer recommended

);

____

The gasPadding option adds a safety margin to your estimate. This is particularly important for contract interactions where execution paths may vary. VM gas cannot be calculated offline — simulation against a node is required.

Gas cost breakdown for multi-clause transactions:

• Base transaction fee: 5,000 gas
• Per clause: 16,000 gas
• Per zero byte of data: 4 gas
• Per non-zero byte of data: 68 gas
• Plus VM execution gas per clause (requires simulation)

Error Handling in Multi-Clause Transactions

When a multi-clause transaction fails, identify which clause caused the failure. The transaction receipt includes per-clause execution results — inspect these individually rather than treating the transaction as a monolithic operation. A common mistake is assuming that if the transaction was mined, all clauses succeeded. Check each clause’s output and revert status.

Fee Delegation Edge Cases

When implementing VIP-191 fee delegation, ensure your gas payer service validates transactions before co-signing. Without validation, a malicious user could drain your gas payer’s VTHO balance by submitting expensive transactions. Common safeguards include:

• Whitelisting contract addresses that the gas payer will sponsor
• Setting per-user transaction rate limits
• Capping the maximum gas per sponsored transaction
• Validating transaction clauses against expected patterns

If the gas payer’s VTHO balance is insufficient at execution time, the transaction will fail — not partially execute. Build monitoring around your gas payer’s balance.

Preparing for Renaissance: Migration Considerations

The Renaissance roadmap is actively expanding VeChainThor’s compatibility surface. As the Interstellar phase (expected 2026) brings full JSON-RPC support and EVM Cancun alignment, developers should be aware of the transition path:

• Galactica (live) introduced Shanghai EVM alignment and dynamic fees via EIP-1559 mechanics. If you’re deploying contracts today, you’re already building on this foundation.
• Hayabusa (late 2025) brings the Delegated Proof-of-Stake consensus migration and tokenomics changes. Existing contracts are unaffected, but applications that interact with staking or node infrastructure should monitor for API changes.
• Interstellar (2026+) will deliver full JSON-RPC compatibility, meaning the RPC Proxy will eventually become a native protocol feature rather than a translation layer. Applications currently using the RPC Proxy will benefit from improved performance and broader method support.

If you’re starting a new project today, building against the SDK’s ThorClient gives you the most future-proof foundation. If you’re using the RPC Proxy for Ethereum compatibility, your integration path only gets smoother from here.

7. Essential Resources — Documentation

VeChain Developer Hub: docs.vechain.org/developer-resources

EVM & RPC Compatibility: docs.vechain.org/…/evm-compatibility-for-developers

VIP-191 Fee Delegation: docs.vechain.org/…/vip-191-designated-gas-payer

SDK Reference: docs.vechain.org/…/sdk

Thor Client API: docs.vechain.org/…/thor-client

VeChain Kit (dApp Kit): docs.vechainkit.vechain.org

Transaction Calculation: docs.vechain.org/…/transaction-calculation

Tools & Platforms

VeChain SDK (GitHub): github.com/vechain/vechain-sdk-js

Hardhat Plugin: npm: @vechain/sdk-hardhat-plugin

RPC Proxy: npm: @vechain/sdk-rpc-proxy

Testnet Explorer: explore-testnet.vechain.org

Testnet Faucet: faucet.vecha.in

VORJ (No-Code Platform): vorj.io

VORJ Documentation: docs.vorj.app/guides

Specifications

VIP-191 Specification: github.com/vechain/VIPs/…/VIP-191.md

VIP-201 Fee Delegation Protocol: github.com/vechain/VIPs/…/VIP-201.md

Community Gas Estimation: github.com/vechain-energy/gas

Gas Fee Walkthrough: learn.vechain.energy/…/Calculate-Gas-Fees

What to Do Next

The fastest path from reading to building:

1. Install the Hardhat plugin and VeChain SDK — npm install @vechain/sdk-hardhat-plugin — and configure your hardhat.config.js for the VeChainThor testnet.
2. Grab testnet tokens from the faucet to fund your development wallet.
3. Deploy a test contract — use one of the example projects from the SDK repository as your starting point.
4. Verify on the Explorer — confirm your deployment at explore-testnet.vechain.org.

Once your contract is live on testnet, the next step is adding VIP-191 fee delegation — so your users never see a gas prompt — and wiring it to a front-end via Connex or the VeChain DApp Kit. We’ll cover that end-to-end workflow in the follow-up guide.

Et, voila! Enough to get you started building on the world’s leading blockchain for real-world utility. Share updates with us as you go, and let’s build the future of Web3, together!

VeChain has been building for utility since 2015 — proven infrastructure, real applications, and a growing ecosystem of developers shipping products that people actually use. The tools are ready. Start building.

Building on VeChain: Developer Resources, Pro Tips & Tools was originally published in VeChain on Medium, where people are continuing the conversation by highlighting and responding to this story.