@@ -53,27 +53,28 @@ impl StakingPrecompile {
5353 . map_or_else ( vec:: Vec :: new, |slice| slice. to_vec ( ) ) ; // Avoiding borrowing conflicts
5454
5555 match method_id {
56- id if id == get_method_id ( "addStake(bytes32,uint16 )" ) => {
56+ id if id == get_method_id ( "addStake(bytes32,uint256 )" ) => {
5757 Self :: add_stake ( handle, & method_input)
5858 }
59- id if id == get_method_id ( "removeStake(bytes32,uint256,uint16 )" ) => {
59+ id if id == get_method_id ( "removeStake(bytes32,uint256,uint256 )" ) => {
6060 Self :: remove_stake ( handle, & method_input)
6161 }
6262 id if id == get_method_id ( "getStakeColdkey(bytes32)" ) => {
6363 Self :: get_stake_coldkey ( & method_input)
6464 }
65+ id if id == get_method_id ( "getStake(bytes32,bytes32,uint256)" ) => {
66+ Self :: get_stake ( & method_input)
67+ }
6568 _ => Err ( PrecompileFailure :: Error {
6669 exit_status : ExitError :: InvalidRange ,
6770 } ) ,
6871 }
6972 }
7073
7174 fn add_stake ( handle : & mut impl PrecompileHandle , data : & [ u8 ] ) -> PrecompileResult {
72- let hotkey = Self :: parse_ss58 ( data) ?. into ( ) ;
75+ let hotkey = Self :: parse_key ( data) ?. into ( ) ;
7376 let amount: U256 = handle. context ( ) . apparent_value ;
74-
75- // TODO: Use netuid method parameter here
76- let netuid: u16 = 0 ;
77+ let netuid = Self :: parse_netuid ( data, 0x3E ) ?;
7778
7879 let amount_sub =
7980 <Runtime as pallet_evm:: Config >:: BalanceConverter :: into_substrate_balance ( amount)
@@ -88,11 +89,10 @@ impl StakingPrecompile {
8889 // Dispatch the add_stake call
8990 Self :: dispatch ( handle, call)
9091 }
91- fn remove_stake ( handle : & mut impl PrecompileHandle , data : & [ u8 ] ) -> PrecompileResult {
92- let hotkey = Self :: parse_ss58 ( data) ?. into ( ) ;
9392
94- // TODO: Use netuid method parameter here
95- let netuid: u16 = 0 ;
93+ fn remove_stake ( handle : & mut impl PrecompileHandle , data : & [ u8 ] ) -> PrecompileResult {
94+ let hotkey = Self :: parse_key ( data) ?. into ( ) ;
95+ let netuid = Self :: parse_netuid ( data, 0x5E ) ?;
9696
9797 // We have to treat this as uint256 (because of Solidity ABI encoding rules, it pads uint64),
9898 // but this will never exceed 8 bytes, se we will ignore higher bytes and will only use lower
@@ -114,11 +114,10 @@ impl StakingPrecompile {
114114 }
115115
116116 fn get_stake_coldkey ( data : & [ u8 ] ) -> PrecompileResult {
117- // TODO: rename parse_ss58 to parse_key or something?
118- let coldkey: AccountId32 = Self :: parse_ss58 ( data) ?. into ( ) ;
117+ let coldkey: AccountId32 = Self :: parse_key ( data) ?. into ( ) ;
119118
120119 // get total stake of coldkey
121- let total_stake = pallet_subtensor:: TotalColdkeyStake :: < Runtime > :: get ( coldkey) ;
120+ let total_stake = pallet_subtensor:: Pallet :: < Runtime > :: get_total_stake_for_coldkey ( & coldkey) ;
122121 let result_u256 = U256 :: from ( total_stake) ;
123122 let mut result = [ 0_u8 ; 32 ] ;
124123 U256 :: to_big_endian ( & result_u256, & mut result) ;
@@ -129,15 +128,68 @@ impl StakingPrecompile {
129128 } )
130129 }
131130
132- fn parse_ss58 ( data : & [ u8 ] ) -> Result < [ u8 ; 32 ] , PrecompileFailure > {
133- if data. len ( ) < 32 {
131+ fn get_stake ( data : & [ u8 ] ) -> PrecompileResult {
132+ let ( hotkey, coldkey) = Self :: parse_hotkey_coldkey ( data) ?;
133+ let netuid: u16 = Self :: parse_netuid ( data, 0x5E ) ?;
134+
135+ let stake = pallet_subtensor:: Pallet :: < Runtime > :: get_stake_for_hotkey_and_coldkey_on_subnet (
136+ & hotkey. into ( ) ,
137+ & coldkey. into ( ) ,
138+ netuid,
139+ ) ;
140+
141+ // Convert to EVM decimals
142+ let stake_u256 = U256 :: from ( stake) ;
143+ let stake_eth =
144+ <Runtime as pallet_evm:: Config >:: BalanceConverter :: into_evm_balance ( stake_u256)
145+ . ok_or ( ExitError :: InvalidRange ) ?;
146+
147+ // Format output
148+ let mut result = [ 0_u8 ; 32 ] ;
149+ U256 :: to_big_endian ( & stake_eth, & mut result) ;
150+
151+ Ok ( PrecompileOutput {
152+ exit_status : ExitSucceed :: Returned ,
153+ output : result. into ( ) ,
154+ } )
155+ }
156+
157+ fn parse_hotkey_coldkey ( data : & [ u8 ] ) -> Result < ( [ u8 ; 32 ] , [ u8 ; 32 ] ) , PrecompileFailure > {
158+ if data. len ( ) < 64 {
134159 return Err ( PrecompileFailure :: Error {
135160 exit_status : ExitError :: InvalidRange ,
136161 } ) ;
137162 }
138163 let mut hotkey = [ 0u8 ; 32 ] ;
139164 hotkey. copy_from_slice ( get_slice ( data, 0 , 32 ) ?) ;
140- Ok ( hotkey)
165+ let mut coldkey = [ 0u8 ; 32 ] ;
166+ coldkey. copy_from_slice ( get_slice ( data, 32 , 64 ) ?) ;
167+ Ok ( ( hotkey, coldkey) )
168+ }
169+
170+ fn parse_key ( data : & [ u8 ] ) -> Result < [ u8 ; 32 ] , PrecompileFailure > {
171+ if data. len ( ) < 32 {
172+ return Err ( PrecompileFailure :: Error {
173+ exit_status : ExitError :: InvalidRange ,
174+ } ) ;
175+ }
176+ let mut key = [ 0u8 ; 32 ] ;
177+ key. copy_from_slice ( get_slice ( data, 0 , 32 ) ?) ;
178+ Ok ( key)
179+ }
180+
181+ fn parse_netuid ( data : & [ u8 ] , offset : usize ) -> Result < u16 , PrecompileFailure > {
182+ if data. len ( ) < offset + 2 {
183+ return Err ( PrecompileFailure :: Error {
184+ exit_status : ExitError :: InvalidRange ,
185+ } ) ;
186+ }
187+
188+ let mut netuid_bytes = [ 0u8 ; 2 ] ;
189+ netuid_bytes. copy_from_slice ( get_slice ( data, offset, offset + 2 ) ?) ;
190+ let netuid: u16 = netuid_bytes[ 1 ] as u16 | ( ( netuid_bytes[ 0 ] as u16 ) << 8u16 ) ;
191+
192+ Ok ( netuid)
141193 }
142194
143195 fn dispatch ( handle : & mut impl PrecompileHandle , call : RuntimeCall ) -> PrecompileResult {
@@ -164,9 +216,12 @@ impl StakingPrecompile {
164216 exit_status : ExitSucceed :: Returned ,
165217 output : vec ! [ ] ,
166218 } ) ,
167- Err ( _) => Err ( PrecompileFailure :: Error {
168- exit_status : ExitError :: Other ( "Subtensor call failed" . into ( ) ) ,
169- } ) ,
219+ Err ( _) => {
220+ log:: warn!( "Returning error PrecompileFailure::Error" ) ;
221+ Err ( PrecompileFailure :: Error {
222+ exit_status : ExitError :: Other ( "Subtensor call failed" . into ( ) ) ,
223+ } )
224+ }
170225 }
171226 }
172227
0 commit comments