Klima 2.0

Notice to Readers

This document describes a proposed technical and economic model developed by 01X as part of exploratory research conducted in connection with the Klima ecosystem. It reflects conceptual design work informed by prior learnings from KlimaDAO and related on-chain carbon market initiatives.
The model presented herein is illustrative only and is intended to explore one possible approach to scaling carbon market infrastructure using blockchain-based systems. It does not represent a commitment to implement any specific architecture, mechanism, parameter, or economic outcome.
The Klima Protocol is expected to deploy a production system for on-chain carbon market infrastructure in or around February 2026. At that time, a separate implementation whitepaper will be released describing the deployed system, and the corresponding smart contract code will be made publicly available as open-source software.
This document should not be relied upon as a description of the final protocol, its operation, or its economics. It does not constitute an offer, solicitation, investment advice, or a representation regarding the legal, regulatory, or economic characteristics of any future deployment.

Copyright Notice

This document represents original work by dark_sole ds@darksole.vip. While contributions from others are gratefully acknowledged, all intellectual property rights remain with the author. The models, algorithms, processes, products, methodologies, and concepts described herein are licenced exclusively for commercial use by the Klima Protocol. No other party may implement, copy, modify, or derive works from these materials without explicit written permission from the author.

© 2025 dark_sole. All rights reserved.

1 Prologue

Klima 2.0 is an autonomous, rules-based coordination protocol designed to support the retirement of carbon credits through continuous and transparent execution terms.

It is not a financial product, investment vehicle, or asset management system, but a piece of market infrastructure that enables carbon supply and retirement demand to interact under predefined conditions.

The protocol operates through a dual-token architecture that facilitates coordination without discretionary control: kVCM functions as the internal unit of account and pricing reference for protocol-facilitated carbon retirement, while K2 provides signalling inputs related to capacity. Together, these tokens inform protocol parameters through deterministic smart-contract logic. This architecture enables the protocol to:

• define execution rates and intake eligibility for carbon credits against transparent, predefined rules;

• make acquired credits available exclusively for irreversible retirement;

• coordinate liquidity provision and participation incentives required for continuous operation.

Participant actions such as locking tokens, signalling preferences, or providing liquidity serve inputs into a coordination mechanism that adjusts protocol parameters within predefined bounds. These inputs do not confer ownership rights, redemption rights, or claims on protocol-held carbon, nor do they constitute discretionary management of assets.

The protocol consists of three interdependent functional layers:

• a carbon inventory layer that holds credits solely for the purpose of facilitating retirement;

• a liquidity layer that supports access and withdrawal from the system through external markets; and

• a coordination layer that aggregates participant signals to inform protocol parameters.

These layers are designed to operate together as a self-contained system, adjusting to observable supply and retirement demand without reliance on external oracles, manual intervention, or fee-extractive intermediaries.

Klima 2.0 abstracts complex carbon market interactions into a transparent and auditable execution framework, enabling participants to interact with carbon retirement infrastructure directly, programmatically, and on equal terms.

Any economic effects arising from protocol activity result from predefined rules and market interaction, rather than from asset ownership, portfolio management, or profit extraction.

2 Klima 2.0

KlimaDAO launched in 2021 on the Polygon blockchain as an early experiment in applying tokenisation and onchain liquidity to voluntary carbon markets. The initial design centred on the KLIMA token and a treasury-based mechanism intended to bootstrap liquidity and participation in a nascent onchain carbon ecosystem.

That first iteration played a meaningful role in demonstrating that carbon credits could be represented, transferred, and retired using blockchain infrastructure. It also catalysed the development of a broader ecosystem of tools and services, including integrations with multiple carbon registries, marketplaces and point-of-sale interfaces, APIs for third-party applications, and direct onchain issuance by project developers.

Over time, it became clear that the original architecture was not well suited to serving large-scale, enterprise carbon buyers or to supporting continuous, rules-based market operation without manual intervention. In particular, treasury-centric designs introduced complexity, opacity, and governance challenges that limited scalability and operational clarity.

Klima 2.0 is a ground-up redesign informed by these lessons. Rather than relying on treasury management or discretionary allocation, the new protocol is structured as neutral, non-extractive market infrastructure focused exclusively on facilitating carbon retirement through transparent pricing, programmatic settlement, and open participation.

The Klima 2.0 protocol replaces treasury-backed mechanisms with a rules-based coordination model that uses protocol-native tokens to parameterise execution rates, intake capacity, and participation incentives. Carbon credits handled by the protocol are acquired solely to fulfil retirement demand and are not held, traded, or managed for financial gain.

This shift reflects a deliberate move away from capital-centric designs toward infrastructure that prioritises auditability, predictability, and long-term operational resilience. Klima 2.0 is intended to function as a shared execution layer for carbon markets, enabling suppliers, buyers, and integrators to interact under predefined conditions without reliance on discretionary intermediaries.

2.1 High-Level Architecture

Klima 2.0 operates using two protocol-native tokens, kVCM and K2, which together enable rules-based coordination and participation within the system. These tokens do not confer ownership rights, redemption rights, or claims on protocol-handled carbon, and do not represent investment interests.

The kVCM and K2 tokens are used in three interdependent functional layers that together support continuous, non-discretionary operation:

1. Carbon Inventory Layer:

   • Accumulates carbon credits by minting kVCM.

   • Sells carbon retirement certificates by burning kVCM.

   • Sets carbon execution rates based on predefined rules.

   Carbon credits handled by the protocol cannot be withdrawn, transferred, or resold. They may only be retired.

2. Liquidity Layer:

   • kVCM and K2 token holders are able to pair their tokens together (or, in the case of kVCM, with USDC) in a standard liquidity pool to provide liquidity and generate fees on trades executed through the pool.

   • Liquidity providers may stake their liquidity provider tokens for a fixed time period of their choice, making them eligible to receive a share of the kVCM and K2 incentives.

3. Coordination Layer:

   • kVCM holders may time-lock their kVCM for a fixed time period of their choice, making them eligible to receive kVCM base accrual, K2 incentives, and to allocate their kVCM to carbon classes – which increases the weight of these carbon classes in the inventory.

   • K2 holders may user-lock their K2 for at least 48 hours, making them eligible to receive kVCM and K2 incentives, and to allocate their K2 to carbon classes – which reduces the difference between the execution terms on carbon intake and retirements for these carbon classes.

   • Time-locked kVCM holders participate in protocol coordination alongside liquidity providers with liquidity staked in the kVCM/K2 liquidity pool.

These layers operate together as a self-contained system that responds only to its own observable state, without reliance on external oracles or centralised intervention.

2.2 Carbon Inventory

The protocol’s carbon inventory accumulates and retires carbon. It is driven by parameters determined by its rules-based smart contracts, and user activities.

Figure 1: Klima 2.0 Carbon Inventory.

Carbon credits are acquired from suppliers, and consumed by retirement buyers. Carbon credits are grouped by predefined classifications called carbon classes.

Aggregate token holder allocations collectively set the parameters for the execution rates of each class, for both suppliers and retirees, by defining:

• Inventory weighting.

• Capacity.

Thus the Protocol is driven in response to its own native token allocations, acting as rules-based carbon market infrastructure to connect available supply with retirement demand. It is able to do so without using oracles or external inputs, and without discretionary allocation, resale, or optimisation of inventory.

2.3 Tokens

Locking or staking the protocol’s tokens allows participants to signal preferences within the system, and may make them eligible to receive protocol incentives.

Holding or locking protocol tokens does not represent ownership of protocol carbon assets, profit participation, or direct exposure to carbon price movements.

Together, kVCM and K2 enable the protocol to operate as neutral, non-extractive infrastructure, coordinating participation and execution without discretionary management.

2.3.1 kVCM

kVCM is the protocol’s primary utility token. Its supply is not capped: it grows when new carbon is supplied to the protocol, and contracts when it is retired.

• When time-locked:

  • It may be allocated to carbon classes for inventory weighting.

  • It receives kVCM base accrual and K2 incentives.

  • In aggregate, time-locks determine the rate of incentive issuance.

• Transactional usage:

  • Mint: when suppliers deliver carbon to the protocol.

  • Burn: when credits are retired from the protocol.

• When staked in liquidity pools it is also eligible for kVCM and K2 incentives, based on the duration of the stake and the position’s relative share of the pool.

Figure 2: Token utility.

2.3.2 K2

K2 is a fixed-supply token distributed programmatically over time.

• When user-locked:

  • It may be allocated to carbon classes to reduce the difference between execution terms on carbon intake and retirements.

  • It receives kVCM and K2 incentives.

  • In aggregate, user-locks influence the rates of incentive issuance.

• When staked in the kVCM/K2 liquidity pool it is also eligible for kVCM and K2 incentives, based on the duration of the stake and the position’s relative share of the pool.

2.3.3 Utility Functions

The kVCM token has two utility functions which are not independent:

Figure 3: kVCM utility functions.

1. Time lock: The kVCM token is locked for a specific period of time which determines a kVCM ‘base accrual’ rate. This cannot be amended.

2. Execution rate allocation: Collective signalling of carbon classes via kVCM allocations determines determines the protocol’s execution rate for carbon intake and retirement, expressed in kVCM units. These parameters govern how the protocol issues or burns kVCM when carbon is supplied or retired. Allocations may be updated over time.

The K2 token also has two utility functions:

1. User lock: The K2 token remains locked for at least 24 hours.

2. Capacity allocation: Collective selection of carbon classes via K2 allocations determines the protocol’s execution capacity for carbon intake and retirement operations for a given class. Higher capacity allocations increase the system’s ability to process additional carbon activity without materially altering the execution rate, as defined by kVCM allocations.

Both tokens support the operation of the infrastructure, with kVCM informing execution rateios, and the K2 token modulating capacity.

2.3.4 Base Accrual and Incentives

The protocol issues tokens to participants who provide services necessary for system operation.

1. kVCM Base Accrual

   A base accrual of kVCM tokens is continously emitted to:

   • Time-locked kVCM.

2. kVCM Incentives

   kVCM incentives are continuously emitted to:

   • User-locked K2.

   • Both kVCM and K2 liquidity providers.

   The number of kVCM tokens emitted as kVCM incentives is proportional to (but never higher than) the number of kVCM tokens emitted as base accrual.

3. K2 Incentives

   Depending on overall system balances, the supply of K2 tokens is programatically allocated at various rates to:

   • Time-locked kVCM.

   • User-locked K2.

   • Both kVCM and K2 liquidity providers.

2.3.5 Token Initialisation

There is an initial issuance of tokens at the genesis of Klima 2.0. All future emissions are distributed autonomously via carbon swaps and incentives.

Token	Supply	Notes
kVCM	20 million	Supply expands and contracts programmatically in response to carbon intake and retirement activity. New tokens are emitted continuously as base accrual and incentives. A portion of the initial supply is allocated to existing KLIMA holders.
K2	100 million	Fixed supply. Distributed programatically over time, with a portion allocated to existing KLIMA holders.

Table 1: Token Summary

2.4 Participants

1. Carbon Suppliers & Retirees

   Participants may supply or retire eligible, tokenised carbon credits to the protocol at quoted execution rates. Supplied credits are handled solely for retirement and cannot be withdrawn, transferred, resold or otherwise arbitraged.

   Carbon inventory: Indicative excution rates for suppliers and retirees are continuously updated based on protocol state.

2. Liquidity Providers

   Participants may provide liquidity in supported token pairs to facilitate entry and exit from the system. Liquidity provision supports continuous execution and is incentivised according to predefined protocol rules.

   Staked liquidity: Protocol incentives may be issued for participants providing liquidity to support system operation.

3. Coordinators

   Participants may influence execution conditions by allocating kVCM and K2 tokens within predefined protocol parameters.

   Time locks & user locks: Protocol incentives may be issued for those contributing activities that coordinate the protocol and signal long-term participation.

2.5 Protocol Design Principles

1. Infrastructure, Not Extraction:

   Klima 2.0 is designed as shared market infrastructure rather than an extractive financial product. The protocol does not charge fees, take hidden spreads, or operate profit-taking mechanisms for any sponsor, foundation, or investor. All protocol behaviour is rules-based and applies uniformly to all participants, with no privileged economic positions or revenue capture layers.

   Design intent: Reduce opaque intermediation and hidden margins common in carbon markets, not replace them with a new rent-seeking intermediary.

2. Consumption-only Carbon Access:

   Carbon credits handled by the protocol are not exposed for resale, speculation, or secondary trading. Once accepted by the protocol, credits may only be accessed for irreversible retirement through protocol-defined processes.

   Design intent: Align the system with carbon’s end use (retirement), rather than treating credits as financial instruments.

3. Coordination Through Signalling:

   Protocol tokens do not represent ownership of carbon, claims on protocol-held assets, or entitlement to surplus value. Instead, tokens function as signalling and coordination inputs that influence protocol parameters (such as execution conditions and capacity) within predefined bounds.

   Design intent: Enable decentralised coordination in a complex and competitive environment.

4. Autonomous, Rules-based Operation

   All protocol behaviour is governed by deterministic smart contracts. Once deployed, the system operates autonomously and does not rely on discretionary decisions by any individual, committee, or organisation.

   Design intent: Build a trustless, auditable system, that is not based on subjective, opaque intervention.

5. Equal Access and Uniform Treatment

   All participants interact with the protocol on identical terms. There are no side agreements, preferential execution paths, differentiated rights, or bespoke economic arrangements. Protocol rules apply uniformly to all users, including the protocol’s creators and affiliated entities.

   Design intent: Ensure credibility, neutrality, and resistance to capture.

6. Market-driven Outcomes, Not Managed returns

   Any economic effects associated with protocol participation arise solely from predefined rules and participant interaction with the system. The protocol does not manage assets on behalf of users, target returns, or seek to optimise outcomes for any class of participant.

   Design intent: Enable transparent market coordination without positioning the protocol as an asset manager or investment vehicle

3 Core Protocol Mechanics

From this section we refer to kVCM tokens as A, K2 tokens as G, USDC tokens as Q, carbon credits as C, and carbon retirement certificates as C*.

Three types of mechanics enable the Klima Protocol to find equilibrium through continuous, rule-based feedback mechanisms representing system state (supply, demand, coordinator allocations). There is no centralised management entity with discretionary powers, or fees that can be turned on.

1. Time-locking mechanics: A token holders can time-lock their tokens until a set date to have the ability to select carbon classes for inventory weighting.

   • The collective time locks define the base accrual curve.

2. Carbon inventory mechanics: the protocol swaps A for carbon credits C (in) or carbon retirement certificates C* (out).

   • Both allocations of time-locked A tokens and user-locked G tokens are used in the protocol: allocations of A determine the execution rates of carbon, and allocations of G determine capacity.

3. Liquidity mechanics: External liquidity pools enable conversion between kVCM and supported settlement assets. Liquidity provision supports system availability and may make participants eligible for protocol incentives.

   • AG liquidity pool: Native token swap A and G.

   • AQ liquidity pool: The asset token A with USDC Q.

The Klima system enables each participant to contribute to various aspects of the model, according to their own interests and preferences. This, in conjunction with the autonomous model, enables the protocol to fulfill continuous carbon retirement activity within the carbon markets.

3.1 Time-locking Mechanics

Time-locking A tokens represents a commitment to protocol participation for a fixed duration. Lock durations are standardised at 90 days increments and expire on a rolling schedule. There are always 40 durations, extending out to approximately 10 years.

• Discount curve: Aggregate time-locking determines the shape of the discount curve of the A token.

• Incentives: Time-locked A tokens receive base accrual. Base accrual is calculated daily based on time-locked positions.

• Locks: Time-locked tokens and any associated base accrual are released only upon time-lock expiration. Early exit is not possible.

G tokens are not involved in the time-locking mechanics. The discount curve is agnostic to carbon class although only time-locked A token holders can allocate their token to carbon classes for inventory weighting.

3.1.1 Base Accrual

Defining:

• S: Total time-locked A tokens expressed as a proportion of the outstanding supply of A.

• S_t: Total A tokens time-locked in bucket t, expressed as a proportion of the outstanding supply of A, where {\sum S_t = S}, and t is the index of standard durations t \in \{1, 2, 3, \dots, 40\}.

• E_t: Duration expressed in years.

Calculating curve parameters D and C:

D = \frac{1}{S} \sum_{t=1}^{40} S_t \, E_t \tag{1}

C = \frac{1}{S} \sum_{t=1}^{40} S_t \, E_t^2 \tag{2}

The shape of the base accrual curve is produced:

\gamma_t = \max \left( \frac{E_t}{D} - \frac{E_t^2}{2 \, C}, \, 0 \right) \tag{3}

Normalising \gamma_t to \hat \gamma_t:

\hat \gamma_t = \frac{\gamma_t}{\sum_{t=1}^{40} \gamma_t} \tag{4}

With the cumulative sum of the normalised values expressed as \Gamma_t:

\Gamma_t = \sum_{i=1}^t \hat \gamma_i \quad \text{for } t = 1, \dots, 40 \tag{5}

The base accrual curve Z_t is solved:

Z_t = (1 - S) \, \frac{\Gamma_t}{E_t} \tag{6}

Whereupon, the discount rate B_t that forms the discount curve is derived:

B_t = \exp(-Z_t \, E_t) \tag{7}

The accrual of time-locked A tokens is calculated daily and added to the locked balance, hence the daily accrual for each duration is calculated:

Y_t = \exp \left( \frac{Z_t}{365} \right) - 1 \tag{8}

Hence, any time-locked A stake S_t will increase daily by \Delta S_t:

\Delta S_t = S_t \, Y_t \tag{9}

With the total A tokens created on a daily basis, or ‘growth’, as

R = \sum_{t=1}^{40} \Delta S_t \tag{10}

viewof inputS = Inputs.range([1e-4, 1], {
  label: tex`\text{Time-Locked } S`,
  step: 1e-4,
  value: 0.55,
});
viewof inputD = Inputs.range([0.25, 10], {
  label: tex`\text{Parameter } D`,
  step: 0.01,
  value: 4.69,
});

function constAreaLinear(range, area, inputSlope, slopeFactor = 0.007) {
  if (range.length === 1) {
    return [area];
  }

  let y1 = 0;
  let y2 = range.length - 1;
  let slope = slopeFactor * Math.atanh(inputSlope);
  let intercept = area / range.length;

  if (Math.abs(slope) > 2 * intercept / (y2 - y1 - 1)) {
    const yExactShift = Math.sqrt(Math.abs(2 * area / slope));
    const yRoundShift = Math.max(1, Math.round(yExactShift));
    if (slope > 0) {
      y1 = y2 - yRoundShift;
    } else {
      y2 = y1 + yRoundShift;
    }
    slope = Math.sign(slope) * 2 * area / Math.pow((y2 - y1), 2);
    intercept = Math.abs(slope) * (y2 - y1 - 1) / 2;
  }

  const yConstArea = [];
  for (let i = 0; i < range.length; i++) {
    const y = i - (y1 + y2) / 2;
    yConstArea.push(Math.max(0, slope * y + intercept));
  }

  return yConstArea;
}

vecE = d3.range(0.25, 10.1, 0.25);

scaleE = d3.scaleLinear(d3.extent(vecE), [-1, 1]);

vecS = constAreaLinear(vecE, 0.55, scaleE(inputD)).map(
  x => x * inputS / 0.55,
);

vecReverseCumsumS = d3.cumsum(vecS.slice().reverse()).reverse();

function dotProduct(v, w) {
  if (v.length !== w.length) {
    throw new Error("Vectors must have the same length");
  }
  return v.reduce((acc, val, i) => acc + val * w[i], 0);
}

function weightedArithmeticMean(v, weights) {
  return dotProduct(v, weights) / d3.sum(weights);
}

paramD = weightedArithmeticMean(vecE, vecS);

paramC = weightedArithmeticMean(vecE.map(e => e * e), vecS);

function computeGamma(vecE, paramD, paramC) {
  const twoC = 2 * paramC;
  return vecE.map(e => Math.max(0, e/paramD - e*e/twoC));
}

vecGamma = computeGamma(vecE, paramD, paramC);

function normalize(v) {
  const sum = d3.sum(v);
  return v.map(val => val / sum);
}

vecNormGamma = normalize(vecGamma);

vecCumSumGamma = d3.cumsum(vecNormGamma);

function computeZ(paramS, vecCumSumGamma, vecE) {
  return vecCumSumGamma.map((g, t) => (1 - paramS) * g / vecE[t]);
}

vecZ = computeZ(inputS, vecCumSumGamma, vecE);

function computeB(vecZ, vecE) {
  return vecZ.map((z, t) => Math.exp(-z * vecE[t]));
}

vecB = computeB(vecZ, vecE);

function computeY(vecZ) {
  return vecZ.map(z => Math.expm1(z));
}

vecY = computeY(vecZ);

paramI = dotProduct(vecS, vecY);

yieldData = {
   const yieldData = [];
   for (let t = 3; t < vecE.length; t += 4) {
      yieldData.push({
         key: "Stake A",
         value: 100 * d3.sum(vecS.slice(t - 3, t + 1)),
         time: vecE[t],
      });
      yieldData.push({
         key: "Base Accrual",
         value: 100 * vecZ[t],
         time: vecE[t],
      });
      yieldData.push({
         key: "Growth-adjusted Base Accrual",
         value: 100 * (vecZ[t] - paramI),
         time: vecE[t],
      });
      yieldData.push({
         key: "Discount Curve",
         value: 100 * vecB[t],
         time: vecE[t],
      });
      yieldData.push({
         key: "Cumulative Stake A",
         value: 100 * vecReverseCumsumS[t - 3],
         time: vecE[t],
      });
   }
   return yieldData;
};
getStake = d => d.key === "Stake A" ? d.value : NaN;
getYieldTerm = d => d.key === "Base Accrual" ? d.value : NaN;
getRealYield = d => d.key === "Growth-adjusted Base Accrual" ? d.value : NaN;
getDiscount = d => d.key === "Discount Curve" ? d.value : NaN;
getCumStake = d => d.key === "Cumulative Stake A" ? d.value : NaN;

stringS = "Total Stake = " + inputS.toLocaleString(
  "en-GB",
  { style: "percent", minimumFractionDigits: 2, maximumFractionDigits: 2 },
);
stringI = "Growth = " + paramI.toLocaleString(
  "en-GB",
  { style: "percent", minimumFractionDigits: 2, maximumFractionDigits: 2 },
) + "/Year";
stringD = `D = ${paramD.toLocaleString(
  "en-GB",
  { minimumFractionDigits: 2, maximumFractionDigits: 2 },
)} years`;
stringC = `√C = ${Math.sqrt(paramC).toLocaleString(
  "en-GB",
  { minimumFractionDigits: 2, maximumFractionDigits: 2 },
)} years`;

yieldParams = [
  { key: stringD, time: paramD },
  { key: stringC, time: Math.sqrt(paramC) },
];

Plot.plot({
  color: {
    legend: true,
    range: d3.schemeCategory10,
    domain: [
      "Stake A",
      "Base Accrual",
      "Growth-adjusted Base Accrual",
      stringD,
      stringC,
    ],
  },
  x: {
    ticks: d3.range(1, 11),
    domain: [0.25, 10.45],
    label: "Duration E (Years)",
  },
  y: {
    domain: [
      0,
      Math.max(d3.max(yieldData, getStake), d3.max(yieldData, getYieldTerm)),
    ],
    grid: true,
  },
  insetTop: 16,
  insetLeft: 8,
  insetRight: 8,
  clip: true,
  marks: [
    Plot.frame(),
    Plot.axisY({ anchor: "left", label: "Stake A (%)" }),
    Plot.axisY({ anchor: "right", label: "Accrual Rate (%/Year)" }),
    Plot.rectY(yieldData, {
      x1: d => d.time - 0.45,
      x2: d => d.time + 0.45,
      y: getStake,
      fill: "key",
    }),
    Plot.ruleX(yieldParams, {
      x: "time",
      stroke: "key",
      strokeWidth : 2,
      strokeDasharray: 4,
    }),
    Plot.lineY(yieldData, { x: "time", y: getYieldTerm, stroke: "key" }),
    Plot.dotY(yieldData, { x: "time", y: getYieldTerm, fill: "key" }),
    Plot.lineY(yieldData, { x: "time", y: getRealYield, stroke: "key" }),
    Plot.dotY(yieldData, { x: "time", y: getRealYield, fill: "key" }),
  ],
});

(a) Base accrual (, ).

Plot.plot({
  color: {
    legend: true,
    range: [8, 5, 3, 4].map(i => d3.schemeCategory10[i]),
    domain: ["Cumulative Stake A", "Discount Curve", stringD, stringC],
  },
  x: {
    ticks: d3.range(1, 11),
    domain: [0.25, 10.45],
    label: "Duration E (Years)"
  },
  y: { domain: [0, 100], grid: true },
  clip: true,
  insetTop: 16,
  insetLeft: 8,
  insetRight: 8,
  marks: [
    Plot.frame(),
    Plot.axisY({ anchor: "left", label: "Cumulative Stake (%)" }),
    Plot.axisY({ anchor: "right", label: "Discount (%)" }),
    Plot.rectY(yieldData, {
      x1: d => d.time - 0.45,
      x2: d => d.time + 0.45,
      y: getCumStake,
      fill: "key",
    }),
    Plot.ruleX(yieldParams, {
      x: "time",
      stroke: "key",
      strokeWidth : 2,
      strokeDasharray: 4,
    }),
    Plot.lineY(yieldData, { x: "time", y: getDiscount, stroke: "key" }),
    Plot.dotY(yieldData, { x: "time", y: getDiscount, fill: "key" }),
  ],
});

(b) Discount rates.

Figure 4: Example of base accrual.

For visualising the sensitivity of overall A base accrual with respect to staking and duration, Figure 5 assumes a single duration over the staking range to provide an approximation of growth \Delta S \approx Z \, S.

function contrastingTextColor(backgroundColor) {
  if (d3.hsl(backgroundColor).l < 0.5) {
    return "white";
  } else {
    return "black";
  }
}

function computeApproxDeltaA(paramS, paramE) {
  return paramS * (1 - paramS) / paramE;
}

growthData = {
  const growthData = [];
  for (let paramS = 0; paramS < 1.01; paramS += 0.1) {
    for (let paramE = 1; paramE <= 10; paramE++) {
      growthData.push({
        key: "ΔA",
        e: paramE,
        s: paramS,
        value: computeApproxDeltaA(paramS, paramE),
      });
    }
  }
  return growthData;
};

Plot.plot({
  color: { legend: true, scheme: "Spectral", type: "sequential", label: "Annual Growth ΔS" },
  x: { ticks: d3.range(1, 10.1, 1), domain: [10.5, 0.5], label: "Duration E (Years)" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Staking S" },
  marks: [
    Plot.frame(),
    Plot.rect(growthData, {
      x1: d => d.e - 0.5,
      x2: d => d.e + 0.5,
      y1: d => d.s - 0.05,
      y2: d => d.s + 0.05,
      fill: "value",
    }),
    Plot.text(growthData, {
      x: "e",
      y: "s",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [0, computeApproxDeltaA(0.5, 1)],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 5: A annual growth rate \Delta S from base accrual.

3.1.2 Protocol Coordination Voting Power

Protocol coordination voting power can be derived from two participation cohorts:

1. Time-locked A tokens: S_t

2. Staked liquidity in the A-G pair AG (see Section 3.3), defined here as A_{Gt}, representing the quantity of A tokens held in the liquidity pool expressed as a proportion of circulating supply.

Voting power is allocated by lock or stake duration, and applied to the respective balance of A tokens:

1. Voting weights for time-locked A tokens v_t:

   v_t = Z_t \, S_t \tag{11}

2. Voting weights for staked liquidity w_t:

   w_t = Z_t \, A_{Gt} \tag{12}

3. Voting power for time-locked A tokens V_t:

   V_t = \frac{v_t}{\sum_{j=1}^{40} (v_j + 2 w_j)} \tag{13}

4. Voting power for staked liquidity W_t:

   W_t = \frac{w_t}{\sum_{j=1}^{40} \left( \frac 1 2 v_j + w_j \right)} \tag{14}

3.2 Carbon Inventory Mechanics

The carbon inventory layer ultimately swaps carbon through a set of smart contracts, driven by carbon supply, demand, and user inputs. The combined allocations of A and G tokens creates a dynamic real-time execution rate curve for each carbon class.

Figure 6: Klima 2.0 carbon inventory mechanics.

3.2.1 Carbon Supply

User swaps carbon credits for A tokens.

3.2.1.1 Existing Carbon in the Inventory

For execution terms, both A tokens and G tokens may be allocated to specific carbon classes {i \in \{1, 2, 3, \dots, n\}} and these are independent allocations between the two tokens.

Figure 7: Token staking class structure.

For a carbon class quantity to be supplied to the protocol, it must have a strictly positive quantity of A tokens allocated to that carbon class, otherwise there is no defined rate, and the carbon cannot be swapped.

Defining:

• C_i: Total tonnes of carbon class i currently held in the inventory.

• A_i: A tokens allocated to carbon class i expressed as a proportion of the outstanding supply of A tokens, where {\sum A_i = A}.

• G_i: G tokens allocated to carbon class i expressed as a proportion of the outstanding supply of G Tokens.

Where \Delta C_i is expressed as the relative increment to its respective pool balance, the amount of A tokens issued for carbon, \Delta A, expressed as a proportion of current supply, is determined as:

\ln(1 + \Delta A) = \left( A_i - \frac{A_i^2 \, (1 - G_i)^2}{2} \right) \ln(1 + \Delta C_i) \tag{15}

Denoting the expression on the right hand side of Equation 15 as \mathsf{RHS}:

\Delta A = \exp(\mathsf{RHS}) - 1 \tag{16}

Finally, \Delta A is applied to the outstanding supply of A to solve for token quantities.

Figure 8 illustrates the G token’s capacity to maintain the initial execution terms of the A token. The data has been normalised in Figure 9 to \Delta C_i \, A_i.

viewof inputDeltaBarCi = Inputs.range([0.01, 1], {
  label: tex`\text{Purchased } \Delta C_i`,
  step: 0.01,
  value: 1,
});

function computeDeltaA(Ai, Gi, deltaCi) {
  return Math.expm1((Ai - (Ai**2 * (1 - Gi)**2 / 2)) * Math.log1p(deltaCi));
}

pricingData = {
  const pricingData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    pricingData.push({
      key: "ΔA",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    pricingData.push({
      key: "Normalised ΔA",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    for (let paramAi = 0.1; paramAi < 1.01; paramAi += 0.1) {
      pricingData.push({
        key: "ΔA",
        ai: paramAi,
        gi: paramGi,
        value: computeDeltaA(paramAi, paramGi, inputDeltaBarCi),
      });
      pricingData.push({
        key: "Normalised ΔA",
        ai: paramAi,
        gi: paramGi,
        value: computeDeltaA(paramAi, paramGi, inputDeltaBarCi) /
                (inputDeltaBarCi * paramAi),
      });
    }
  }
  return pricingData;
};
getDeltaA = d => d.key === "ΔA" ? d.value : NaN;
getNormDeltaA = d => d.key === "Normalised ΔA" ? d.value : NaN;

stringInputDeltaBarCi = inputDeltaBarCi.toLocaleString(
  "en-GB",
  { style: "percent", maximumFractionDigits: 0 },
);

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: `ΔA, where ΔCᵢ = ${stringInputDeltaBarCi}`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(pricingData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getDeltaA,
    }),
    Plot.text(pricingData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getDeltaA(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            computeDeltaA(0.1, 1, inputDeltaBarCi),
            computeDeltaA(1, 1, inputDeltaBarCi),
          ],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 8: A price curves (\Delta A).

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: `Normalised ΔA, where ΔCᵢ = ${stringInputDeltaBarCi}`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(pricingData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getNormDeltaA,
    }),
    Plot.text(pricingData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getNormDeltaA(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            computeDeltaA(1, 0, inputDeltaBarCi) / inputDeltaBarCi,
            computeDeltaA(1, 1, inputDeltaBarCi) / inputDeltaBarCi,
          ],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 9: Normalised A price curves.

Noting that the sensitivity to G_i increases as A_i increases and the effects become more pronounced as \Delta C_i increases.

3.2.1.2 Zero Carbon Scenario

There are circumstances when there is zero carbon held in the inventory for a particular class, i.e. {C_i = 0}, which invalidates the calculation of \Delta C_i and a different approach is required.

Taking \Delta C_\emptyset as the tonnes of carbon tokens (implying an existing balance of 1 tonne) to be supplied for any carbon class that has a strictly positive A allocation A_\emptyset, together with G allocation G_\emptyset:

\Delta A = \frac{\Delta C_\emptyset}{1 + \Delta C_\emptyset} \, \left( A_\emptyset - \frac{A_\emptyset^2 (1 - G_\emptyset)^2}{2} \right)^2 \tag{17}

viewof inputDeltaBarCnull = Inputs.range([1e-1, 1e5], {
  label: tex`\text{Purchased } \Delta C_\emptyset`,
  step: 1e-1,
  value: 1e2,
  transform: Math.log,
});

function computeZeroCarbonDeltaA(Ai, Gi, deltaCnull) {
  return (deltaCnull / (1 + deltaCnull)) * (Ai - (Ai**2 * (1 - Gi)**2 / 2))**2;
}

function computeTrueDeltaA(Ai, Gi, barCiTonnes, deltaBarCiTonnes) {
  if (barCiTonnes === 0) {
    return computeZeroCarbonDeltaA(Ai, Gi, deltaBarCiTonnes);
  } else {
    const deltaBarCi = deltaBarCiTonnes / barCiTonnes;
    return computeDeltaA(Ai, Gi, deltaBarCi);
  }
}

function numberOfDigits(x) {
  return x === 0 ? 1 : (1 + Math.floor(Math.log10(x)));
}

zeroCarbonData = {
  const zeroCarbonData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    zeroCarbonData.push({
      key: "ΔA",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    zeroCarbonData.push({
      key: "Normalised ΔA",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    for (let paramAi = 0.1; paramAi < 1.01; paramAi += 0.1) {
      zeroCarbonData.push({
        key: "ΔA",
        ai: paramAi,
        gi: paramGi,
        value: computeZeroCarbonDeltaA(paramAi, paramGi, inputDeltaBarCnull),
      });
      zeroCarbonData.push({
        key: "Normalised ΔA",
        ai: paramAi,
        gi: paramGi,
        value: computeZeroCarbonDeltaA(paramAi, paramGi, inputDeltaBarCnull) /
                ((inputDeltaBarCnull / (1 + inputDeltaBarCnull)) * paramAi**2),
      });
    }
  }
  return zeroCarbonData;
};

stringDeltaBarCnull = inputDeltaBarCnull.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(1, numberOfDigits(inputDeltaBarCnull)),
    maximumSignificantDigits: Math.max(1, numberOfDigits(inputDeltaBarCnull)),
  },
);

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: `ΔA, where ΔC∅ = ${stringDeltaBarCnull} tCO2eq`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(zeroCarbonData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getDeltaA,
    }),
    Plot.text(zeroCarbonData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getDeltaA(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 4, maximumFractionDigits: 4 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            computeZeroCarbonDeltaA(0.1, 1, inputDeltaBarCnull),
            computeZeroCarbonDeltaA(1, 1, inputDeltaBarCnull),
          ],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 10: A price curves (\Delta A) in the zero carbon scenario.

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: `Normalised ΔA, where ΔC∅ = ${stringDeltaBarCnull} tCO2eq`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(zeroCarbonData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getNormDeltaA,
    }),
    Plot.text(zeroCarbonData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getNormDeltaA(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            computeZeroCarbonDeltaA(1, 0, inputDeltaBarCnull) /
                    (inputDeltaBarCnull / (1 + inputDeltaBarCnull)),
            computeZeroCarbonDeltaA(1, 1, inputDeltaBarCnull) /
                    (inputDeltaBarCnull / (1 + inputDeltaBarCnull)),
          ],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 11: Normalised A price curves in the zero carbon scenario.

3.2.2 Carbon Credit Retirements

User swaps A tokens for carbon retirement certificates.

3.2.2.1 Weighted Carbon Class

For retiring carbon that is weighted, that is for which there is a strictly positive A token allocation, an A token holder can extract the carbon class retirement certificate of their choice C_i:

\ln(1 + \Delta C_i) = \frac{-\ln(1 + \Delta A)}{A_i + \frac 1 2 A_i^2 \, (1 - G_i)^2} \tag{18}

As before, denoting the expression on the right hand side of Equation 18 as \mathsf{RHS}:

\Delta C_i = \exp(\mathsf{RHS}) - 1 \tag{19}

viewof inputDeltaA = Inputs.range([0.001, 0.999], {
  label: tex`\text{Burnt } \Delta A`,
  step: 0.001,
  value: 0.1,
});

function computeDeltaCi(Ai, Gi, deltaA) {
  return Math.expm1(-Math.log1p(deltaA) / (Ai + (Ai**2 * (1 - Gi)**2 / 2)));
}

retirementData = {
  const retirementData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    retirementData.push({
      key: "-ΔCᵢ",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    for (let paramAi = 0.1; paramAi < 1.01; paramAi += 0.1) {
      retirementData.push({
        key: "-ΔCᵢ",
        ai: paramAi,
        gi: paramGi,
        value: -computeDeltaCi(paramAi, paramGi, inputDeltaA),
      });
    }
  }
  return retirementData;
};

stringInputDeltaA = inputDeltaA.toLocaleString(
  "en-GB",
  { style: "percent", minimumFractionDigits: 1, maximumFractionDigits: 1 },
);

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: `-ΔCᵢ, where ΔA = ${stringInputDeltaA}`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(retirementData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: "value",
    }),
    Plot.text(retirementData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            -computeDeltaCi(1, 0, inputDeltaA),
            -computeDeltaCi(0.1, 1, inputDeltaA),
          ],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 12: Proportion of carbon retired.

Figure 12 shows the cost of carbon increasing with A_i and decreasing on G_i.

3.2.2.2 Unweighted Carbon Class

A retirement certificate for a carbon class with a zero A allocation cannot be extracted from the inventory by swapping in A tokens.

3.2.2.3 Round Trip Difference

Any difference between the A tokens issued in connection with carbon intake and the A tokens burned in connection with retirement is reflected solely as a change in the circulating supply of A tokens, according to the above protocol rules. No margin, profit, or financial surplus is retained or extracted by any entity.

Figure 13 below shows the difference captured on a ‘round trip’ by the system where \varepsilon is the proportion retained:

viewof inputDeltaCinitial = Inputs.range([0.001, 1], {
  label: tex`\text{Initial }\Delta C`,
  step: 0.001,
  value: 0.1,
});

function computeSpread(Ai, Gi, deltaCinitial) {
  const deltaA = computeDeltaA(Ai, Gi, deltaCinitial);
  const deltaCfinal = -computeDeltaCi(Ai, Gi, deltaA);
  return (deltaCinitial - deltaCfinal) / deltaCinitial;
}

liquidationData = {
  const liquidationData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    liquidationData.push({ key: "deltaa", ai: 0, gi: paramGi, value: NaN });
    liquidationData.push({ key: "deltac", ai: 0, gi: paramGi, value: NaN });
    liquidationData.push({ key: "spread", ai: 0, gi: paramGi, value: NaN });
    for (let paramAi = 0.1; paramAi < 1.01; paramAi += 0.1) {
      const deltaA = computeDeltaA(paramAi, paramGi, inputDeltaCinitial)
      liquidationData.push({
        key: "deltaa",
        ai: paramAi,
        gi: paramGi,
        value: computeDeltaA(paramAi, paramGi, inputDeltaCinitial) /
                inputDeltaCinitial,
      });
      liquidationData.push({
        key: "deltac",
        ai: paramAi,
        gi: paramGi,
        value: computeDeltaCi(paramAi, paramGi, deltaA) / inputDeltaCinitial,
      });
      liquidationData.push({
        key: "spread",
        ai: paramAi,
        gi: paramGi,
        value: computeSpread(paramAi, paramGi, inputDeltaCinitial),
      });
    }
  }
  return liquidationData;
};
getLiqDeltaA = d => d.key === "deltaa" ? d.value : NaN;
getLiqDeltaCi = d => d.key === "deltac" ? d.value : NaN;
getLiqSpread = d => d.key === "spread" ? d.value : NaN;

stringInputDeltaCinitial = inputDeltaCinitial.toLocaleString(
  "en-GB",
  { style: "percent", minimumFractionDigits: 1, maximumFractionDigits: 1 },
);

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    domain: [0, computeSpread(1, 0, 1)],
    type: "sequential",
    label: `Carbon Difference ε, where initial ΔC = ${stringInputDeltaCinitial}`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(liquidationData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getLiqSpread,
    }),
    Plot.text(liquidationData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getLiqSpread(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [0, computeSpread(1, 0, inputDeltaCinitial)],
          d3.interpolateSpectral,
        )(d.value),
      ),
    }),
  ],
});

Figure 13: Carbon ‘difference’.

Figure 14 shows the component difference contributions on a carbon supply and purchase round trip of a carbon retirement certificate.

Inputs.bind(
  Inputs.range([0.001, 1], {
    label: tex`\text{Initial }\Delta C`,
    step: 0.001,
    value: 0.1,
  }),
  viewof inputDeltaCinitial,
);

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    domain: [0, 1],
    type: "sequential",
    label: `Component ΔA, where initial ΔC = ${
      stringInputDeltaCinitial
    }`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(liquidationData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getLiqDeltaA,
    }),
    Plot.text(liquidationData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getLiqDeltaA(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(d3.interpolateSpectral(d.value)),
    }),
  ],
});

(a) Carbon ‘difference’ component ΔA.

Plot.plot({
  color: {
    legend: true,
    scheme: "Greys",
    domain: [
      -1,
      computeDeltaCi(
        1,
        0,
        computeDeltaA(1, 0, inputDeltaCinitial) / inputDeltaCinitial,
      ),
    ],
    label: `Component ΔC, where initial ΔC = ${
      stringInputDeltaCinitial
    }`,
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(liquidationData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: getLiqDeltaCi,
    }),
    Plot.text(liquidationData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(getLiqDeltaCi(d)) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential(
          [
            -1,
            computeDeltaCi(
              1,
              0,
              computeDeltaA(1, 0, inputDeltaCinitial) / inputDeltaCinitial,
            ),
          ],
          d3.interpolateGreys,
        )(d.value),
      ),
    }),
  ],
});

(b) Carbon ‘difference’ component ΔC.

Figure 14: Carbon ‘difference’ components.

3.3 Liquidity Mechanics

Both A and G tokens can be used for providing liquidity.

Figure 15: Token liquidity and execution structure.

There are two core liquidity pools:

1. An AMM 50:50 pairing of A and G tokens: pool AG.

2. A hard currency USDC denoted as Q paired with A: pool AQ.

3.3.1 Liquidity Fees

The AQ pool will have its own set of fees in the standard way.¹

The AG pool has different economics as the assets are highly correlated since they represent the same economy. For this reason, the fees are extremely low.

By staking liquidity (liquidity provider tokens) to the standard durations, both pools may receive a distribution of A tokens determined from Section 3.3.2 below. This is an additional primary issuance to the Base Accrual already discussed.

3.3.2 kVCM Incentives

In addition to the base accrual mechanism, kVCM incentives are distributed to user-locked G token holders and staked liquidity providers of A and G tokens.

As we have seen, a higher G token allocation G_i for a carbon class increases the protocol’s capacity to process additional carbon activity without materially altering the execution rate. As a consequence, the relationship between the carbon class selected under G_i and the A strengthens. If we consider G_i as an estimate of residual or idiosyncratic sensitivity in the carbon class, we can calculate an inventory beta \beta from the implied betas of each carbon class i.

\beta = \sqrt{\sum_{i=1}^n A_i - A_i \, (1 - G_i)^2} \tag{20}

The inventory \beta determines a sensitivity factor for the liquidity pools of A.

For intuition, the map in Figure 16 shows the various outputs of the function per carbon class.

function computeBeta(vecAi, vecGi) {
  const beta2 = vecAi.reduce(
    (acc, Ai, i) => acc + Ai - Ai * (1 - vecGi[i])**2,
    0,
  );
  return Math.sqrt(beta2);
}

function computeBetai(Ai, Gi) {
  return Math.sqrt(Ai - Ai * (1 - Gi)**2);
}

betaData = {
  const betaData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    betaData.push({
      key: "βᵢ",
      ai: 0,
      gi: paramGi,
      value: NaN,
    });
    for (let paramAi = 0.1; paramAi < 1.01; paramAi += 0.1) {
      betaData.push({
        key: "βᵢ",
        ai: paramAi,
        gi: paramGi,
        value: computeBetai(paramAi, paramGi),
      });
    }
  }
  return betaData;
};

Plot.plot({
  color: {
    legend: true,
    scheme: "Spectral",
    type: "sequential",
    label: "βᵢ",
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Aᵢ" },
  y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
  marks: [
    Plot.frame(),
    Plot.rect(betaData, {
      x1: d => d.ai - 0.05,
      x2: d => d.ai + 0.05,
      y1: d => d.gi - 0.05,
      y2: d => d.gi + 0.05,
      fill: "value",
    }),
    Plot.text(betaData, {
      x: "ai",
      y: "gi",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(d3.interpolateSpectral(d.value)),
    }),
  ],
});

Figure 16: Range of \beta_i.

The table and figure below show an example of the effects on \beta of allocating large G_i values to small A_i values where the shift in G_i results in a lower \beta (0.27 from 0.55) with no change to total G and A allocations.

Class	1	2	3	4	\beta
A_i	0.50	0.20	0.10	0.05
Initial G_i	0.30	0.10	0.05	0.01
Initial \beta_i^2	0.2550	0.0380	0.0098	0.0010	0.5511
New G_i	0.01	0.05	0.10	0.30
New \beta_i^2	0.0100	0.0195	0.0190	0.0255	0.2719
\Delta G_i	(0.29)	(0.05)	0.05	0.29
\Delta \beta_i^2	(0.2451)	(0.0185)	0.0092	0.0245

Table 2: Effect on \beta from outsized G allocation.

arrayAi = [0.5, 0.2, 0.1, 0.05];
arrayInitialGi = [0.3, 0.1, 0.05, 0.01];
arrayNewGi = arrayInitialGi.toReversed();
betaContribData = {
  const betaContribData = [];
  for (let i = 0; i < arrayAi.length; i++) {
    const Ai = arrayAi[i];
    const initialGi = arrayInitialGi[i];
    const initialBeta2 = computeBetai(Ai, initialGi)**2;
    const newGi = arrayNewGi[i];
    const newBeta2 = computeBetai(Ai, newGi)**2;
    betaContribData.push({ key: "Initial Gᵢ", class: i, value: initialGi });
    betaContribData.push({ key: "Initial βᵢ²", class: i, value: initialBeta2 });
    betaContribData.push({ key: "New Gᵢ", class: i, value: newGi });
    betaContribData.push({ key: "New βᵢ²", class: i, value: newBeta2 });
  }
  return betaContribData;
};
getInitialG = d => d.key === "Initial Gᵢ" ? d.value : NaN;
getInitialBeta2 = d => d.key === "Initial βᵢ²" ? d.value : NaN;
getNewG = d => d.key === "New Gᵢ" ? d.value : NaN;
getNewBeta2 = d => d.key === "New βᵢ²" ? d.value : NaN;

domainG = [0, Math.max(d3.max(arrayInitialGi), d3.max(arrayNewGi))];
rangeBeta2 = [
  0,
  Math.max(
    d3.max(betaContribData, getInitialBeta2),
    d3.max(betaContribData, getNewBeta2),
  ),
];
scaleG = d3.scaleLinear(domainG, rangeBeta2);
mapScaleG = x => x.map(scaleG);

paramInitialBeta = computeBeta(arrayAi, arrayInitialGi);
paramNewBeta = computeBeta(arrayAi, arrayNewGi);

stringInitialBeta = "Initial β = " + paramInitialBeta.toLocaleString(
  "en-GB",
  { minimumFractionDigits: 4, maximumFractionDigits: 4 },
);
stringNewBeta = "New β = " + paramNewBeta.toLocaleString(
  "en-GB",
  { minimumFractionDigits: 4, maximumFractionDigits: 4 },
);

Plot.plot({
  color: {
    legend: true,
    range: ["gray", "black", "blue", "red"],
    domain: ["Initial βᵢ²", "New βᵢ²", "Initial Gᵢ", "New Gᵢ"],
  },
  x: {
    ticks: d3.range(4),
    label: "Aᵢ Over 4 Classes",
    tickFormat: d => arrayAi[d],
  },
  y: { domain: rangeBeta2 },
  insetTop: 16,
  insetLeft: 8,
  insetRight: 8,
  marks: [
    Plot.frame(),
    Plot.axisY({ anchor: "left", label: "βᵢ²" }),
    Plot.axisY(scaleG.ticks(), { anchor: "right", label: "Gᵢ", y: scaleG }),
    Plot.rectY(betaContribData, {
      x1: d => d.class - 0.45,
      x2: d => d.class,
      y: getInitialBeta2,
      fill: "key",
    }),
    Plot.rectY(betaContribData, {
      x1: d => d.class,
      x2: d => d.class + 0.45,
      y: getNewBeta2,
      fill: "key",
    }),
    Plot.lineY(betaContribData, Plot.mapY(mapScaleG, {
      x: "class",
      y: getInitialG,
      stroke: "key",
      strokeDasharray: 4,
    })),
    Plot.dotY(betaContribData, Plot.mapY(mapScaleG, {
      x: "class",
      y: getInitialG,
      fill: "key",
    })),
    Plot.lineY(betaContribData, Plot.mapY(mapScaleG, {
      x: "class",
      y: getNewG,
      stroke: "key",
      strokeDasharray: 4,
    })),
    Plot.dotY(betaContribData, Plot.mapY(mapScaleG, {
      x: "class",
      y: getNewG,
      fill: "key",
    })),
    Plot.text([stringInitialBeta], { x: 0.5, y: 0.23, fill: d => "blue" }),
    Plot.text([stringNewBeta], { x: 2.5, y: 0.23, fill: d => "red" }),
  ],
});

Figure 17: Example of G allocation on \beta.

Figure 17 shows the effect of G allocation on \beta as a function of A allocation; that is to say that a large G_i stake on a small A_i stake has limited effects (notwithstanding other consequential factors).

3.3.3 Allocation of kVCM incentives

The full issuance of A tokens is depicted below, including now the A incentives for the liquidity pools.

Figure 18: A token flow structure.

3.3.4 Share of kVCM incentives

The kVCM incentives are shared between user-locked G tokens, AG. and AQ pools, with shares \lambda_{GG}, \lambda_G, and \lambda_Q respectively.

Defining:

• G_G: Total G tokens in the AG pool, expressed as a proportion of the outstanding supply of G.

• A_G: Total A tokens in the AG pool, expressed as a proportion of the outstanding supply of A.

• A_Q: Total A tokens in the AQ pool, expressed as a proportion of the outstanding supply of A.

The allocation to user-locked G tokens, \lambda_{GG}:

\lambda_{GG} = \frac{1 - A_Q}{1 + \left( \frac{\sum_{i=1}^{n}{G_i}}{G_G} \right)^2} \tag{21}

function computeLambdaGG(AQ, Gi, GG) {
  return (1 - AQ) / (1 + (Gi / GG)**2);
}

function changeTranslation(dx, dy) {
  return function () {
    const svgTransformList = this.transform.baseVal;
    if (svgTransformList.length > 1) {
      throw new Error("SVGTransformList must only contain one translation");
    }
    const {e, f} = svgTransformList.consolidate().matrix;
    return `translate(${e + dx},${f + dy})`;
  }
}

lambdaGGData = {
  const lambdaGGData = [];
  for (let paramGi = 0; paramGi < 1.01; paramGi += 0.1) {
    for (let paramAQ = 0; paramAQ < 1.01; paramAQ += 0.1) {
      lambdaGGData.push({
        key: "λ",
        aq: paramAQ,
        gi: paramGi,
        value: computeLambdaGG(paramAQ, paramGi, 1 - paramGi),
      });
    }
  }
  return lambdaGGData;
};

plotLambdaGG = {
  const plotLambdaGG = Plot.plot({
    color: {
      legend: true,
      scheme: "Spectral",
      domain: [0, 1],
      type: "sequential",
      label: "λ",
    },
    x: { ticks: d3.range(0, 1.01, 0.1), label: "A  " },
    y: { ticks: d3.range(0, 1.01, 0.1), domain: [1.05, -0.05], label: "Gᵢ" },
    marks: [
      Plot.frame(),
      Plot.rect(lambdaGGData, {
        x1: d => d.aq - 0.05,
        x2: d => d.aq + 0.05,
        y1: d => d.gi - 0.05,
        y2: d => d.gi + 0.05,
        fill: "value",
      }),
      Plot.text(lambdaGGData, {
        x: "aq",
        y: "gi",
        text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
          "en-GB",
          { minimumFractionDigits: 2, maximumFractionDigits: 2 },
        ),
        fill: d => contrastingTextColor(
          d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
        ),
      }),
    ],
  });

  d3.select(plotLambdaGG)
    .select("g[aria-label='x-axis label']")
    .select("text")
      .clone(false)
      .attr("transform", changeTranslation(-12, 1.5))
      .attr("font-size", "0.6em")
      .attr("font-weight", "600")
      .text("Q");

  return plotLambdaGG;
};

Figure 19: G stake allocation (assuming G_G = 1 - G_i).

Noting the relationship between G and \beta, and particularly if G = 0, \beta = 0.

The residual share, 1 - \lambda_{GG}, is split between the liquidity pools:

\lambda_G = (1 - \lambda_{GG}) \frac{2 A_G}{2 A_G + A_Q \sqrt 2} \tag{22}

For completeness:

\lambda_Q = 1 - \lambda_{GG} - \lambda_G \tag{23}

function computeLambdaG(AQ, AG) {
  return 2 * AG / (2 * AG + AQ * Math.sqrt(2));
}

function computeLambdaQ(AQ, AG) {
  return 1 - computeLambdaG(AQ, AG);
}

lambdaGQData = {
  const lambdaGQData = [];
  for (let paramAG = 0; paramAG < 1.01; paramAG += 0.1) {
    for (let paramAQ = 0; paramAQ < 1.01; paramAQ += 0.1) {
      if (paramAG + paramAQ < 1.01) {
        lambdaGQData.push({
          key: "Relative 𝗔𝗚 Liquidity Pool Share",
          aq: paramAQ,
          ag: paramAG,
          value: computeLambdaG(paramAQ, paramAG),
        });
        lambdaGQData.push({
          key: "Relative 𝗔𝗤 Liquidity Pool Share",
          aq: paramAQ,
          ag: paramAG,
          value: computeLambdaQ(paramAQ, paramAG),
        });
      }
    }
  }
  return lambdaGQData;
};

plotLambdaGQ = {
  const plotLambdaGQ = Plot.plot({
    aspectRatio: 1,
    color: {
      legend: true,
      scheme: "Spectral",
      domain: [0, 1],
      type: "sequential",
      label: "λ",
    },
    x: { ticks: d3.range(0, 1.01, 0.1), label: "A  " },
    y: {
      ticks: d3.range(0, 1.01, 0.1),
      domain: [1.05, -0.05],
      label: "A",
    },
    fx: { label: null },
    className: "LambdaGQ",
    marks: [
      Plot.frame(),
      Plot.rect(lambdaGQData, {
        x1: d => d.aq - 0.05,
        x2: d => d.aq + 0.05,
        y1: d => d.ag - 0.05,
        y2: d => d.ag + 0.05,
        fx: "key",
        fill: "value",
      }),
      Plot.text(lambdaGQData, {
        x: "aq",
        y: "ag",
        fx: "key",
        text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
          "en-GB",
          { minimumFractionDigits: 2, maximumFractionDigits: 2 },
        ),
        fill: d => contrastingTextColor(
          d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
        ),
      }),
    ],
  });

  d3.select(plotLambdaGQ)
    .select("g[aria-label='x-axis label']")
    .select("text")
    .clone(false)
      .attr("transform", changeTranslation(-12, 1.5))
      .attr("font-size", "0.6em")
      .attr("font-weight", "600")
      .text("Q");

  d3.select(plotLambdaGQ)
    .select("g[aria-label='y-axis label']")
    .select("text")
      .attr("transform", changeTranslation(0, 10))
    .clone(false)
      .attr("transform", changeTranslation(14, 4.1))
      .attr("font-size", "0.6em")
      .attr("font-weight", "600")
      .text("G");

  return plotLambdaGQ;
};

Figure 20: Liquidity pool split \lambda_G, \lambda_Q.

3.3.5 kVCM Incentives Distribution

For \lambda_{GG}, \lambda_G, \lambda_Q we apply \beta:

\Lambda_X = \lambda_X \, \beta, \quad \text{for } X \in \{GG, G, Q\} \tag{24}

Taking b as a discount parameter:

b = \frac{\sum_1^{40} Z_t \, S_t \, B_t}{\sum_1^{40} Z_t \, S_t } \tag{25}

The total kVCM incentive tokens R_\lambda:

R_\lambda = b \, R \, (\Lambda_{GG} + \Lambda_G + \Lambda_Q) \tag{26}

The allocations of R_\lambda are pro-rata to \Lambda_{GG}, \Lambda_G, \Lambda_Q, and thereafter:

1. Locked G: \Lambda_{GG} in proportion to G.

2. Locked AG, AQ tokens are allocated a weighting G_t, Q_t depending on their time bucket t:

   G_t = \frac{Z_t \, L_{Gt} \, B_t}{\sum Z_t \, L_{Gt} \, B_t} \tag{27}

   Q_t = \frac{Z_t \, L_{Qt} \, B_t}{\sum Z_t \, L_{Qt} \, B_t} \tag{28}

   Where L_{Gt}, L_{Qt} are the proportion of all liquidity locked in each time bucket for AG and AQ respectively.

Thereafter each time bucket allocation is proportionate to staked liquidity provider token holdings.

3.4 Interactive Model

This additional section is only in the interactive version of the whitepaper. It presents an interactive model where parameters of interest can be adjusted by the reader.

In Section 3.4.1, a carbon supplier swaps carbon to the protocol in exchange for A tokens; from the point of view of the protocol, this represents a carbon acquisition. In Section 3.4.2, a holder of A tokens burns them to retire carbon from the protocol; from the point of view of the protocol, this represents a carbon retirement.

3.4.1 kVCM Tokens Minted When the Protocol Acquires Carbon

In this section, the reader controls how many tonnes of carbon class i are acquired by the protocol. The number of A tokens emitted in exchange is calculated in real time. The price of carbon class i is calculated by dividing the number of A tokens emitted by the protocol by the number of tonnes purchased by the protocol.

function piecewiseLogTransform(xTran = 1) {
  return x => x > xTran ? Math.log(x) : x - xTran + Math.log(xTran);
}

function piecewiseLogInvert(xTran = 1) {
  return y => y > Math.log(xTran) ? Math.exp(y) : y - Math.log10(xTran) + xTran;
}

function setInput(input, value) {
  input.value = value;
  input.dispatchEvent(new Event("input", { bubbles: true }));
}

function numDigits(x) {
  return x === 0 ? 1 : (1 + Math.floor(Math.log10(x)));
}

defaultAValue = 2e6;
defaultASupply = 2e7;
defaultPresentTonnes = 1e7;
defaultDeltaTonnes = 1e2;
defaultAi = 0.5;
defaultGi = 0.5;

Inputs.button(
  [["Reset", () => {
    setInput(viewof inputAValue, defaultAValue);
    setInput(viewof inputASupply, defaultASupply);
    setInput(viewof inputPresentTonnes, defaultPresentTonnes);
    setInput(viewof inputDeltaTonnes, defaultDeltaTonnes);
    setInput(viewof inputAi, defaultAi);
    setInput(viewof inputGi, defaultGi);
  }]],
);

viewof inputAValue = Inputs.range([1e5, 1e9], {
  label: tex`\text{Market cap. of \textbf{A}}`,
  step: 1,
  value: defaultAValue,
  transform: Math.log,
});
viewof inputASupply = Inputs.range([1e6, 1e10], {
  label: tex`\text{Supply of \textbf{A}}`,
  step: 1,
  value: defaultASupply,
  transform: Math.log,
});
viewof inputPresentTonnes = Inputs.range([0, 1e9], {
  label: tex`\text{Inventory } C_i`,
  step: 1e-3,
  value: defaultPresentTonnes,
  transform: piecewiseLogTransform(1e-3),
  invert: piecewiseLogInvert(1e-3),
});
viewof inputDeltaTonnes = Inputs.range([1e-3, 1e7], {
  label: tex`\text{Purchased tonnes}`,
  step: 1e-3,
  value: defaultDeltaTonnes,
  transform: Math.log,
});
viewof inputAi = Inputs.range([0, 1], {
  label: tex`\text{Allocation } A_i`,
  step: 1e-6,
  value: defaultAi,
  transform: piecewiseLogTransform(1e-6),
  invert: piecewiseLogInvert(1e-6),
});
viewof inputGi = Inputs.range([0, 1], {
  label: tex`\text{Allocation } G_i`,
  step: 1e-6,
  value: defaultGi,
});

paramDeltaA = computeTrueDeltaA(
  inputAi,
  inputGi,
  inputPresentTonnes,
  inputDeltaTonnes,
);
paramDeltaTonnes = paramDeltaA === 0 ? 0 : inputDeltaTonnes;
paramAEmitted = paramDeltaA * inputASupply;
paramAPrice = inputAValue / inputASupply;
paramBarCiPrice = inputAValue * paramDeltaA / inputDeltaTonnes;

stringASupply = inputASupply.toLocaleString(
  "en-GB",
  {
    minimumFractionDigits: Math.max(0, 2 - numDigits(paramAEmitted)),
    maximumFractionDigits: Math.max(0, 2 - numDigits(paramAEmitted)),
  },
) + " kVCM";
stringPresentTonnes = inputPresentTonnes.toLocaleString(
  "en-GB",
  {
    minimumFractionDigits: Math.max(0, 3 - numDigits(paramDeltaTonnes)),
    maximumFractionDigits: Math.max(0, 3 - numDigits(paramDeltaTonnes)),
  },
) + " tCO2eq";
stringAEmitted = "+" + paramAEmitted.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, numDigits(paramAEmitted)),
    maximumSignificantDigits: Math.max(2, numDigits(paramAEmitted)),
  },
) + " kVCM";
stringDeltaTonnes = "+" + paramDeltaTonnes.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(3, numDigits(paramDeltaTonnes)),
    maximumSignificantDigits: Math.max(3, numDigits(paramDeltaTonnes)),
  },
) + " tCO2eq";
stringAPrice = "$" + paramAPrice.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, 2 + numDigits(paramAPrice)),
    maximumSignificantDigits: Math.max(2, 2 + numDigits(paramAPrice)),
  },
);
stringBarCiPrice = "$" + paramBarCiPrice.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, 2 + numDigits(paramBarCiPrice)),
    maximumSignificantDigits: Math.max(2, 2 + numDigits(paramBarCiPrice)),
  },
);

	Supply of A Tokens	Inventory Carbon
Total
Variation
Unit Price

3.4.2 Carbon Retired by the Protocol When it Burns kVCM Tokens

In this section, the reader controls how many A tokens are burnt by the protocol. The number of liquid tonnes retired by the protocol AAM in exchange is calculated in real time. The price of carbon is calculated by dividing the number of A tokens burnt by the protocol by the number of tonnes of carbon retired.

defaultLiquidTonnes = 1e7;
defaultABurnt = 1e2;
defaultGnull = 0.5;
defaultA = 0.5;
defaultS = 0.5;

Inputs.button(
  [["Reset", () => {
    setInput(viewof inputAValue_, defaultAValue);
    setInput(viewof inputASupply_, defaultASupply);
    setInput(viewof inputLiquidTonnes, defaultLiquidTonnes);
    setInput(viewof inputABurnt, defaultABurnt);
    setInput(viewof inputAi, defaultAi);
    setInput(viewof inputGi, defaultGi);
  }]],
);

viewof inputAValue_ = Inputs.range([1e5, 1e9], {
  label: tex`\text{Market cap. of \textbf{A}}`,
  step: 1,
  value: defaultAValue,
  transform: Math.log,
});
viewof inputASupply_ = Inputs.range([1e6, 1e10], {
  label: tex`\text{Supply of \textbf{A}}`,
  step: 1,
  value: defaultASupply,
  transform: Math.log,
});
viewof inputLiquidTonnes = Inputs.range([1e-3, 1e9], {
  label: tex`\text{Inventory } C_i`,
  step: 1e-3,
  value: defaultLiquidTonnes,
  transform: Math.log,
});
viewof inputABurnt = Inputs.range([1e-1, 1e6], {
  label: tex`\text{\textbf{A} tokens burnt}`,
  step: 1e-1,
  value: defaultABurnt,
  transform: Math.log,
});
Inputs.bind(
  Inputs.range([0, 1], {
    label: tex`\text{Allocation } A_i`,
    step: 1e-6,
    value: defaultAi,
    transform: piecewiseLogTransform(1e-6),
    invert: piecewiseLogInvert(1e-6),
  }),
  viewof inputAi,
);

Inputs.bind(
  Inputs.range([0, 1], {
    label: tex`\text{Allocation } G_i`,
    step: 1e-6,
    value: defaultGi,
  }),
  viewof inputGi,
);

paramABurnt = inputAi === 0 ? 0 : inputABurnt
paramDeltaA_ = paramABurnt / inputASupply_;
paramDeltaCi = inputAi === 0 ? -0 : computeDeltaCi(
  inputAi,
  inputGi,
  paramDeltaA_,
);
paramDeltaCiTonnes = -paramDeltaCi * inputLiquidTonnes;
paramAPrice_ = inputAValue_ / inputASupply_;
paramCiPrice = inputAi === 0 ? 0 : inputAValue_ * paramDeltaA_ / paramDeltaCiTonnes;

stringASupply_ = inputASupply_.toLocaleString(
  "en-GB",
  {
    minimumFractionDigits: Math.max(0, 2 - numDigits(paramABurnt)),
    maximumFractionDigits: Math.max(0, 2 - numDigits(paramABurnt)),
  },
) + " kVCM";
stringLiquidTonnes = inputLiquidTonnes.toLocaleString(
  "en-GB",
  {
    minimumFractionDigits: Math.max(0, 2 - numDigits(paramDeltaCiTonnes)),
    maximumFractionDigits: Math.max(0, 2 - numDigits(paramDeltaCiTonnes)),
  },
) + " tCO2eq";
stringABurnt = "−" + paramABurnt.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, numDigits(paramABurnt)),
    maximumSignificantDigits: Math.max(2, numDigits(paramABurnt)),
  },
) + " kVCM";
stringDeltaCiTonnes = "−" + paramDeltaCiTonnes.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, numDigits(paramDeltaCiTonnes)),
    maximumSignificantDigits: Math.max(2, numDigits(paramDeltaCiTonnes)),
  },
) + " tCO2eq";
stringAPrice_ = "$" + paramAPrice_.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, 2 + numDigits(paramAPrice_)),
    maximumSignificantDigits: Math.max(2, 2 + numDigits(paramAPrice_)),
  },
);
stringCiPrice = "$" + paramCiPrice.toLocaleString(
  "en-GB",
  {
    minimumSignificantDigits: Math.max(2, 2 + numDigits(paramCiPrice)),
    maximumSignificantDigits: Math.max(2, 2 + numDigits(paramCiPrice)),
  },
);

	Supply of A Tokens	Inventory Carbon
Total
Variation
Unit Price

4 Klima 2.0 Token Distribution

4.1 Planned Allocations

Cohort	Proportion	Quantity (m)
Klima Holders	87.5%	17.5
DAO/Treasury	10.0%	2.0
01X	2.5%	0.5
Total	100.0%	20.0

Table 3: kVCM token.

Cohort	Proportion	Quantity (m)	Liquidity
Klima Holders	40.0%	40.0	Logistic Vesting 48 months
Ecosystem Grant	5.0%	5.0	Logistic Vesting 48 months
Programmatic Incentives	40.0%	40.0	Incentive Curve
pKlima Holders	3.0%	3.0	Logistic Vesting 48 months
DAO/Treasury	4.5%	4.5	24 month locked LP of AG
01X	2.5%	2.5	24 month locked LP of AG
Product Design and Development	5.0%	5.0	Logistic Vesting 48 months
Total	100.0%	100.0

Table 4: K2 token.

allocInitGData = {
  const allocInitGData = [];
  for (let i = 0; i < 100.01; i += 0.25) {
    if (i < 2.51) {
      allocInitGData.push({ key: "01X", value: i });
    }
    if (2.49 < i && i < 5.51) {
      allocInitGData.push({ key: "pKlima Holders", value: i });
    }
    if (5.49 < i && i < 10.01) {
      allocInitGData.push({ key: "DAO/Treasury", value: i });
    }
    if (9.99 < i && i < 15.01) {
      allocInitGData.push({ key: "Ecosystem Grant", value: i });
    }
    if (14.99 < i && i < 20.01) {
      allocInitGData.push({ key: "Product Design", value: i });
    }
    if (19.99 < i && i < 60.01) {
      allocInitGData.push({ key: "Klima Holders", value: i });
    }
    if (59.99 < i) {
      allocInitGData.push({ key: "Incentives", value: i });
    }
  }
  return allocInitGData;
};
longitudeScale = d3.scaleLinear([180, -180]);
getCenter = d =>
        [1.25, 4, 7.75, 12.5, 17.5, 40, 80].includes(d.value) ? d.value : NaN;

cohortsDomain = [
  "Incentives",
  "Klima Holders",
  "Product Design",
  "Ecosystem Grant",
  "DAO/Treasury",
  "pKlima Holders",
  "01X",
];

Plot.plot({
  projection: { type: "azimuthal-equidistant", rotate: [0, -90], scale: 2 },
  color: { legend: true, range: d3.schemeCategory10, domain: cohortsDomain },
  marks: [
    Plot.area(allocInitGData, {
      x1: ({ value }) => longitudeScale(value / 100),
      y1: -20,
      x2: ({ value }) => longitudeScale(value / 100),
      y2: -70,
      fill: "key",
    }),
  ]
});

Figure 21: K2 token allocations.

4.2 Programmatic Incentive Curve

The incentive issuance is built on a logistic function, \operatorname{P}, to generate total proportion of supply in issue. It is calibrated from the initial issuance at TGE P_0 and the inflection point time T where 50% of G token incentives have been released.

Setting x_0 from the initial supply parameter:

x_0 = \ln\left( \frac{P_0}{1 - P_0} \right) \tag{29}

With x_t at time point t \in (0, \infty):

x_t = x_0 \, \left( 1 - \frac t T \right) \tag{30}

Giving supply function \operatorname{P}(t) as:

\operatorname{P}(t) = \frac{\exp(x_t)}{\exp(x_t) + 1} \tag{31}

P_0 set at and T at months:

viewof inputP0 = Inputs.range([0.01, 0.5], {
  label: tex`\text{Initial issuance } P_0`,
  step: 0.01,
  value: 0.07,
});
viewof inputT = Inputs.range([2, 60], {
  label: tex`T \text{ (months)}`,
  step: 1,
  value: 24,
});

stringInputP0 = inputP0.toLocaleString(
  "en-GB",
  { style: "percent", maximumFractionDigits: 0 },
);
stringInputT = inputT.toLocaleString("en-GB", { maximumFractionDigits: 0 });

function computeP(t, P0, T) {
  const x0 = Math.log(P0 / (1 - P0));
  const xt = x0 * (1 - t / T);
  const exp = Math.exp(xt);
  return exp / (exp + 1);
}

function computeDerivP(t, P0, T) {
  const x0 = Math.log(P0 / (1 - P0));
  const xt = x0 * (1 - t / T);
  const exp = Math.exp(xt);
  const P = exp / (1 + exp);
  return -(x0 / T) * P * (1 - P);
}

function getVesting(vecVesting, t, tStart, tEnd) {
  if (t < tStart)
    return 0;
  else if (t < tEnd) {
    return vecVesting[t - tStart];
  } else {
    return vecVesting[tEnd - tStart - 1];
  }
}

tVestStart = 3;
tVestEnd = 2 * inputT;
tVesting = d3.range(tVestStart, tVestEnd);
vecVestingDeriv = normalize(tVesting.map(t =>
  computeDerivP(t, inputP0, inputT)
));
vecVesting = d3.cumsum(vecVestingDeriv);

supplyDataAll = {
  let paramVestingPrevious = 0;
  const vecSupplyIncentives = [];
  const vecSupplyCirculating = [];
  const supplyData = [];
  for (let t = 0; t <= 72; t++) {
    const paramP = computeP(t, inputP0, inputT);
    const paramDerivP = computeDerivP(t, inputP0, inputT);
    const paramVesting = getVesting(vecVesting, t, tVestStart, tVestEnd);
    const paramVestingDiff = paramVesting - paramVestingPrevious;
    paramVestingPrevious = paramVesting;

    const supply01X = 2.5;
    const supplyPKlima = 3 * paramVesting;
    const supplyTreasury = 4.5;
    const supplyGrant = 5 * paramVesting;
    const supplyProduct = 5 * paramVesting;
    const supplyKlima = 40 * paramVesting;
    const supplyIncentives = 40 * paramP;
    vecSupplyIncentives.push(supplyIncentives);

    const supply01XStacked = supply01X;
    const supplyPKlimaStacked = supplyPKlima + supply01XStacked;
    const supplyTreasuryStacked = supplyTreasury + supplyPKlimaStacked;
    const supplyGrantStacked = supplyGrant + supplyTreasuryStacked;
    const supplyProductStacked = supplyProduct + supplyGrantStacked;
    const supplyKlimaStacked = supplyKlima + supplyProductStacked;
    const supplyIncentivesStacked = supplyIncentives + supplyKlimaStacked;
    const supplyCirculating = supplyIncentivesStacked / 100;
    vecSupplyCirculating.push(supplyIncentivesStacked);

    if (t <= 60) {
      const diffIncentives = 40 * (t === 0 ? inputP0 : paramDerivP);
      const diffKlima = 40 * paramVestingDiff;
      const diffProduct = 5 * paramVestingDiff;
      const diffGrant = 5 * paramVestingDiff;
      const diffPKlima = 3 * paramVestingDiff;
      const diffTreasury = t === 0 ? 4.5: 0;
      const diff01X = t === 0 ? 2.5 : 0;

      const diffIncentivesStacked = diffIncentives;
      const diffKlimaStacked = diffKlima + diffIncentivesStacked;
      const diffProductStacked = diffProduct + diffKlimaStacked;
      const diffGrantStacked = diffGrant + diffProductStacked;
      const diffPKlimaStacked = diffPKlima + diffGrantStacked;
      const diffTreasuryStacked = diffTreasury + diffPKlimaStacked;
      const diff01XStacked = diff01X + diffTreasuryStacked;

      supplyData.push({
        key: "Proportion of Supply",
        x: t,
        y: 100 * paramP,
      });
      supplyData.push({
        key: "Rate of Change",
        x: t,
        y: 100 * paramDerivP,
      });

      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "01X",
        x: t,
        y: supply01XStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "pKlima Holders",
        x: t,
        y: supplyPKlimaStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "DAO/Treasury",
        x: t,
        y: supplyTreasuryStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "Ecosystem Grant",
        x: t,
        y: supplyGrantStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "Product Design",
        x: t,
        y: supplyProductStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "Klima Holders",
        x: t,
        y: supplyKlimaStacked / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Stacked)",
        cohort: "Incentives",
        x: t,
        y: supplyIncentivesStacked / supplyCirculating,
      });

      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "01X",
        x: t,
        y: supply01X / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "pKlima Holders",
        x: t,
        y: supplyPKlima / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "DAO/Treasury",
        x: t,
        y: supplyTreasury / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "Ecosystem Grant",
        x: t,
        y: supplyGrant / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "Product Design",
        x: t,
        y: supplyProduct / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "Klima Holders",
        x: t,
        y: supplyKlima / supplyCirculating,
      });
      supplyData.push({
        key: "Circulating Supply (Unstacked)",
        cohort: "Incentives",
        x: t,
        y: supplyIncentives / supplyCirculating,
      });

      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "01X",
        x: t,
        y: supply01XStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "pKlima Holders",
        x: t,
        y: supplyPKlimaStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "DAO/Treasury",
        x: t,
        y: supplyTreasuryStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "Ecosystem Grant",
        x: t,
        y: supplyGrantStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "Product Design",
        x: t,
        y: supplyProductStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "Klima Holders",
        x: t,
        y: supplyKlimaStacked,
      });
      supplyData.push({
        key: "Total Supply (Stacked)",
        cohort: "Incentives",
        x: t,
        y: supplyIncentivesStacked,
      });

      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "01X",
        x: t,
        y: supply01X,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "pKlima Holders",
        x: t,
        y: supplyPKlima,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "DAO/Treasury",
        x: t,
        y: supplyTreasury,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "Ecosystem Grant",
        x: t,
        y: supplyGrant,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "Product Design",
        x: t,
        y: supplyProduct,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "Klima Holders",
        x: t,
        y: supplyKlima,
      });
      supplyData.push({
        key: "Total Supply (Unstacked)",
        cohort: "Incentives",
        x: t,
        y: supplyIncentives,
      });

      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "Incentives",
        x: t,
        y: diffIncentives,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "Klima Holders",
        x: t,
        y: diffKlima,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "Product Design",
        x: t,
        y: diffProduct,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "Ecosystem Grant",
        x: t,
        y: diffGrant,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "pKlima Holders",
        x: t,
        y: diffPKlima,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "DAO/Treasury",
        x: t,
        y: diffTreasury,
      });
      supplyData.push({
        key: "Total Supply Differential (Unstacked)",
        cohort: "01X",
        x: t,
        y: diff01X,
      });
    }
  }

  const vecNextYearIncentives = vecSupplyIncentives.map((val, t) =>
    vecSupplyIncentives[t + 12] - val);
  const vecAPY = vecSupplyCirculating.map((val, t) =>
    100 * (vecSupplyCirculating[t + 12] - val) / val);
  const vecAPR = vecSupplyCirculating.map((val, t) =>
    100 * (vecSupplyCirculating[t + 12] - vecNextYearIncentives[t] - val) / val);

  for (let t = 0; t <= 60; t++) {
    supplyData.push({ key: "APY", x: t, y: vecAPY[t] });
    supplyData.push({ key: "APR", x: t, y: vecAPR[t] });
  }
  return [
    vecSupplyIncentives,
    vecSupplyCirculating,
    supplyData,
    vecAPY,
    vecAPR,
  ];
}
vecSupplyIncentives = supplyDataAll[0];
vecSupplyCirculating = supplyDataAll[1];
supplyData = supplyDataAll[2];
vecAPY = supplyDataAll[3];
vecAPR = supplyDataAll[4];

getLogisticCurve = d => d.key === "Proportion of Supply" ? d.y : NaN;
getRateOfChange = d => d.key === "Rate of Change" ? d.y : NaN;
getCirculatingStacked = d =>
        d.key === "Circulating Supply (Stacked)" ? d.y : NaN;
getCirculatingUnstacked = d =>
        d.key === "Circulating Supply (Unstacked)" ? d.y : NaN;
getTotalStacked = d => d.key === "Total Supply (Stacked)" ? d.y : NaN;
getTotalUnstacked = d => d.key === "Total Supply (Unstacked)" ? d.y : NaN;
getDiffUnstacked = d =>
        d.key === "Total Supply Differential (Unstacked)" ? d.y : NaN;
getCohortCirculatingStacked = d =>
        d.key === "Circulating Supply (Stacked)" ? d.cohort : NaN;
getCohortCirculatingUnstacked = d =>
        d.key === "Circulating Supply (Unstacked)" ? d.cohort : NaN;
getCohortTotalStacked = d =>
        d.key === "Total Supply (Stacked)" ? d.cohort : NaN;
getCohortTotalUnstacked = d =>
        d.key === "Total Supply (Unstacked)" ? d.cohort : NaN;
getCohortDiffUnstacked = d =>
        d.key === "Total Supply Differential (Unstacked)" ? d.cohort : NaN;
getAPY = d => d.key === "APY" ? d.y : NaN;
getAPR = d => d.key === "APR" ? d.y : NaN;

domainRateOfChange = [0, d3.max(supplyData, getRateOfChange)];
scaleRateOfChange = d3.scaleLinear(domainRateOfChange, [0, 100]);
mapScaleRateOfChange = x => x.map(scaleRateOfChange);

stringP0 = "Initial Issuance P₀ = " + inputP0.toLocaleString(
  "en-GB",
  { style: "percent", maximumFractionDigits: 0 },
);
stringT = "Inflection Point Time T = " + inputT.toLocaleString(
  "en-GB",
  { maximumFractionDigits: 0 },
) + " months";

supplyParams = [
  { key: stringP0, x: 0.5, y: 100 * inputP0 },
  { key: stringT, x: inputT, y: 50 },
];

Plot.plot({
  color: {
    legend: true,
    range: [5, 7, 0, 2].map(i => d3.schemeCategory10[i]),
    domain: ["Proportion of Supply", "Rate of Change", stringP0, stringT],
  },
  x: {
    ticks: d3.range(0, 60.1, 12),
    label: "‘Life’ Span (Months)",
    grid: true,
  },
  y: { domain: [0, 100] },
  insetTop: 16,
  clip: true,
  marks: [
    Plot.frame(),
    Plot.axisY({ anchor: "left", label: "Proportion of Supply (%)" }),
    Plot.axisY(scaleRateOfChange.ticks(), {
      anchor: "right",
      tickFormat: scaleRateOfChange.tickFormat(),
      label: "Rate of Change (%/Month)",
      y: scaleRateOfChange
    }),
    Plot.lineY(supplyData, Plot.mapY(mapScaleRateOfChange, {
      x: "x",
      y: getRateOfChange,
      stroke: "key",
      strokeWidth : 2,
      strokeDasharray: 4,
    })),
    Plot.lineY(supplyData, {
      x: "x",
      y: getLogisticCurve,
      stroke: "key",
      strokeWidth : 2,
    }),
    Plot.areaY(supplyData, Plot.mapY(mapScaleRateOfChange, {
      x: "x",
      y: getRateOfChange,
      fill: "key",
      fillOpacity: 0.3,
    })),
    Plot.areaY(supplyData, {
      x: "x",
      y: getLogisticCurve,
      fill: "key",
      fillOpacity: 0.3,
    }),
    Plot.ruleX(supplyParams, {
      x: d => d.key === stringT ? d.x : NaN,
      y: "y",
      stroke: "key",
      strokeWidth : 2,
      strokeDasharray: 4,
    }),
    Plot.dotY(supplyParams, {
      x: "x",
      y: "y",
      r: 5,
      fill: "key",
    }),
  ]
});

Figure 22: Incentive Issuance

Plot.plot({
  color: { legend: true, range: d3.schemeCategory10, domain: cohortsDomain },
  x: { ticks: d3.range(0, 60.1, 12), label: "Time (Months)", grid: true },
  y: { domain: [0, 100], label: "Circulating Supply (%)", grid: true },
  clip: true,
  marks: [
    Plot.frame(),
    Plot.lineY(supplyData, {
      x: "x",
      y: getCirculatingStacked,
      stroke: getCohortCirculatingStacked,
      strokeWidth : 2,
    }),
    Plot.areaY(supplyData, {
      x: "x",
      y: getCirculatingUnstacked,
      fill: getCohortCirculatingUnstacked,
      fillOpacity: 0.5,
    }),
  ]
});

Figure 23: K2 token circulating supply over time.

Plot.plot({
  color: { legend: true, range: d3.schemeCategory10, domain: cohortsDomain },
  x: { ticks: d3.range(0, 60.1, 12), label: "Time (Months)", grid: true },
  y: { domain: [0, 100], label: "Total Supply (%)", grid: true },
  clip: true,
  marks: [
    Plot.frame(),
    Plot.lineY(supplyData, {
      x: "x",
      y: getTotalStacked,
      stroke: getCohortTotalStacked,
      strokeWidth : 2,
    }),
    Plot.areaY(supplyData, {
      x: "x",
      y: getTotalUnstacked,
      fill: getCohortTotalUnstacked,
      fillOpacity: 0.5,
    }),
  ]
})

(a) Total supply (stacked).

Plot.plot({
  color: { legend: true, range: d3.schemeCategory10, domain: cohortsDomain },
  x: { ticks: d3.range(0, 60.1, 12), label: "Time (Months)", grid: true },
  y: { label: "Total Supply (%)", grid: true },
  insetTop: 16,
  clip: true,
  marks: [
    Plot.frame(),
    Plot.lineY(supplyData, {
      x: "x",
      y: getTotalUnstacked,
      stroke: getCohortTotalUnstacked,
      strokeWidth : 2,
    }),
    Plot.areaY(supplyData, {
      x: "x",
      y1: 0,
      y2: getTotalUnstacked,
      fill: getCohortTotalUnstacked,
      fillOpacity: 0.2,
    }),
  ]
})

(b) Total supply (unstacked).

Figure 24: K2 token total supply over time.

Plot.plot({
  color: { legend: true, range: d3.schemeCategory10, domain: cohortsDomain },
  x: { ticks: d3.range(0, 60.1, 12), label: "Time (Months)", grid: true },
  y: { label: "Rate of Growth (%/Month)", grid: true },
  insetTop: 16,
  insetLeft: 8,
  insetRight: 8,
  clip: true,
  marks: [
    Plot.frame(),
    Plot.rectY(supplyData, {
      x1: d => d.x - 0.45,
      x2: d => d.x + 0.45,
      y: getDiffUnstacked,
      fill: getCohortDiffUnstacked,
    }),
  ]
});

Figure 25: K2 supply differential (stacked).

4.3 Share of K2 Incentives

Figure 26: K2 token incentive distribution structure.

The relative utilisation measurement factor \upsilon is calculated as follows.

Defining initially:

• G: Total G tokens staked expressed as a proportion of the circulating supply, G \in [0, 1].

• L: Total G tokens held in the AG pool expressed as a proportion of circulating supply, L \in (0, 1].

Where \upsilon = 0 if G + L = 0, otherwise:

\upsilon = \left( \frac{2 G L}{G^2 + L^2} \right)^2 \tag{32}

function computeUpsilon(G, L) {
  if (G === 0 && L === 0) {
    return 0;
  } else {
    return (2 * G * L / (G**2 + L**2))**2;
  }
}

upsilonData = {
  const upsilonData = [];
  for (let paramG = 0; paramG < 1.01; paramG += 0.05) {
    for (let paramL = 0; paramL < 1.01; paramL += 0.05) {
      if (paramG + paramL < 1.01) {
        upsilonData.push({
          key: "υ",
          l: paramL,
          g: paramG,
          value: computeUpsilon(paramG, paramL),
        });
      }
    }
  }
  return upsilonData;
};

Plot.plot({
  aspectRatio: 1,
  color: {
    legend: true,
    scheme: "Spectral",
    domain: [0, 1],
    type: "sequential",
    label: "Relative Utilisation υ",
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Liquidity L" },
  y: {
    ticks: d3.range(0, 1.01, 0.1),
    domain: [1.025, -0.025],
    label: "Stake G",
  },
  marks: [
    Plot.frame(),
    Plot.rect(upsilonData, {
      x1: d => d.l - 0.025,
      x2: d => d.l + 0.025,
      y1: d => d.g - 0.025,
      y2: d => d.g + 0.025,
      fill: "value",
    }),
    Plot.text(upsilonData, {
      x: "l",
      y: "g",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
      ),
    }),
  ],
});

Figure 27: Upsilon \upsilon range of values.

The absolute utilisation parameter \eta is defined as \eta = 0 if G + L = 0, otherwise:

\eta = \frac{2 G L}{G (1 - G) + L ( 1 - L)} \tag{33}

function computeEta(G, L) {
  if (G === 0 && L === 0) {
    return 0;
  } else {
    return 2 * G * L / (G * (1 - G) + L * (1 - L));
  }
}

etaData = {
  const etaData = [];
  for (let paramG = 0; paramG < 1.01; paramG += 0.05) {
    for (let paramL = 0; paramL < 1.01; paramL += 0.05) {
      if (paramG + paramL < 1.01) {
        etaData.push({
          key: "η",
          l: paramL,
          g: paramG,
          value: computeEta(paramG, paramL),
        });
      }
    }
  }
  return etaData;
};

Plot.plot({
  aspectRatio: 1,
  color: {
    legend: true,
    scheme: "Spectral",
    domain: [0, 1],
    type: "sequential",
    label: "Absolute Utilisation η",
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Liquidity L" },
  y: {
    ticks: d3.range(0, 1.01, 0.1),
    domain: [1.025, -0.025],
    label: "Stake G",
  },
  marks: [
    Plot.frame(),
    Plot.rect(etaData, {
      x1: d => d.l - 0.025,
      x2: d => d.l + 0.025,
      y1: d => d.g - 0.025,
      y2: d => d.g + 0.025,
      fill: "value",
    }),
    Plot.text(etaData, {
      x: "l",
      y: "g",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
      ),
    }),
  ],
});

Figure 28: Eta \eta range of values.

Incentives I are allocated as follows:

4.3.1 Treasury

The allocation to the Treasury I_T is the imbalance generated from \upsilon:

I_T = 1 - \upsilon \, \eta \tag{34}

4.3.2 Post Treasury

The residual post-treasury allocation is shared four ways within 2 buckets:

1. Time-locked A & user-locked G tokens

   Where S is the proportion of time-locked A tokens (as defined previously in Section 3.1.1):

   1. Time-locked A, I_S:

      I_S = S \, \frac{L^2}{G^2 + L^2} \tag{35}

   2. User-locked G, I_G:

      I_G = (1 - S) \, \frac{L^2}{G^2 + L^2} \tag{36}

2. Liquidity

   With \lambda_G, \lambda_Q, \lambda_{GG} as defined in Section 3.3.4:

   3. AG pool I_{AG}:

      I_{AG} = \frac{\lambda_G}{1 - \lambda_{GG}} \, \frac{G^2}{G^2 + L^2} \tag{37}

   4. AQ pool I_{AQ}:

      I_{AQ} = \frac{\lambda_Q}{1 - \lambda_{GG}} \, \frac{G^2}{G^2 + L^2} \tag{38}

viewof inputS_ = Inputs.range([0, 1], {
  label: tex`\text{Time-Locked } S`,
  step: 0.01,
  value: 0.5,
});

viewof inputWeightAG = Inputs.range([0, 1], {
  label: tex`\text{LP split}`,
  step: 0.01,
  value: 0.5,
});

paramWeightAQ = 1 - inputWeightAG;

function computeTreasury(G, L) {
  return Math.max(0, 1 - computeUpsilon(G, L) * computeEta(G, L));
}

function computeIBonds(G, L, S) {
  if (G === 0 && L === 0) {
    return 0;
  } else {
    return S * L**2 / (G**2 + L**2);
  }
}

function computeIStaking(G, L, S) {
  if (G === 0 && L === 0) {
    return 0;
  } else {
    return (1 - S) * L**2 / (G**2 + L**2);
  }
}

function computeIPool(G, L, weight) {
  if (G === 0 && L === 0) {
    return 0;
  } else {
    return weight * G**2 / (G**2 + L**2);
  }
}

allocationSQData = {
  const allocationSQData = [];
  for (let paramG = 0; paramG < 1.01; paramG += 0.1) {
    for (let paramL = 0; paramL < 1.01; paramL += 0.1) {
      if (paramG + paramL < 1.01) {
        allocationSQData.push({
          key: "𝗔 Time-locks Allocation",
          l: paramL,
          g: paramG,
          value: computeIBonds(paramG, paramL, inputS_),
        });
        allocationSQData.push({
          key: "𝗚 User-locks Allocation",
          l: paramL,
          g: paramG,
          value: computeIStaking(paramG, paramL, inputS_),
        });
      }
    }
  }
  return allocationSQData;
};

plotAllocationSQ = {
  const plotAllocationSQ = Plot.plot({
    aspectRatio: 1,
    color: {
      legend: true,
      scheme: "Spectral",
      domain: [0, 1],
      type: "sequential",
      label: "Allocation I",
    },
    x: { ticks: d3.range(0, 1.01, 0.1), label: "Liquidity L" },
    y: {
      ticks: d3.range(0, 1.01, 0.1),
      domain: [1.05, -0.05],
      label: "Stake G",
    },
    fx: { label: null },
    marks: [
      Plot.frame(),
      Plot.rect(allocationSQData, {
        x1: d => d.l - 0.05,
        x2: d => d.l + 0.05,
        y1: d => d.g - 0.05,
        y2: d => d.g + 0.05,
        fx: "key",
        fill: "value",
      }),
      Plot.text(allocationSQData, {
        x: "l",
        y: "g",
        fx: "key",
        text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
          "en-GB",
          { minimumFractionDigits: 2, maximumFractionDigits: 2 },
        ),
        fill: d => contrastingTextColor(
          d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
        ),
      }),
    ],
  });

  d3.select(plotAllocationSQ)
    .select("g[aria-label='y-axis label']")
    .select("text")
      .attr("transform", changeTranslation(0, 10));

  return plotAllocationSQ;
};

(a) Time-locked A and user-locked G allocations.

allocationPoolData = {
  const allocationPoolData = [];
  for (let paramG = 0; paramG < 1.01; paramG += 0.1) {
    for (let paramL = 0; paramL < 1.01; paramL += 0.1) {
      if (paramG + paramL < 1.01) {
        allocationPoolData.push({
          key: "𝗔𝗚 Pool Allocation",
          l: paramL,
          g: paramG,
          value: computeIPool(paramG, paramL, inputWeightAG),
        });
        allocationPoolData.push({
          key: "𝗔𝗤 Pool Allocation",
          l: paramL,
          g: paramG,
          value: computeIPool(paramG, paramL, paramWeightAQ),
        });
      }
    }
  }
  return allocationPoolData;
};

plotAllocationPool = {
  const plotAllocationPool = Plot.plot({
    aspectRatio: 1,
    color: {
      legend: true,
      scheme: "Spectral",
      domain: [0, 1],
      type: "sequential",
      label: "Allocation I",
    },
    x: { ticks: d3.range(0, 1.01, 0.1), label: "Liquidity L" },
    y: {
      ticks: d3.range(0, 1.01, 0.1),
      domain: [1.05, -0.05],
      label: "Stake G",
    },
    fx: { label: null },
    marks: [
      Plot.frame(),
      Plot.rect(allocationPoolData, {
        x1: d => d.l - 0.05,
        x2: d => d.l + 0.05,
        y1: d => d.g - 0.05,
        y2: d => d.g + 0.05,
        fx: "key",
        fill: "value",
      }),
      Plot.text(allocationPoolData, {
        x: "l",
        y: "g",
        fx: "key",
        text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
          "en-GB",
          { minimumFractionDigits: 2, maximumFractionDigits: 2 },
        ),
        fill: d => contrastingTextColor(
          d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
        ),
      }),
    ],
  });

  d3.select(plotAllocationPool)
    .select("g[aria-label='y-axis label']")
    .select("text")
      .attr("transform", changeTranslation(0, 10));

  return plotAllocationPool;
};

(b) Liquidity pools allocations.

Figure 29: Share of non-treasury incentives I_S, I_G, I_{AG} and I_{AQ}.

treasuryData = {
  const treasuryData = [];
  for (let paramG = 0; paramG < 1.01; paramG += 0.05) {
    for (let paramL = 0; paramL < 1.01; paramL += 0.05) {
      if (paramG + paramL < 1.01) {
        treasuryData.push({
          key: "I_T",
          l: paramL,
          g: paramG,
          value: computeTreasury(paramG, paramL),
        });
      }
    }
  }
  return treasuryData;
};

Plot.plot({
  aspectRatio: 1,
  color: {
    legend: true,
    scheme: "Spectral",
    domain: [0, 1],
    type: "sequential",
    label: "Allocation I",
  },
  x: { ticks: d3.range(0, 1.01, 0.1), label: "Liquidity L" },
  y: {
    ticks: d3.range(0, 1.01, 0.1),
    domain: [1.025, -0.025],
    label: "Stake G",
  },
  marks: [
    Plot.frame(),
    Plot.rect(treasuryData, {
      x1: d => d.l - 0.025,
      x2: d => d.l + 0.025,
      y1: d => d.g - 0.025,
      y2: d => d.g + 0.025,
      fill: "value",
    }),
    Plot.text(treasuryData, {
      x: "l",
      y: "g",
      text: d => Number.isNaN(d.value) ? "" : d.value.toLocaleString(
        "en-GB",
        { minimumFractionDigits: 2, maximumFractionDigits: 2 },
      ),
      fill: d => contrastingTextColor(
        d3.scaleSequential([0, 1], d3.interpolateSpectral)(d.value),
      ),
    }),
  ],
})

Figure 30: Treasury incentives I_T.

Footnotes

1. Note the development of liquidity pool pricing functionality may be applicable.