Odyssey Gas Fee Schedule - Phase 1

This document will outline the breakdown of transaction fees (gas fees) tokenomics for all subnets within the Odyssey Chain ecosystem.

Overview

Odyssey Chain is a fork of the Avalanche Network, which uses Snowman consensus (PoS). Avalanche combines three separate blockchain networks to achieve superior scalability and functionality. The protocol operates as a frictionless payment system, cryptocurrency, and DeFi ecosystem. The three blockchains - X-chain, C-chain, and P-chain - all serve different roles in the network.

Universal Gas Fee Schedule Breakdown

Gas fees on Odyssey Chain are transacted and distributed in a unique manner, aimed at facilitating the growth of the protocol while incorporating decentralized mechanisms to foster a more decentralized ecosystem over time.

Odyssey Chain Gas Fees Starting September 1, 2023 - August 29, 2026

Odyssey Chain Gas Fees Starting September 1, 2023 - August 29, 2025

Gas Fee Algorithm

Below is the "dynamic" Odyssey Chain gas fee algorithm. As shown above, the gas fee is split between 2 time-frames to reflect 2 different project use cases. Growth Phase 1 (Validator focused to foster growth of network) Duration: Day 1 Chain deployment and up to year 3 Phase Phase 2 (Deflationary focused to foster deflationary mechanisms) Duration: Year 3 and beyond

Phase 1 (Between 1-3 years): 

var (
  orionExtraReward int = 2500
  validatorReward int = 2500
  stakingReward int = 2500
  lpReward int = 2500
  priorityReward int = 10000
)

func getPercent(amount uint64, percent int) uint64 {
  switch percent {
    case 0: 
      return uint64(0)
    case 10000: 
	return amount
    default: 
      return amount * uint64(percent) / uint64(10000)
}

consecutiveSuccesses := 0
while validating: 
  ask K random validators their preference
  if consecutiveSuccesses >= ฮฒ give response with >= ฮฑ:
   preference := response with >= ฮฑ
   decide(preference)
   orionValidators := getOrionValidators(k)
   distributePriorityFee(getPercent(priorityTipFee, priorityReward))
   distributeBaseFee(getPercent(txnFee, validatorReward))
   distributeOrionExtraFee(getPercent(txnFee, orionExtraReward), orionValidators)
   distributeStaking(getPercent(txnFee, stakingReward))
   distributeLPShare(getPercent(txnFee, lpReward))


Phase 2 (After 3 years):

var (
  orionExtraReward int = 1000
  validatorReward int = 1500
  burnShare int = 2500
  lpReward int = 2500
  stakingReward int = 2500
  priorityReward int = 10000
)

func getPercent(amount uint64, percent int) uint64 {
  switch percent {
    case 0: 
      return uint64(0)
    case 10000: 
	return amount
    default: 
      return amount * uint64(percent) / uint64(10000)
}

consecutiveSuccesses := 0
while validating: 
  ask K random validators their preference
  if consecutiveSuccesses >= ฮฒ give response with >= ฮฑ:
   preference := response with >= ฮฑ
   decide(preference)
   orionValidators := getOrionValidators(k)
   distributePriorityFee(getPercent(priorityTipFee, priorityReward))
   distributeBaseFee(getPercent(txnFee, validatorReward))
   distributeOrionExtraFee(getPercent(txnFee, orionExtraReward), orionValidators)
   distributeLPShare(getPercent(txnFee, lpReward))
   distributeStaking(getPercent(txnFee, stakingReward))
   burnFee(getPercent(txnFee, burnShare))

func distributeBaseFee(baseRewardShare uint64): 
  validators := getTransactionValidators(txn)
  for i := 0 to validators: 
    rewardAmount := calculateStakingReward(validators[i].stakingDuration, validators[i].stakingAmount, baseRewardShare)
    payFee(validators[i], rewardAmount)

func distributePriorityFee(tipRewardShare uint64): 
  validators := getTransactionValidators(txn)
  for i := 0 to validators: 
    rewardAmount := calculateStakingReward(validators[i].stakingDuration, validators[i].stakingAmount, tipRewardShare)
    payFee(validators[i], rewardAmount)

func distributeOrionExtraFee(orionExtraRewardShare uint64, orionValidators *Validators): 
  for i := 0 to orionValidators: 
    rewardAmount := calculateStakingReward(orionValidators[i].stakingDuration, orionValidators[i].stakingAmount, orionExtraRewardShare)
    payFee(orionValidators[i], rewardAmount)

func distributeStaking(stakingRewardShare uint64): 
  stakingPoolAddress := Staking.getAddress()
  transfer(stakingRewardShare, stakingPoolAddress)

func distributeLPShare(lpRewardShare uint64): 
  lpAddress := getLPAddress()
  transfer(lpRewardShare, lpAddress)

func burnFee(burnAmount uint64): 
  burn(burnAmount)

Odyssey Chain Gas Fees Starting September 1, 2025

X-Chain

The X-chain is responsible for the issuance of new digital assets. This network supports the creation of new tokens, NFTs (non-fungible tokens), stablecoins, and more.

X-Chain Transaction Fee Schedule

The P-chain serves as a platform for launching and customizing subnets, where users can create their unique rules and parameters.

C-Chain

The C-chain is designed to improve Ethereum developer onboarding. The developers describe this network as a conversion chain.

C-Chain Transaction Fee Schedule

P-Chain

P-Chain Transaction Fee Schedule

Last updated