Skip to content

Feat/recycle burn chain exts #2560

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
LandynDev wants to merge 9 commits into
base: devnet-ready
Choose a base branch
from
Open

Feat/recycle burn chain exts #2560

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
dda99da
Burn and Recycle Chain Exts
LandynDev Apr 1, 2026
8ebf234
Remove debug logging from chain extension dispatch
LandynDev Apr 1, 2026
94796b0
Additional unit tests: Root burn test, Zero amt test, Amount clamping…
LandynDev Apr 3, 2026
1c4f180
cargo fmt fix
LandynDev Apr 7, 2026
65357d3
Address review: remove redundant clamping, add atomicity
LandynDev Apr 7, 2026
60dffb3
Return actual recycled/burned alpha amount from pallet
LandynDev Apr 8, 2026
757fe29
Use pallet WeightInfo trait for recycle/burn chain extensions
LandynDev Apr 14, 2026
0216e94
Charge second-stage weight only when stage is reached
LandynDev Apr 14, 2026
089a24a
Fix CI: rustfmt wrap and forbid-saturating-math in mock
LandynDev Apr 14, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
176 changes: 176 additions & 0 deletions chain-extensions/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,11 +9,13 @@ pub mod types;

use crate::types::{FunctionId, Output};
use codec::{Decode, Encode, MaxEncodedLen};
use frame_support::storage::{TransactionOutcome, transactional};
use frame_support::{DebugNoBound, traits::Get};
use frame_system::RawOrigin;
use pallet_contracts::chain_extension::{
BufInBufOutState, ChainExtension, Environment, Ext, InitState, RetVal, SysConfig,
};
use pallet_subtensor::weights::WeightInfo as SubtensorWeightInfo;
use pallet_subtensor_proxy as pallet_proxy;
use pallet_subtensor_proxy::WeightInfo;
use sp_runtime::{DispatchError, Weight, traits::StaticLookup};
Expand Down Expand Up @@ -523,6 +525,180 @@ where

Ok(RetVal::Converging(Output::Success as u32))
}
FunctionId::RecycleAlphaV1 => {
let weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::recycle_alpha();

env.charge_weight(weight)?;

let (hotkey, amount, netuid): (T::AccountId, AlphaBalance, NetUid) =
Copy link
Copy Markdown
Collaborator

@evgeny-s evgeny-s Apr 16, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Can we make arguments order consistent with AddStakeRecycleV1?

env.read_as()?;

let caller = env.caller();

let call_result = pallet_subtensor::Pallet::<T>::do_recycle_alpha(
RawOrigin::Signed(caller).into(),
hotkey,
amount,
netuid,
);

match call_result {
Ok(real_amount) => {
env.write_output(&real_amount.encode())
.map_err(|_| DispatchError::Other("Failed to write output"))?;
Ok(RetVal::Converging(Output::Success as u32))
}
Err(e) => {
let error_code = Output::from(e) as u32;
Ok(RetVal::Converging(error_code))
}
}
}
FunctionId::BurnAlphaV1 => {
let weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::burn_alpha();

env.charge_weight(weight)?;

let (hotkey, amount, netuid): (T::AccountId, AlphaBalance, NetUid) =
env.read_as()?;

let caller = env.caller();

let call_result = pallet_subtensor::Pallet::<T>::do_burn_alpha(
RawOrigin::Signed(caller).into(),
hotkey,
amount,
netuid,
);

match call_result {
Ok(real_amount) => {
env.write_output(&real_amount.encode())
.map_err(|_| DispatchError::Other("Failed to write output"))?;
Ok(RetVal::Converging(Output::Success as u32))
}
Err(e) => {
let error_code = Output::from(e) as u32;
Ok(RetVal::Converging(error_code))
}
}
}
FunctionId::AddStakeRecycleV1 => {
let add_stake_weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::add_stake(
);
let recycle_weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::recycle_alpha();

env.charge_weight(add_stake_weight)?;

let (hotkey, netuid, tao_amount): (T::AccountId, NetUid, TaoBalance) =
env.read_as()?;

let caller = env.caller();

let mut recycle_attempted = false;

let result: Result<AlphaBalance, DispatchError> =
transactional::with_transaction(|| {
let alpha = match pallet_subtensor::Pallet::<T>::do_add_stake(
RawOrigin::Signed(caller.clone()).into(),
hotkey.clone(),
netuid,
tao_amount,
) {
Ok(a) => a,
Err(e) => return TransactionOutcome::Rollback(Err(e)),
};

recycle_attempted = true;

match pallet_subtensor::Pallet::<T>::do_recycle_alpha(
RawOrigin::Signed(caller).into(),
hotkey,
alpha,
netuid,
) {
Ok(real_alpha) => TransactionOutcome::Commit(Ok(real_alpha)),
Err(e) => TransactionOutcome::Rollback(Err(e)),
}
});

if recycle_attempted {
env.charge_weight(recycle_weight)?;
}

match result {
Ok(alpha) => {
env.write_output(&alpha.encode())
.map_err(|_| DispatchError::Other("Failed to write output"))?;
Ok(RetVal::Converging(Output::Success as u32))
}
Err(e) => {
let error_code = Output::from(e) as u32;
Ok(RetVal::Converging(error_code))
}
}
}
FunctionId::AddStakeBurnV1 => {
let add_stake_weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::add_stake(
);
let burn_weight =
<<T as pallet_subtensor::Config>::WeightInfo as SubtensorWeightInfo>::burn_alpha();

env.charge_weight(add_stake_weight)?;

let (hotkey, netuid, tao_amount): (T::AccountId, NetUid, TaoBalance) =
env.read_as()?;

let caller = env.caller();

let mut burn_attempted = false;

let result: Result<AlphaBalance, DispatchError> =
transactional::with_transaction(|| {
let alpha = match pallet_subtensor::Pallet::<T>::do_add_stake(
RawOrigin::Signed(caller.clone()).into(),
hotkey.clone(),
netuid,
tao_amount,
) {
Ok(a) => a,
Err(e) => return TransactionOutcome::Rollback(Err(e)),
};

burn_attempted = true;

match pallet_subtensor::Pallet::<T>::do_burn_alpha(
RawOrigin::Signed(caller).into(),
hotkey,
alpha,
netuid,
) {
Ok(real_alpha) => TransactionOutcome::Commit(Ok(real_alpha)),
Err(e) => TransactionOutcome::Rollback(Err(e)),
}
});

if burn_attempted {
env.charge_weight(burn_weight)?;
}

match result {
Ok(alpha) => {
env.write_output(&alpha.encode())
.map_err(|_| DispatchError::Other("Failed to write output"))?;
Ok(RetVal::Converging(Output::Success as u32))
}
Err(e) => {
let error_code = Output::from(e) as u32;
Ok(RetVal::Converging(error_code))
}
}
}
}
}
}
Expand Down
Loading
Loading