Merge pull request #2207 from opentensor/get_proxies_in_precompile

sam0x17 · web-flow · commit de708ba33294 · 2025-12-16T22:19:02.000-05:00
add getProxies in precompile
diff --git a/common/src/lib.rs b/common/src/lib.rs
@@ -184,11 +184,37 @@ impl TryFrom<u8> for ProxyType {
             14 => Ok(Self::SudoUncheckedSetCode),
             15 => Ok(Self::SwapHotkey),
             16 => Ok(Self::SubnetLeaseBeneficiary),
+            17 => Ok(Self::RootClaim),
             _ => Err(()),
         }
     }
 }
 
+impl From<ProxyType> for u8 {
+    fn from(proxy_type: ProxyType) -> Self {
+        match proxy_type {
+            ProxyType::Any => 0,
+            ProxyType::Owner => 1,
+            ProxyType::NonCritical => 2,
+            ProxyType::NonTransfer => 3,
+            ProxyType::Senate => 4,
+            ProxyType::NonFungible => 5,
+            ProxyType::Triumvirate => 6,
+            ProxyType::Governance => 7,
+            ProxyType::Staking => 8,
+            ProxyType::Registration => 9,
+            ProxyType::Transfer => 10,
+            ProxyType::SmallTransfer => 11,
+            ProxyType::RootWeights => 12,
+            ProxyType::ChildKeys => 13,
+            ProxyType::SudoUncheckedSetCode => 14,
+            ProxyType::SwapHotkey => 15,
+            ProxyType::SubnetLeaseBeneficiary => 16,
+            ProxyType::RootClaim => 17,
+        }
+    }
+}
+
 impl Default for ProxyType {
     // allow all Calls; required to be most permissive
     fn default() -> Self {
diff --git a/contract-tests/src/contracts/proxy.ts b/contract-tests/src/contracts/proxy.ts
@@ -144,5 +144,41 @@ export const IProxyABI = [
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "account",
+        "type": "bytes32"
+      }
+    ],
+    "name": "getProxies",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "delegate",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "uint256",
+            "name": "proxy_type",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "delay",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct IProxy.ProxyInfo[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
   }
 ];
diff --git a/contract-tests/test/pure-proxy.precompile.test.ts b/contract-tests/test/pure-proxy.precompile.test.ts
@@ -46,8 +46,10 @@ async function getProxies(api: TypedApi<typeof devnet>, address: string) {
 
 describe("Test pure proxy precompile", () => {
     const evmWallet = generateRandomEthersWallet();
+    // only used for edge case and normal proxy
     const evmWallet2 = generateRandomEthersWallet();
     const evmWallet3 = generateRandomEthersWallet();
+    const evmWallet4 = generateRandomEthersWallet();
     const receiver = getRandomSubstrateKeypair();
 
     let api: TypedApi<typeof devnet>
@@ -61,6 +63,7 @@ describe("Test pure proxy precompile", () => {
         await forceSetBalanceToEthAddress(api, evmWallet.address)
         await forceSetBalanceToEthAddress(api, evmWallet2.address)
         await forceSetBalanceToEthAddress(api, evmWallet3.address)
+        await forceSetBalanceToEthAddress(api, evmWallet4.address)
     })
 
     it("Call createPureProxy, then use proxy to call transfer", async () => {
@@ -130,34 +133,78 @@ describe("Test pure proxy precompile", () => {
         const proxies = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
         const contract = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet2)
 
+        const proxiesFromContract = await contract.getProxies(convertH160ToPublicKey(evmWallet2.address))
+        assert.equal(proxiesFromContract.length, proxies[0].length, "proxies length should be equal")
+
         const type = 0;
         const delay = 0;
 
         const tx = await contract.addProxy(convertH160ToPublicKey(evmWallet3.address), type, delay)
         await tx.wait()
 
+        const proxiesAfterAdd = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
+        const proxiesList = proxiesAfterAdd[0].map(proxy => proxy.delegate)
 
-        const proxiesAfterAdd = await await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
+        const proxiesFromContractAfterAdd = await contract.getProxies(convertH160ToPublicKey(evmWallet2.address))
 
-        const length = proxiesAfterAdd[0].length
-        assert.equal(length, proxies[0].length + 1, "proxy should be set")
-        const proxy = proxiesAfterAdd[0][proxiesAfterAdd[0].length - 1]
+        assert.equal(proxiesFromContractAfterAdd.length, proxiesList.length, "proxy length should be equal")
 
-        assert.equal(proxy.delegate, convertH160ToSS58(evmWallet3.address), "proxy should be set")
+        for (let index = 0; index < proxiesFromContractAfterAdd.length; index++) {
+            const proxyInfo = proxiesFromContractAfterAdd[index]
+            let proxySs58 = convertPublicKeyToSs58(proxyInfo[0])
+            assert.ok(proxiesList.includes(proxySs58), "proxy should be set")
+            if (index === proxiesFromContractAfterAdd.length - 1) {
+                assert.equal(Number(proxyInfo[1]), type, "proxy_type should match")
+                assert.equal(Number(proxyInfo[2]), delay, "delay should match")
+            }
+        }
 
+        assert.equal(proxiesList.length, proxies[0].length + 1, "proxy should be set")
+        const proxy = proxiesList[proxiesList.length - 1]
 
+        assert.equal(proxy, convertH160ToSS58(evmWallet3.address), "proxy should be set")
         const balance = (await api.query.System.Account.getValue(convertPublicKeyToSs58(receiver.publicKey))).data.free
-
         const amount = 1000000000;
 
         const contract2 = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet3)
-
-
         const callCode = await getTransferCallCode(api, receiver, amount)
         const tx2 = await contract2.proxyCall(convertH160ToPublicKey(evmWallet2.address), [type], callCode)
         await tx2.wait()
 
         const balanceAfter = (await api.query.System.Account.getValue(convertPublicKeyToSs58(receiver.publicKey))).data.free
         assert.equal(balanceAfter, balance + BigInt(amount), "balance should be increased")
     })
+
+    it("Call addProxy many times, then check getProxies is correct", async () => {
+        const proxies = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet4.address))
+        const contract = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet4)
+        assert.equal(proxies[0].length, 0, "proxies length should be 0")
+
+        const proxiesFromContract = await contract.getProxies(convertH160ToPublicKey(evmWallet4.address))
+        assert.equal(proxiesFromContract.length, proxies[0].length, "proxies length should be equal")
+
+        const type = 1;
+        const delay = 2;
+
+        for (let i = 0; i < 5; i++) {
+            const evmWallet = generateRandomEthersWallet()
+            const tx = await contract.addProxy(convertH160ToPublicKey(evmWallet.address), type, delay)
+            await tx.wait()
+        }
+
+        const proxiesAfterAdd = await await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet4.address))
+        const proxiesList = proxiesAfterAdd[0].map(proxy => proxy.delegate)
+
+        const proxiesFromContractAfterAdd = await contract.getProxies(convertH160ToPublicKey(evmWallet4.address))
+
+        assert.equal(proxiesFromContractAfterAdd.length, proxiesList.length, "proxy length should be equal")
+
+        for (let index = 0; index < proxiesFromContractAfterAdd.length; index++) {
+            const proxyInfo = proxiesFromContractAfterAdd[index]
+            let proxySs58 = convertPublicKeyToSs58(proxyInfo[0])
+            assert.ok(proxiesList.includes(proxySs58), "proxy should be set")
+            assert.equal(Number(proxyInfo[1]), type, "proxy_type should match")
+            assert.equal(Number(proxyInfo[2]), delay, "delay should match")
+        }
+    })
 });
diff --git a/precompiles/src/proxy.rs b/precompiles/src/proxy.rs
@@ -9,12 +9,14 @@ use frame_system::RawOrigin;
 use pallet_evm::{AddressMapping, PrecompileHandle};
 use pallet_subtensor_proxy as pallet_proxy;
 use precompile_utils::EvmResult;
-use sp_core::H256;
+use sp_core::{H256, U256};
 use sp_runtime::{
     codec::DecodeLimit,
     traits::{Dispatchable, StaticLookup},
 };
 use sp_std::boxed::Box;
+use sp_std::convert::{TryFrom, TryInto};
+use sp_std::vec;
 use sp_std::vec::Vec;
 use subtensor_runtime_common::ProxyType;
 pub struct ProxyPrecompile<R>(PhantomData<R>);
@@ -239,4 +241,30 @@ where
 
         handle.try_dispatch_runtime_call::<R, _>(call, RawOrigin::Signed(account_id))
     }
+
+    #[precompile::public("getProxies(bytes32)")]
+    #[precompile::view]
+    pub fn get_proxies(
+        _handle: &mut impl PrecompileHandle,
+        account_id: H256,
+    ) -> EvmResult<Vec<(H256, U256, U256)>> {
+        let account_id = R::AccountId::from(account_id.0.into());
+
+        let proxies = pallet_proxy::pallet::Pallet::<R>::proxies(account_id);
+        let mut result: Vec<(H256, U256, U256)> = vec![];
+        for proxy in proxies.0 {
+            let delegate: [u8; 32] = proxy.delegate.into();
+            let proxy_type: u8 = proxy.proxy_type.into();
+            let delay: u32 = proxy
+                .delay
+                .try_into()
+                .map_err(|_| PrecompileFailure::Error {
+                    exit_status: ExitError::Other("Invalid delay".into()),
+                })?;
+
+            result.push((delegate.into(), proxy_type.into(), delay.into()));
+        }
+
+        Ok(result)
+    }
 }
diff --git a/precompiles/src/solidity/proxy.abi b/precompiles/src/solidity/proxy.abi
@@ -0,0 +1,160 @@
+[
+  {
+    "type": "function",
+    "name": "createPureProxy",
+    "inputs": [
+      {
+        "name": "proxy_type",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "delay",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "index",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "proxyCall",
+    "inputs": [
+      {
+        "name": "real",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "force_proxy_type",
+        "type": "uint8[]",
+        "internalType": "uint8[]"
+      },
+      {
+        "name": "call",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "killPureProxy",
+    "inputs": [
+      {
+        "name": "spawner",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "proxy_type",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "index",
+        "type": "uint16",
+        "internalType": "uint16"
+      },
+      {
+        "name": "height",
+        "type": "uint16",
+        "internalType": "uint16"
+      },
+      {
+        "name": "ext_index",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addProxy",
+    "inputs": [
+      {
+        "name": "delegate",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "proxy_type",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "delay",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeProxy",
+    "inputs": [
+      {
+        "name": "delegate",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "proxy_type",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "delay",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeProxies",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "pokeDeposit",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getProxies",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
diff --git a/precompiles/src/solidity/proxy.sol b/precompiles/src/solidity/proxy.sol
