Merkle airdrop pallet

Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "pallets/faucet",
     "pallets/qpow",
     "pallets/wormhole",
+    "pallets/merkle-airdrop",
     "primitives/faucet",
     "primitives/consensus/qpow",
     "primitives/crypto/wormhole",
@@ -112,6 +113,7 @@ sp-storage = { version = "22.0.0", default-features = false }
 sp-transaction-pool = { version = "35.0.0", default-features = false }
 sp-version = { version = "38.0.0", default-features = false }
 substrate-wasm-builder = { version = "25.0.0", default-features = false }
+pallet-merkle-airdrop = { version = "0.1.0", path = "./pallets/merkle-airdrop", default-features = false }
 
 log = { version = "0.4.22", default-features = false }
 hex = {version = "0.4.3", default-features = false }

pallets/merkle-airdrop/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "pallet-merkle-airdrop"
+description = "A pallet for distributing tokens via Merkle proofs"
+version = "0.1.0"
+license = "MIT-0"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+edition.workspace = true
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true, default-features = false, features = ["derive"] }
+scale-info = { workspace = true, default-features = false, features = ["derive"] }
+frame-benchmarking = { optional = true, workspace = true }
+frame-support.workspace = true
+frame-system.workspace = true
+pallet-balances.workspace = true
+sp-runtime.workspace = true
+sp-core.workspace = true
+sp-io.workspace = true
+log = { version = "0.4.22", default-features = false }
+sha2 = { version = "0.10", default-features = false }
+binary-merkle-tree = { version = "16.0.0", default-features = false }
+poseidon-resonance = { workspace = true, default-features = false }
+
+[dev-dependencies]
+sp-core = { default-features = true, workspace = true }
+sp-io = { default-features = true, workspace = true }
+sp-runtime = { default-features = true, workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-benchmarking?/std",
+    "frame-support/std",
+    "frame-system/std",
+    "scale-info/std",
+    "sp-runtime/std",
+    "sp-core/std",
+    "sp-io/std",
+    "pallet-balances/std",
+    "sha2/std",
+    "binary-merkle-tree/std",
+    "poseidon-resonance/std",
+]
+runtime-benchmarks = [
+    "frame-benchmarking/runtime-benchmarks",
+    "frame-support/runtime-benchmarks",
+    "frame-system/runtime-benchmarks",
+]
+try-runtime = [
+    "frame-support/try-runtime",
+    "frame-system/try-runtime",
+] 

pallets/merkle-airdrop/README.md

@@ -0,0 +1,14 @@
+# Merkle Airdrop Pallet
+
+A Substrate pallet for distributing tokens via Merkle proofs.
+
+## Testing & Usage
+
+For testing and interacting with this pallet, please refer to the CLI tool and example in the [resonance-api-client](https://github.com/Quantus-Network/resonance-api-client/blob/master/examples/async/examples/merkle-airdrop-README.md) repository:
+- `examples/ac-examples-async/examples/merkle_airdrop_cli.rs`
+- `examples/ac-examples-async/examples/merkle_airdrop_cli-README.md` for the documentation
+
+These tool demonstrates how to:
+- Generate Merkle trees and proofs
+- Create and fund airdrops
+- Claim tokens using proofs

pallets/merkle-airdrop/src/benchmarking.rs

@@ -0,0 +1,118 @@
+//! Benchmarking setup for pallet-merkle-airdrop
+
+use super::*;
+
+#[allow(unused)]
+use crate::Pallet as MerkleAirdrop;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+extern crate alloc;
+use alloc::vec;
+use frame_support::traits::fungible::{Inspect, Mutate};
+use frame_support::BoundedVec;
+use sp_runtime::traits::Saturating;
+
+#[benchmarks]
+mod benchmarks {
+    use super::*;
+
+    #[benchmark]
+    fn create_airdrop() {
+        let caller: T::AccountId = whitelisted_caller();
+        let merkle_root = [0u8; 32];
+
+        #[extrinsic_call]
+        create_airdrop(RawOrigin::Signed(caller), merkle_root);
+    }
+
+    #[benchmark]
+    fn fund_airdrop() {
+        let caller: T::AccountId = whitelisted_caller();
+        let merkle_root = [0u8; 32];
+
+        let airdrop_id = MerkleAirdrop::<T>::next_airdrop_id();
+        AirdropMerkleRoots::<T>::insert(airdrop_id, merkle_root);
+        AirdropCreators::<T>::insert(airdrop_id, caller.clone());
+        NextAirdropId::<T>::put(airdrop_id + 1);
+
+        let amount: BalanceOf<T> = 1u32.into();
+
+        // Get ED and ensure caller has sufficient balance
+        let ed = <T::Currency as Inspect<T::AccountId>>::minimum_balance();
+
+        let caller_balance = ed.saturating_mul(10u32.into()).saturating_add(amount);
+        <T::Currency as Mutate<T::AccountId>>::set_balance(&caller, caller_balance);
+
+        <T::Currency as Mutate<T::AccountId>>::set_balance(&MerkleAirdrop::<T>::account_id(), ed);
+
+        #[extrinsic_call]
+        fund_airdrop(RawOrigin::Signed(caller), airdrop_id, amount);
+    }
+
+    #[benchmark]
+    fn claim() {
+        let caller: T::AccountId = whitelisted_caller();
+        let recipient: T::AccountId = whitelisted_caller();
+
+        let amount: BalanceOf<T> = 1u32.into();
+
+        let leaf_hash = MerkleAirdrop::<T>::calculate_leaf_hash_blake2(&recipient, amount);
+        let merkle_root = leaf_hash;
+
+        let airdrop_id = MerkleAirdrop::<T>::next_airdrop_id();
+        AirdropMerkleRoots::<T>::insert(airdrop_id, merkle_root);
+        NextAirdropId::<T>::put(airdrop_id + 1);
+
+        let ed = <T::Currency as Inspect<T::AccountId>>::minimum_balance();
+        let large_balance = ed.saturating_mul(1_000_000u32.into());
+
+        <T::Currency as Mutate<T::AccountId>>::set_balance(&caller, large_balance);
+        <T::Currency as Mutate<T::AccountId>>::set_balance(&recipient, large_balance);
+        <T::Currency as Mutate<T::AccountId>>::set_balance(
+            &MerkleAirdrop::<T>::account_id(),
+            large_balance,
+        );
+
+        AirdropBalances::<T>::insert(airdrop_id, large_balance);
+
+        let empty_proof = vec![];
+        let merkle_proof = BoundedVec::<MerkleHash, T::MaxProofs>::try_from(empty_proof)
+            .expect("Empty proof should fit in bound");
+
+        #[extrinsic_call]
+        claim(RawOrigin::None, airdrop_id, recipient, amount, merkle_proof);
+    }
+
+    #[benchmark]
+    fn delete_airdrop() {
+        let caller: T::AccountId = whitelisted_caller();
+        let merkle_root = [0u8; 32];
+
+        // Create an airdrop first
+        let airdrop_id = MerkleAirdrop::<T>::next_airdrop_id();
+        AirdropMerkleRoots::<T>::insert(airdrop_id, merkle_root);
+        AirdropCreators::<T>::insert(airdrop_id, caller.clone());
+        NextAirdropId::<T>::put(airdrop_id + 1);
+
+        let ed = <T::Currency as Inspect<T::AccountId>>::minimum_balance();
+        let tiny_amount: BalanceOf<T> = 1u32.into();
+        let large_balance = ed.saturating_mul(1_000_000u32.into());
+
+        <T::Currency as Mutate<T::AccountId>>::set_balance(&caller, large_balance);
+        <T::Currency as Mutate<T::AccountId>>::set_balance(
+            &MerkleAirdrop::<T>::account_id(),
+            large_balance,
+        );
+
+        AirdropBalances::<T>::insert(airdrop_id, tiny_amount);
+
+        #[extrinsic_call]
+        delete_airdrop(RawOrigin::Signed(caller), airdrop_id);
+    }
+
+    impl_benchmark_test_suite!(
+        MerkleAirdrop,
+        crate::mock::new_test_ext(),
+        crate::mock::Test
+    );
+}