Documentation
Docs2. Quick Start

2. Quick Start

2.1 Adding Kortana to MetaMask

Kortana provides seamless compatibility with EIP-155, EIP-3085, and standard Web3 wallet tooling. Developers and end-users can connect MetaMask, Coinbase Wallet, or Rabby directly to the Kortana network without installing custom browser extensions or proprietary software. The RPC interface adheres to the standard Ethereum JSON-RPC specification, translating Ethereum-style remote procedure calls directly into the underlying dual-engine state trie.

To add the Kortana Testnet to your MetaMask wallet automatically via dApp integration or manually through the network settings modal, utilize the following EIP-3085 wallet_addEthereumChain payload:

{
  "chainId": "0x11B3F",
  "chainName": "Kortana Testnet",
  "nativeCurrency": { "name": "Dinar", "symbol": "DNR", "decimals": 18 },
  "rpcUrls": ["https://poseidon-rpc.testnet.kortana.xyz/"],
  "blockExplorerUrls": ["https://explorer.testnet.kortana.xyz"]
}

(For Mainnet, use "chainId": "0x232A" / 9002 and RPC "https://zeus-rpc.mainnet.kortana.xyz/")

Once configured, your wallet can immediately sign transactions, manage native Dinar ($DNR) balances, approve ERC-20/Quorlin token allowances, and interact with deployed smart contracts across both execution environments.

2.2 First Transaction

Because Kortana implements standard secp256k1 ECDSA cryptographic signature recovery along with EIP-155 replay protection and EIP-1559 fee structures, standard Web3 JavaScript/TypeScript SDKs (including ethers.js, viem, and web3.js) function without modification. When a transaction is submitted, the node calculates intrinsic gas, recovers the sender address from the (v, r, s) signature components, verifies account balance against the maximum fee limit, and queues the transaction for block inclusion.

The following example demonstrates how to initialize a JSON-RPC provider using ethers.js v6, query the latest finalized block height, retrieve account balances, and broadcast a signed transfer of DNR across the network:

import { ethers } from "ethers";

// Connect to the Kortana Testnet JSON-RPC endpoint
const provider = new ethers.JsonRpcProvider("https://poseidon-rpc.testnet.kortana.xyz/");

// Fetch the latest finalized block number
const blockNumber = await provider.getBlockNumber();
console.log(`Current Finalized Block Height: ${blockNumber}`);

// Initialize a signer using a private key
const wallet = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);
console.log(`Connected Signer Address: ${wallet.address}`);

// Query the account balance
const balance = await provider.getBalance(wallet.address);
console.log(`Account Balance: ${ethers.formatEther(balance)} DNR`);

// Broadcast a native value transfer
const tx = await wallet.sendTransaction({
  to: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
  value: ethers.parseEther("1.0"),
});

console.log(`Transaction broadcast with Hash: ${tx.hash}`);
const receipt = await tx.wait();
console.log(`Transaction finalized in block: ${receipt.blockNumber}`);

2.3 Deploying Your First Contract (Solidity)

Solidity smart contracts compile to standard EVM bytecode and deploy onto the Kortana KEVM engine using existing developer toolchains such as Foundry, Hardhat, Truffle, or Remix. Kortana fully supports the EVM Cancun hard fork revision, meaning modern Solidity features—such as transient storage (TSTORE/TLOAD), memory copying (MCOPY), and custom errors—execute with exact byte-for-byte behavioral parity with Ethereum.

To deploy a Solidity contract using Foundry's forge, configure your RPC endpoint and broadcast the deployment transaction with your funded account key:

# Using Foundry forge to deploy a Solidity contract to Kortana Testnet
forge create --rpc-url https://poseidon-rpc.testnet.kortana.xyz/ \
  --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \
  src/MyToken.sol:MyToken \
  --constructor-args "Kortana Token" "KTN" 1000000000000000000000000

When this transaction executes, the KEVM processes the initialization bytecode, runs the contract constructor, and persists the resulting runtime bytecode to the world state trie. The contract address is derived deterministically from the deployer's address and nonce using standard Ethereum CREATE semantics.

2.4 Deploying Your First Contract (Quorlin)

Quorlin is Kortana's native, capability-secure programming language that targets the 32-register KVM machine. Unlike Solidity/EVM deployment, which requires an init-code indirection step that executes initialization logic and returns runtime bytecode, Quorlin deployment is direct and transparent. The compiled .kvm module contains the verified runtime instructions, a structured constant table, and an explicit constructor entry point.

To compile and deploy a native Quorlin contract, use the quorlinc compiler and the kortana-cli developer tool:

# 1. Compile the Quorlin source code to a KVM binary module and ABI definition
quorlinc Token.ql -o build/

# 2. Deploy the compiled KVM module using the Kortana CLI
kortana-cli tx deploy \
  --code build/Token.kvm \
  --key operator.key \
  --rpc https://poseidon-rpc.testnet.kortana.xyz/

During deployment, the node validates that the bytecode carries the mandatory 4B 56 4D 00 ("KVM\0") magic prefix, verifies that all instruction encodings conform to the 4-byte fixed-width ISA, executes the constructor method exactly once, and stores the module at the derived address in the state trie.

2.5 Using the Block Explorer

The Kortana Block Explorer provides an intuitive, real-time analytics window into the on-chain activity of the network. Because Kortana operates a dual-execution environment, the explorer backend subscribes to both standard EVM transaction logs and native KVM execution traces, providing comprehensive visibility into cross-VM calls, state mutations, and dPOH timing ticks.

Key explorer endpoints and monitoring features include:

  • Testnet Explorer: https://explorer.testnet.kortana.xyz
  • Mainnet Explorer: https://explorer.mainnet.kortana.xyz
  • Real-Time Finality Feed: Monitor the aggregation of BLS12-381 Quorum Certificates and view-change pacemakers.
  • Dual-VM Trace Inspection: Step through individual EVM opcodes or KVM 32-register state transitions to inspect contract execution and debug reverted calls.
  • dPOH Sequence Verification: Track continuous SHA-256 tick metrics, slot hash rates, and validator block proposal schedules.
Previous 1. What is Kortana?Next3. Network Information