feat: Rebrand Polkadot/Substrate references to PezkuwiChain

This commit systematically rebrands various references from Parity Technologies'
Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk.

Key changes include:
- Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks.
- Modified internal documentation and code comments to reflect PezkuwiChain naming and structure.
- Replaced direct references to  with  or specific paths within the  for XCM, Pezkuwi, and other modules.
- Cleaned up deprecated  issue and PR references in various  and  files, particularly in  and  modules.
- Adjusted image and logo URLs in documentation to point to PezkuwiChain assets.
- Removed or rephrased comments related to external Polkadot/Substrate PRs and issues.

This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.

bizinikiwi/pezframe/atomic-swap/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "pezpallet-atomic-swap"
+version = "28.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "FRAME atomic swap pallet"
+readme = "README.md"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame = { workspace = true, features = ["runtime"] }
+scale-info = { features = ["derive"], workspace = true }
+
+[dev-dependencies]
+pezpallet-balances = { workspace = true, default-features = true }
+
+[features]
+default = ["std"]
+std = ["codec/std", "frame/std", "pezpallet-balances/std", "scale-info/std"]
+try-runtime = ["frame/try-runtime", "pezpallet-balances/try-runtime"]
+runtime-benchmarks = [
+	"frame/runtime-benchmarks",
+	"pezpallet-balances/runtime-benchmarks",
+]

bizinikiwi/pezframe/atomic-swap/README.md

@@ -0,0 +1,23 @@
+# Atomic Swap
+
+A module for atomically sending funds.
+
+- [`atomic_swap::Config`](https://docs.rs/pezpallet-atomic-swap/latest/pallet_atomic_swap/trait.Config.html)
+- [`Call`](https://docs.rs/pezpallet-atomic-swap/latest/pallet_atomic_swap/enum.Call.html)
+- [`Module`](https://docs.rs/pezpallet-atomic-swap/latest/pallet_atomic_swap/struct.Module.html)
+
+## Overview
+
+A module for atomically sending funds from an origin to a target. A proof
+is used to allow the target to approve (claim) the swap. If the swap is not
+claimed within a specified duration of time, the sender may cancel it.
+
+## Interface
+
+### Dispatchable Functions
+
+- `create_swap` - called by a sender to register a new atomic swap
+- `claim_swap` - called by the target to approve a swap
+- `cancel_swap` - may be called by a sender after a specified duration
+
+License: Apache-2.0

bizinikiwi/pezframe/atomic-swap/src/lib.rs

@@ -0,0 +1,362 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Atomic Swap
+//!
+//! A pallet for atomically sending funds.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! A pallet for atomically sending funds from an origin to a target. A proof
+//! is used to allow the target to approve (claim) the swap. If the swap is not
+//! claimed within a specified duration of time, the sender may cancel it.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! * [`create_swap`](Call::create_swap) - called by a sender to register a new atomic swap
+//! * [`claim_swap`](Call::claim_swap) - called by the target to approve a swap
+//! * [`cancel_swap`](Call::cancel_swap) - may be called by a sender after a specified duration
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod tests;
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use codec::{Decode, DecodeWithMemTracking, Encode};
+use core::{
+	marker::PhantomData,
+	ops::{Deref, DerefMut},
+};
+use frame::{
+	prelude::*,
+	traits::{BalanceStatus, Currency, ReservableCurrency},
+};
+use scale_info::TypeInfo;
+
+/// Pending atomic swap operation.
+#[derive(
+	Clone,
+	Eq,
+	PartialEq,
+	RuntimeDebugNoBound,
+	Encode,
+	Decode,
+	DecodeWithMemTracking,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound())]
+pub struct PendingSwap<T: Config> {
+	/// Source of the swap.
+	pub source: T::AccountId,
+	/// Action of this swap.
+	pub action: T::SwapAction,
+	/// End block of the lock.
+	pub end_block: BlockNumberFor<T>,
+}
+
+/// Hashed proof type.
+pub type HashedProof = [u8; 32];
+
+/// Definition of a pending atomic swap action. It contains the following three phrases:
+///
+/// - **Reserve**: reserve the resources needed for a swap. This is to make sure that **Claim**
+/// succeeds with best efforts.
+/// - **Claim**: claim any resources reserved in the first phrase.
+/// - **Cancel**: cancel any resources reserved in the first phrase.
+pub trait SwapAction<AccountId, T: Config> {
+	/// Reserve the resources needed for the swap, from the given `source`. The reservation is
+	/// allowed to fail. If that is the case, the the full swap creation operation is cancelled.
+	fn reserve(&self, source: &AccountId) -> DispatchResult;
+	/// Claim the reserved resources, with `source` and `target`. Returns whether the claim
+	/// succeeds.
+	fn claim(&self, source: &AccountId, target: &AccountId) -> bool;
+	/// Weight for executing the operation.
+	fn weight(&self) -> Weight;
+	/// Cancel the resources reserved in `source`.
+	fn cancel(&self, source: &AccountId);
+}
+
+/// A swap action that only allows transferring balances.
+#[derive(
+	Clone,
+	RuntimeDebug,
+	Eq,
+	PartialEq,
+	Encode,
+	Decode,
+	DecodeWithMemTracking,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(C))]
+#[codec(mel_bound())]
+pub struct BalanceSwapAction<AccountId, C: ReservableCurrency<AccountId>> {
+	value: <C as Currency<AccountId>>::Balance,
+	_marker: PhantomData<C>,
+}
+
+impl<AccountId, C> BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	/// Create a new swap action value of balance.
+	pub fn new(value: <C as Currency<AccountId>>::Balance) -> Self {
+		Self { value, _marker: PhantomData }
+	}
+}
+
+impl<AccountId, C> Deref for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	type Target = <C as Currency<AccountId>>::Balance;
+
+	fn deref(&self) -> &Self::Target {
+		&self.value
+	}
+}
+
+impl<AccountId, C> DerefMut for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.value
+	}
+}
+
+impl<T: Config, AccountId, C> SwapAction<AccountId, T> for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	fn reserve(&self, source: &AccountId) -> DispatchResult {
+		C::reserve(source, self.value)
+	}
+
+	fn claim(&self, source: &AccountId, target: &AccountId) -> bool {
+		C::repatriate_reserved(source, target, self.value, BalanceStatus::Free).is_ok()
+	}
+
+	fn weight(&self) -> Weight {
+		T::DbWeight::get().reads_writes(1, 1)
+	}
+
+	fn cancel(&self, source: &AccountId) {
+		C::unreserve(source, self.value);
+	}
+}
+
+pub use pallet::*;
+
+#[frame::pallet]
+pub mod pallet {
+	use super::*;
+
+	/// Atomic swap's pallet configuration trait.
+	#[pallet::config]
+	pub trait Config: pezframe_system::Config {
+		/// The overarching event type.
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
+		/// Swap action.
+		type SwapAction: SwapAction<Self::AccountId, Self> + Parameter + MaxEncodedLen;
+		/// Limit of proof size.
+		///
+		/// Atomic swap is only atomic if once the proof is revealed, both parties can submit the
+		/// proofs on-chain. If A is the one that generates the proof, then it requires that either:
+		/// - A's blockchain has the same proof length limit as B's blockchain.
+		/// - Or A's blockchain has shorter proof length limit as B's blockchain.
+		///
+		/// If B sees A is on a blockchain with larger proof length limit, then it should kindly
+		/// refuse to accept the atomic swap request if A generates the proof, and asks that B
+		/// generates the proof instead.
+		#[pallet::constant]
+		type ProofLimit: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub type PendingSwaps<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Blake2_128Concat,
+		HashedProof,
+		PendingSwap<T>,
+	>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Swap already exists.
+		AlreadyExist,
+		/// Swap proof is invalid.
+		InvalidProof,
+		/// Proof is too large.
+		ProofTooLarge,
+		/// Source does not match.
+		SourceMismatch,
+		/// Swap has already been claimed.
+		AlreadyClaimed,
+		/// Swap does not exist.
+		NotExist,
+		/// Claim action mismatch.
+		ClaimActionMismatch,
+		/// Duration has not yet passed for the swap to be cancelled.
+		DurationNotPassed,
+	}
+
+	/// Event of atomic swap pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Swap created.
+		NewSwap { account: T::AccountId, proof: HashedProof, swap: PendingSwap<T> },
+		/// Swap claimed. The last parameter indicates whether the execution succeeds.
+		SwapClaimed { account: T::AccountId, proof: HashedProof, success: bool },
+		/// Swap cancelled.
+		SwapCancelled { account: T::AccountId, proof: HashedProof },
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Register a new atomic swap, declaring an intention to send funds from origin to target
+		/// on the current blockchain. The target can claim the fund using the revealed proof. If
+		/// the fund is not claimed after `duration` blocks, then the sender can cancel the swap.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: Receiver of the atomic swap.
+		/// - `hashed_proof`: The blake2_256 hash of the secret proof.
+		/// - `balance`: Funds to be sent from origin.
+		/// - `duration`: Locked duration of the atomic swap. For safety reasons, it is recommended
+		///   that the revealer uses a shorter duration than the counterparty, to prevent the
+		///   situation where the revealer reveals the proof too late around the end block.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1).ref_time().saturating_add(40_000_000))]
+		pub fn create_swap(
+			origin: OriginFor<T>,
+			target: T::AccountId,
+			hashed_proof: HashedProof,
+			action: T::SwapAction,
+			duration: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			ensure!(
+				!PendingSwaps::<T>::contains_key(&target, hashed_proof),
+				Error::<T>::AlreadyExist
+			);
+
+			action.reserve(&source)?;
+
+			let swap = PendingSwap {
+				source,
+				action,
+				end_block: pezframe_system::Pallet::<T>::block_number() + duration,
+			};
+			PendingSwaps::<T>::insert(target.clone(), hashed_proof, swap.clone());
+
+			Self::deposit_event(Event::NewSwap { account: target, proof: hashed_proof, swap });
+
+			Ok(())
+		}
+
+		/// Claim an atomic swap.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `proof`: Revealed proof of the claim.
+		/// - `action`: Action defined in the swap, it must match the entry in blockchain. Otherwise
+		///   the operation fails. This is used for weight calculation.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::DbWeight::get().reads_writes(1, 1)
+				.saturating_add(action.weight())
+				.ref_time()
+				.saturating_add(40_000_000)
+				.saturating_add((proof.len() as u64).saturating_mul(100))
+		)]
+		pub fn claim_swap(
+			origin: OriginFor<T>,
+			proof: Vec<u8>,
+			action: T::SwapAction,
+		) -> DispatchResult {
+			ensure!(proof.len() <= T::ProofLimit::get() as usize, Error::<T>::ProofTooLarge);
+
+			let target = ensure_signed(origin)?;
+			let hashed_proof = blake2_256(&proof);
+
+			let swap =
+				PendingSwaps::<T>::get(&target, hashed_proof).ok_or(Error::<T>::InvalidProof)?;
+			ensure!(swap.action == action, Error::<T>::ClaimActionMismatch);
+
+			let succeeded = swap.action.claim(&swap.source, &target);
+
+			PendingSwaps::<T>::remove(target.clone(), hashed_proof);
+
+			Self::deposit_event(Event::SwapClaimed {
+				account: target,
+				proof: hashed_proof,
+				success: succeeded,
+			});
+
+			Ok(())
+		}
+
+		/// Cancel an atomic swap. Only possible after the originally set duration has passed.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: Target of the original atomic swap.
+		/// - `hashed_proof`: Hashed proof of the original atomic swap.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1).ref_time().saturating_add(40_000_000))]
+		pub fn cancel_swap(
+			origin: OriginFor<T>,
+			target: T::AccountId,
+			hashed_proof: HashedProof,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+
+			let swap = PendingSwaps::<T>::get(&target, hashed_proof).ok_or(Error::<T>::NotExist)?;
+			ensure!(swap.source == source, Error::<T>::SourceMismatch);
+			ensure!(
+				pezframe_system::Pallet::<T>::block_number() >= swap.end_block,
+				Error::<T>::DurationNotPassed,
+			);
+
+			swap.action.cancel(&swap.source);
+			PendingSwaps::<T>::remove(&target, hashed_proof);
+
+			Self::deposit_event(Event::SwapCancelled { account: target, proof: hashed_proof });
+
+			Ok(())
+		}
+	}
+}

bizinikiwi/pezframe/atomic-swap/src/tests.rs

@@ -0,0 +1,130 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg(test)]
+
+use super::*;
+use crate as pezpallet_atomic_swap;
+use frame::testing_prelude::*;
+
+type Block = pezframe_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: pezframe_system,
+		Balances: pezpallet_balances,
+		AtomicSwap: pezpallet_atomic_swap,
+	}
+);
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Test {
+	type Block = Block;
+	type AccountData = pezpallet_balances::AccountData<u64>;
+}
+
+#[derive_impl(pezpallet_balances::config_preludes::TestDefaultConfig)]
+impl pezpallet_balances::Config for Test {
+	type AccountStore = System;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type SwapAction = BalanceSwapAction<u64, Balances>;
+	type ProofLimit = ConstU32<1024>;
+}
+
+const A: u64 = 1;
+const B: u64 = 2;
+
+pub fn new_test_ext() -> TestExternalities {
+	let mut t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let genesis = pezpallet_balances::GenesisConfig::<Test> {
+		balances: vec![(A, 100), (B, 200)],
+		..Default::default()
+	};
+	genesis.assimilate_storage(&mut t).unwrap();
+	t.into()
+}
+
+#[test]
+fn two_party_successful_swap() {
+	let mut chain1 = new_test_ext();
+	let mut chain2 = new_test_ext();
+
+	// A generates a random proof. Keep it secret.
+	let proof: [u8; 2] = [4, 2];
+	// The hashed proof is the blake2_256 hash of the proof. This is public.
+	let hashed_proof = blake2_256(&proof);
+
+	// A creates the swap on chain1.
+	chain1.execute_with(|| {
+		AtomicSwap::create_swap(
+			RuntimeOrigin::signed(A),
+			B,
+			hashed_proof,
+			BalanceSwapAction::new(50),
+			1000,
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 - 50);
+		assert_eq!(Balances::free_balance(B), 200);
+	});
+
+	// B creates the swap on chain2.
+	chain2.execute_with(|| {
+		AtomicSwap::create_swap(
+			RuntimeOrigin::signed(B),
+			A,
+			hashed_proof,
+			BalanceSwapAction::new(75),
+			1000,
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100);
+		assert_eq!(Balances::free_balance(B), 200 - 75);
+	});
+
+	// A reveals the proof and claims the swap on chain2.
+	chain2.execute_with(|| {
+		AtomicSwap::claim_swap(
+			RuntimeOrigin::signed(A),
+			proof.to_vec(),
+			BalanceSwapAction::new(75),
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 + 75);
+		assert_eq!(Balances::free_balance(B), 200 - 75);
+	});
+
+	// B use the revealed proof to claim the swap on chain1.
+	chain1.execute_with(|| {
+		AtomicSwap::claim_swap(
+			RuntimeOrigin::signed(B),
+			proof.to_vec(),
+			BalanceSwapAction::new(50),
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 - 50);
+		assert_eq!(Balances::free_balance(B), 200 + 50);
+	});
+}