velords: create lords burner contract

veLords/mainnet_lords_burner.ansi

@@ -0,0 +1,26 @@
+   ____          _         
+  |    \ ___ ___| |___ _ _ 
+  |  |  | -_| . | | . | | |
+  |____/|___|  _|_|___|_  |
+            |_|       |___|
+
+
+
+Contract is lordship_burner.contract_class.json...
+
+
+
+Declaring Lordship Lords Burner...
+
+
+- Class Hash:  0x1fee7f8d94aab37b94bcf07b35a556d3039cbe72ba36109216b52d6cc07251b
+- Tx Hash:  Already declared
+
+Deploying Lordship Lords Burner ... 
+
+
+Tx hash:  https://voyager.online/tx/0x302d79c2523f13d9796d14ae9e6ddc59da8ddd323a243af6770325bb1512dd5)
+Contract Address:  0x45c587318c9ebcf2fbe21febf288ee2e3597a21cd48676005a5770a50d433c5 
+
+
+"addresses/prod/Lordship Lords Burner.json" has been saved or overwritten

veLords/scripts/deployment/addresses/prod/Lordship Lords Burner.json

@@ -0,0 +1,9 @@
+{
+  "address": "0x45c587318c9ebcf2fbe21febf288ee2e3597a21cd48676005a5770a50d433c5",
+  "calldata": [
+    "0x992acf50dba66f87d8cafffbbc3cdbbec5f8f514b5014f6d4d75e6b8789153",
+    "0x91b13b83e5c34112aa066a844d4cbe6af99b3d134293829ca1730ea4869a71"
+  ],
+  "deployed_at": 1726197087423,
+  "deployed_at_readable": "Fri, 13 Sep 2024 03:11:27 GMT"
+}

veLords/scripts/deployment/libs/deploy.js

@@ -78,6 +78,28 @@ export const deployRewardPool = async (veLordsAddress) => {
   return address
 };
 
+export const deployLordsBurner = async (rewardPoolAddress) => {
+  ///////////////////////////////////////////
+  ////////       Lords Burner     ///////////
+  ///////////////////////////////////////////
+
+  // declare contract
+  let realName = "Lordship Lords Burner";
+  let contractName = "lordship_burner";
+  const class_hash = (
+    await declare(getContractPath(TARGET_PATH, contractName), realName)
+  ).class_hash;
+
+  // deploy contract
+  let LORDS_BURNER_ADMIN = BigInt(process.env.FINAL_ADMIN);
+  let LORDS_BURNER_REWARD_POOL = rewardPoolAddress;
+  let constructorCalldata = [
+    LORDS_BURNER_ADMIN,
+    LORDS_BURNER_REWARD_POOL,
+  ];
+  let address = await deploy(realName, class_hash, constructorCalldata);
+  return address;
+};
 
 export const setRewardPoolInVeLords = async (veLords, rewardPool) => {
   ///////////////////////////////////////////

veLords/scripts/deployment/startDeploy.js

@@ -1,5 +1,5 @@
 import colors from "colors";
-import { deployRewardPool, deployVeLords, setFinalAdminInRewardPoolAndVeLords, setRewardPoolInVeLords } from "./libs/deploy.js";
+import { deployLordsBurner, deployRewardPool, deployVeLords, setFinalAdminInRewardPoolAndVeLords, setRewardPoolInVeLords } from "./libs/deploy.js";
 
 const main = async () => {
   console.log(`   ____          _         `.red);
@@ -11,6 +11,7 @@ const main = async () => {
 
   let veLordsAddress = await deployVeLords();
   let rewardPoolAddress = await deployRewardPool(veLordsAddress);
+  await deployLordsBurner(rewardPoolAddress);
   await setRewardPoolInVeLords(veLordsAddress, rewardPoolAddress)
   await setFinalAdminInRewardPoolAndVeLords(veLordsAddress, rewardPoolAddress)
 };

veLords/src/burner.cairo

@@ -0,0 +1,79 @@
+// A simple contract that receives lords and allows anyone 
+// to call the burn function to send it to the reward pool
+
+// the contract is upgradeable so new functions can be added in the future
+
+#[starknet::contract]
+mod burner {
+    use lordship::interfaces::IBurner::IBurner;
+    use lordship::interfaces::IERC20::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use lordship::interfaces::IRewardPool::{IRewardPoolDispatcher, IRewardPoolDispatcherTrait};
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::upgrades::UpgradeableComponent;
+    use openzeppelin::upgrades::interface::IUpgradeable;
+    use starknet::{ClassHash, ContractAddress, get_contract_address, contract_address_const};
+
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(path: UpgradeableComponent, storage: upgradeable, event: UpgradeableEvent);
+
+    #[abi(embed_v0)]
+    impl OwnableTwoStepImpl = OwnableComponent::OwnableTwoStepImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+    impl UpgradeableInternalImpl = UpgradeableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        // component storage
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        upgradeable: UpgradeableComponent::Storage,
+        reward_pool: IRewardPoolDispatcher
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        UpgradeableEvent: UpgradeableComponent::Event
+    }
+
+    fn LORDS_TOKEN() -> IERC20Dispatcher {
+        IERC20Dispatcher {
+            contract_address: contract_address_const::<
+                0x0124aeb495b947201f5fac96fd1138e326ad86195b98df6dec9009158a533b49
+            >()
+        }
+    }
+
+
+    #[constructor]
+    fn constructor(ref self: ContractState, owner: ContractAddress, reward_pool: ContractAddress,) {
+        self.ownable.initializer(owner);
+        self.reward_pool.write(IRewardPoolDispatcher { contract_address: reward_pool });
+    }
+
+    #[abi(embed_v0)]
+    impl UpgradeableImpl of IUpgradeable<ContractState> {
+        fn upgrade(ref self: ContractState, new_class_hash: ClassHash) {
+            self.ownable.assert_only_owner();
+            self.upgradeable._upgrade(new_class_hash);
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl IBurnerImpl of IBurner<ContractState> {
+        fn burn_lords(ref self: ContractState) {
+            let this: ContractAddress = get_contract_address();
+            let lords_token = LORDS_TOKEN();
+            let lords_balance = lords_token.balance_of(this);
+            assert!(lords_balance > 0, "LORDS balance is zero");
+
+            let reward_pool = self.reward_pool.read();
+            lords_token.approve(reward_pool.contract_address, lords_balance);
+            reward_pool.burn(lords_balance);
+        }
+    }
+}

veLords/src/interfaces/IBurner.cairo

@@ -0,0 +1,6 @@
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IBurner<TContractState> {
+    fn burn_lords(ref self: TContractState);
+}

veLords/src/lib.cairo

@@ -1,8 +1,10 @@
+mod burner;
 mod dlords;
 mod reward_pool;
 mod velords;
 
 pub mod interfaces {
+    pub mod IBurner;
     pub mod IERC20;
     pub mod IRewardPool;
     pub mod IVE;