initial commit phase .
This commit is contained in:
|| Prof. - Xadk3!
parent
50e2f6d92d
commit
a5f1d08a5e
|
|
@ -0,0 +1,11 @@
|
|||
/target
|
||||
*db*
|
||||
__pycache__/
|
||||
.o
|
||||
.so
|
||||
.exe
|
||||
.pyc
|
||||
.ts
|
||||
*_no.git_*
|
||||
venv/
|
||||
*venv*
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,12 @@
|
|||
[package]
|
||||
name = "evmSH"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1.0.70"
|
||||
ethers = "2.0.3"
|
||||
revm = "3.1.1"
|
||||
tokio = "1.27.0"
|
||||
|
|
@ -0,0 +1,471 @@
|
|||
#!/usr/bin/env node
|
||||
/* note: it can crash a net while running on kernel-space */
|
||||
/*jshint es5:false, asi:true, quotmark:false, eqeqeq:false, forin: false */
|
||||
|
||||
/*
|
||||
* (c) 2011-14 Tim Becker, see file LICENSE for details
|
||||
*/
|
||||
|
||||
/*
|
||||
* Provides functionality for bencoding and decoding as use in
|
||||
* bittorrent and described in: http://www.bittorrent.org/beps/bep_0003.html
|
||||
*
|
||||
* Encoding is as follows:
|
||||
*
|
||||
* var benc = require('bncode'),
|
||||
* exmp = {}
|
||||
*
|
||||
* exmp.bla = "blup"
|
||||
* exmp.foo = "bar"
|
||||
* exmp.one = 1
|
||||
* exmp.woah = {}
|
||||
* exmp.woah.arr = []
|
||||
* exmp.woah.arr.push(1)
|
||||
* exmp.woah.arr.push(2)
|
||||
* exmp.woah.arr.push(3)
|
||||
* exmp.str = new Buffer("Buffers work too")
|
||||
*
|
||||
* var bencBuffer = benc.encode(exmp) i
|
||||
*
|
||||
* // d3:bla4:blup3:foo3:bar3:onei1e4:woahd3:arr \
|
||||
* // li1ei2ei3eee3:str16:Buffers work tooe
|
||||
*
|
||||
*
|
||||
* Decoding will work in progressively, e.g. if you're receiving partial
|
||||
* bencoded strings on the network:
|
||||
*
|
||||
* var benc = require("bncode"),
|
||||
* buf = null
|
||||
*
|
||||
* decoder = new bncode.decoder()
|
||||
* while (buf = receiveData()) {
|
||||
* decoder.decode(buf)
|
||||
* }
|
||||
*
|
||||
* log(decoder.result())
|
||||
*
|
||||
*
|
||||
* Or "all in one"
|
||||
*
|
||||
* var benc = require("bncode"),
|
||||
* buf = getBuffer(),
|
||||
* dec = benc.decode(buf)
|
||||
*
|
||||
* log(dec.bla)
|
||||
*
|
||||
*
|
||||
* There are some subtleties concerning bencoded strings. These are
|
||||
* decoded as Buffer objects because they are just strings of raw bytes
|
||||
* and as such would wreak havoc with multi byte strings in javascript.
|
||||
*
|
||||
* The exception to this is strings that appear as keys in bencoded
|
||||
* dicts. These are decoded as Javascript Strings, as they should always
|
||||
* be strings of (ascii) characters and if they weren't decoded as JS
|
||||
* Strings, dict's would map to Javascript objects with properties.
|
||||
*
|
||||
*/
|
||||
|
||||
exports.encode = Bencode
|
||||
exports.decoder = Bdecode
|
||||
exports.decode = decode
|
||||
exports.Stream = Stream
|
||||
|
||||
var inherits = require('util').inherits
|
||||
var Transform = require('stream').Transform
|
||||
|
||||
var I = 'i'.charCodeAt(0)
|
||||
var L = 'l'.charCodeAt(0)
|
||||
var E = 'e'.charCodeAt(0)
|
||||
var D = 'd'.charCodeAt(0)
|
||||
var COLON = ':'.charCodeAt(0)
|
||||
var DASH = '-'.charCodeAt(0)
|
||||
|
||||
var STATE_INITIAL = 0
|
||||
var STATE_STATE_STRING_LEN = STATE_INITIAL + 1
|
||||
var STATE_STRING = STATE_STATE_STRING_LEN + 1
|
||||
var STATE_COLON = STATE_STRING + 1
|
||||
var STATE_STATE_INTEGER = STATE_COLON + 1
|
||||
var STATE_INTEGER = STATE_STATE_INTEGER + 1
|
||||
|
||||
/*
|
||||
* This is the internal state machine for taking apart bencoded strings,
|
||||
* it's not exposed in the eports. It's constructed with four callbacks
|
||||
* that get fired when:
|
||||
*
|
||||
* cb: a value (string or number) is encountered
|
||||
* cb_list: a begin list element is encountered
|
||||
* cb_dict: a beginning of dictionary is encountered.
|
||||
* cd_end: an end element, wheter dict or list is encountered
|
||||
*
|
||||
* Once constructed, the machine may be fed with buffers containing
|
||||
* partial bencoded string. Call `consistent` to check whether the
|
||||
* current state is consistent, e.g. not smack-dap in the middle of
|
||||
* a string or a number and if the dict, list and end calls balance
|
||||
*
|
||||
*
|
||||
* The functionality being so rudimentary requires some more state and
|
||||
* logic in the code executing the machine, for this see Context, below.
|
||||
*
|
||||
*/
|
||||
|
||||
function BdecodeSMachine (cb, cb_list, cb_dict, cb_end) {
|
||||
var depth = 0
|
||||
var state = STATE_INITIAL
|
||||
|
||||
this.consistent = function () {
|
||||
return state === STATE_INITIAL && depth === 0
|
||||
}
|
||||
|
||||
var strLen = 0
|
||||
var str = ''
|
||||
var _int = 0
|
||||
var neg = false
|
||||
|
||||
this.parse = function (buffer, encoding) {
|
||||
if (typeof buffer === 'string') {
|
||||
buffer = new Buffer(buffer, encoding || 'utf8')
|
||||
}
|
||||
|
||||
for (var pos = 0; pos !== buffer.length; ++pos) {
|
||||
switch (state) {
|
||||
case STATE_INITIAL:
|
||||
switch (buffer[pos]) {
|
||||
case 0x30:
|
||||
case 0x31:
|
||||
case 0x32:
|
||||
case 0x33:
|
||||
case 0x34:
|
||||
case 0x35:
|
||||
case 0x36:
|
||||
case 0x37:
|
||||
case 0x38:
|
||||
case 0x39:
|
||||
state = STATE_STATE_STRING_LEN
|
||||
strLen = 0
|
||||
strLen += buffer[pos] - 0x30
|
||||
break
|
||||
case I:
|
||||
state = STATE_STATE_INTEGER
|
||||
_int = 0
|
||||
neg = false
|
||||
break
|
||||
case L:
|
||||
state = STATE_INITIAL
|
||||
depth += 1
|
||||
cb_list()
|
||||
break
|
||||
case D:
|
||||
state = STATE_INITIAL
|
||||
depth += 1
|
||||
cb_dict()
|
||||
break
|
||||
case E:
|
||||
state = STATE_INITIAL
|
||||
depth -= 1
|
||||
if (depth < 0) {
|
||||
throw new Error('end with no beginning: ' + pos)
|
||||
} else {
|
||||
cb_end()
|
||||
}
|
||||
break
|
||||
}
|
||||
break
|
||||
case STATE_STATE_STRING_LEN:
|
||||
if (integer(buffer[pos])) {
|
||||
strLen *= 10
|
||||
strLen += buffer[pos] - 0x30
|
||||
} else {
|
||||
str = new Buffer(strLen)
|
||||
pos -=1
|
||||
state = STATE_COLON
|
||||
}
|
||||
break
|
||||
case STATE_COLON:
|
||||
if (buffer[pos] !== COLON) {
|
||||
throw new Error('not a colon at: ' + pos.toString(16))
|
||||
}
|
||||
state = STATE_STRING
|
||||
// in case this is a zero length string, there's
|
||||
// no bytes to be collected.
|
||||
if (0 === strLen) {
|
||||
cb(new Buffer(0))
|
||||
state = STATE_INITIAL
|
||||
}
|
||||
break
|
||||
case STATE_STRING:
|
||||
if (0 === strLen) {
|
||||
cb(str)
|
||||
state = STATE_INITIAL
|
||||
} else {
|
||||
//str += String.fromCharCode(buffer[pos]) // not unicode safe..
|
||||
str[str.length-strLen] = buffer[pos]
|
||||
strLen -= 1
|
||||
if (0 === strLen) {
|
||||
cb(str)
|
||||
state = STATE_INITIAL
|
||||
}
|
||||
}
|
||||
break
|
||||
case STATE_STATE_INTEGER:
|
||||
state = STATE_INTEGER
|
||||
if (buffer[pos] === DASH) {
|
||||
neg = true // handle neg and zero within value.
|
||||
break
|
||||
} // else fall through
|
||||
case STATE_INTEGER:
|
||||
if (integer(buffer[pos])) {
|
||||
_int *= 10
|
||||
_int += buffer[pos] - 0x30
|
||||
} else if (buffer[pos] === E) {
|
||||
var ret = neg ? 0 - _int : _int
|
||||
cb(ret)
|
||||
state = STATE_INITIAL
|
||||
} else {
|
||||
throw new Error('not part of int at:'+pos.toString(16))
|
||||
}
|
||||
break
|
||||
} // switch state
|
||||
} // for buffer
|
||||
} // function parse
|
||||
|
||||
function integer (value) {
|
||||
// check that value is a number and that
|
||||
// its value is ascii integer.
|
||||
if (typeof value !== 'number') {
|
||||
return false
|
||||
}
|
||||
return between(value, 0x30, 0x39)
|
||||
}
|
||||
function between (val, min, max) {
|
||||
return (min <= val && val <= max)
|
||||
}
|
||||
|
||||
} // end BdecodeSMachine
|
||||
|
||||
/*
|
||||
* The exported decode functionality.
|
||||
*/
|
||||
function Bdecode () {
|
||||
// markers
|
||||
var DICTIONARY_START = {}
|
||||
var LIST_START = {}
|
||||
|
||||
var Context = function () {
|
||||
var self = this
|
||||
var stack = []
|
||||
|
||||
this.cb = function (o) {
|
||||
stack.push(o)
|
||||
}
|
||||
this.cb_list = function () {
|
||||
self.cb(LIST_START)
|
||||
}
|
||||
this.cb_dict = function () {
|
||||
self.cb(DICTIONARY_START)
|
||||
}
|
||||
|
||||
this.cb_end = function () {
|
||||
|
||||
// unwind the stack until either a DICTIONARY_START or LIST_START is
|
||||
// found, create arr or hash, stick unwound stack on, push arr or hash
|
||||
// back onto stack
|
||||
|
||||
var obj = null
|
||||
var tmp_stack = []
|
||||
|
||||
while ((obj = stack.pop()) !== undefined) {
|
||||
if (LIST_START === obj) {
|
||||
var obj2 = null
|
||||
var list = []
|
||||
while((obj2 = tmp_stack.pop()) !== undefined) {
|
||||
list.push(obj2)
|
||||
}
|
||||
self.cb(list)
|
||||
break
|
||||
} else if (DICTIONARY_START === obj) {
|
||||
var key = null
|
||||
var val = null
|
||||
var dic = {}
|
||||
while ((key = tmp_stack.pop()) !== undefined && (val = tmp_stack.pop()) !== undefined) {
|
||||
dic[key.toString()] = val
|
||||
}
|
||||
|
||||
if (key !== undefined && dic[key] === undefined) {
|
||||
throw new Error('uneven number of keys and values A')
|
||||
}
|
||||
self.cb(dic)
|
||||
break
|
||||
} else {
|
||||
tmp_stack.push(obj)
|
||||
}
|
||||
}
|
||||
if (tmp_stack.length > 0) {
|
||||
// could this case even occur?
|
||||
throw new Error('uneven number of keys and values B')
|
||||
}
|
||||
}
|
||||
this.result = function () {
|
||||
return stack
|
||||
}
|
||||
}
|
||||
|
||||
var self = this
|
||||
var ctx = new Context()
|
||||
var smachine = new BdecodeSMachine(ctx.cb, ctx.cb_list, ctx.cb_dict, ctx.cb_end)
|
||||
|
||||
this.result = function () {
|
||||
if (!smachine.consistent()) {
|
||||
throw new Error('not in consistent state. More bytes coming?')
|
||||
}
|
||||
return ctx.result()
|
||||
}
|
||||
|
||||
this.decode = function (buf, encoding) {
|
||||
smachine.parse(buf, encoding)
|
||||
}
|
||||
}
|
||||
|
||||
function Bencode (obj) {
|
||||
var self = this
|
||||
var to_encode = obj
|
||||
var buffer = null
|
||||
|
||||
switch (typeof obj) {
|
||||
case 'string':
|
||||
return encodeString(obj)
|
||||
case 'number':
|
||||
return encodeNumber(obj)
|
||||
case 'object':
|
||||
if (obj instanceof Array) {
|
||||
return encodeList(obj)
|
||||
} else if (Buffer.isBuffer(obj)) {
|
||||
return encodeBuffer(obj)
|
||||
} else {
|
||||
// assume it's a hash
|
||||
return encodeDict(obj)
|
||||
}
|
||||
}
|
||||
|
||||
function encodeString (obj) {
|
||||
var blen = Buffer.byteLength(obj)
|
||||
var len = blen.toString(10)
|
||||
var buf = new Buffer(len.length + 1 + blen)
|
||||
|
||||
buf.write(len, 0, 'ascii')
|
||||
buf.write(':', len.length, 'ascii')
|
||||
buf.write(obj, len.length + 1, 'utf8')
|
||||
|
||||
return buf
|
||||
}
|
||||
|
||||
function encodeNumber (num) {
|
||||
var n = num.toString(10)
|
||||
var buf = new Buffer(n.length + 2)
|
||||
|
||||
buf.write('i', 0)
|
||||
buf.write(n, 1)
|
||||
buf.write('e', n.length + 1)
|
||||
|
||||
return buf
|
||||
}
|
||||
|
||||
function encodeDict (obj) {
|
||||
var func = function (obj, pos) {
|
||||
var keys = Object.keys(obj).sort()
|
||||
keys.forEach(function (key) {
|
||||
var val = new Bencode(obj[key])
|
||||
key = new Bencode(key)
|
||||
|
||||
ensure(key.length + val.length, pos)
|
||||
key.copy(buffer, pos, 0)
|
||||
pos += key.length
|
||||
val.copy(buffer, pos, 0)
|
||||
pos += val.length
|
||||
})
|
||||
return pos
|
||||
}
|
||||
return assemble(obj, 'd', func)
|
||||
}
|
||||
|
||||
function encodeList (obj) {
|
||||
var func = function(obj, pos) {
|
||||
obj.forEach(function (o) {
|
||||
var elem = new Bencode(o)
|
||||
|
||||
ensure(elem.length, pos)
|
||||
elem.copy(buffer, pos, 0)
|
||||
pos += elem.length
|
||||
})
|
||||
return pos
|
||||
}
|
||||
return assemble(obj, 'l', func)
|
||||
}
|
||||
|
||||
function encodeBuffer (obj) {
|
||||
var len = obj.length.toString(10)
|
||||
var buf = new Buffer(len.length + 1 + obj.length)
|
||||
|
||||
buf.write(len, 0, 'ascii')
|
||||
buf.write(':', len.length, 'ascii')
|
||||
obj.copy(buf, len.length + 1, 0)
|
||||
|
||||
return buf
|
||||
}
|
||||
|
||||
function assemble (obj, prefix, func) {
|
||||
var pos = 0
|
||||
|
||||
ensure(1024, 0)
|
||||
buffer.write(prefix, pos++)
|
||||
|
||||
pos = func(obj, pos)
|
||||
ensure(1, pos)
|
||||
|
||||
buffer.write('e', pos++)
|
||||
return buffer.slice(0, pos)
|
||||
}
|
||||
|
||||
function ensure (num, pos) {
|
||||
if (!buffer) {
|
||||
buffer = new Buffer(num)
|
||||
} else {
|
||||
if (buffer.length > num + pos + 1) {
|
||||
return
|
||||
} else {
|
||||
var buf2 = new Buffer(buffer.length + num)
|
||||
buffer.copy(buf2, 0, 0)
|
||||
buffer = buf2
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function decode (buffer, encoding) {
|
||||
var decoder = new Bdecode()
|
||||
|
||||
decoder.decode(buffer, encoding)
|
||||
return decoder.result()[0]
|
||||
}
|
||||
|
||||
function Stream (options) {
|
||||
options = options || {}
|
||||
options.objectMode = true
|
||||
Transform.call(this, options)
|
||||
this._decoder = new Bdecode()
|
||||
}
|
||||
|
||||
inherits(Stream, Transform)
|
||||
|
||||
Stream.prototype._transform = function (chunk, encoding, callback) {
|
||||
try {
|
||||
this._decoder.decode(chunk, encoding)
|
||||
callback(null)
|
||||
} catch(err) {
|
||||
callback(err)
|
||||
}
|
||||
}
|
||||
|
||||
Stream.prototype._flush = function (callback) {
|
||||
this.push(this._decoder.result()[0])
|
||||
callback(null)
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
use waddaFork::tait;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<()> {
|
||||
// create ethers client and wrap it in Arc<M>
|
||||
// let client = Arc::new(nick.local.CLIENT);
|
||||
await tait().?;
|
||||
println!("Hello, world!");
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
use std::{str::FromStr, sync::Arc};
|
||||
use anyhow::{Ok, Result};
|
||||
use bytes::Bytes;
|
||||
use ethers::{
|
||||
abi::parse_abi,
|
||||
prelude::BaseContract,
|
||||
providers::{Http, Provider},
|
||||
};
|
||||
use revm::{
|
||||
db::{CacheDB, EmptyDB, EthersDB},
|
||||
primitives::{ExecutionResult, Output, TransactTo, B160, U256 as rU256},
|
||||
Database, EVM,
|
||||
};
|
||||
|
||||
#[tokio::main]
|
||||
async fn tait() -> Result<()> {
|
||||
// create ethers client and wrap it in Arc<M>
|
||||
let client = Provider::<Http>::try_from(
|
||||
"https://mainnet.infura.io/v3/c60b0bb42f8a4c6481ecd229eddaca27",
|
||||
)?;
|
||||
let client = Arc::new(client);
|
||||
|
||||
// ----------------------------------------------------------- //
|
||||
// Storage slots of UniV2Pair contract //
|
||||
// =========================================================== //
|
||||
// storage[5] = factory: address //
|
||||
// storage[6] = token0: address //
|
||||
// storage[7] = token1: address //
|
||||
// storage[8] = (res0, res1, ts): (uint112, uint112, uint32) //
|
||||
// storage[9] = price0CumulativeLast: uint256 //
|
||||
// storage[10] = price1CumulativeLast: uint256 //
|
||||
// storage[11] = kLast: uint256 //
|
||||
// =========================================================== //
|
||||
|
||||
// choose slot of storage that you would like to transact with
|
||||
let slot = rU256::from(8);
|
||||
|
||||
// ETH/USDT pair on Uniswap V2
|
||||
let pool_address = B160::from_str("0x252ea274ff957494274057ed94844ffd7184e21f")?;
|
||||
|
||||
// generate abi for the calldata from the human readable interface
|
||||
let abi = BaseContract::from(
|
||||
parse_abi(&[
|
||||
"function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)",
|
||||
])?
|
||||
);
|
||||
|
||||
// encode abi into Bytes
|
||||
let encoded = abi.encode("getReserves", ())?;
|
||||
|
||||
// initialize new EthersDB
|
||||
let mut ethersdb = EthersDB::new(Arc::clone(&client), None).unwrap();
|
||||
|
||||
// query basic properties of an account incl bytecode
|
||||
let acc_info = ethersdb.basic(pool_address).unwrap().unwrap();
|
||||
|
||||
// query value of storage slot at account address
|
||||
let value = ethersdb.storage(pool_address, slot).unwrap();
|
||||
|
||||
// initialise empty in-memory-db
|
||||
let mut cache_db = CacheDB::new(EmptyDB::default());
|
||||
|
||||
// insert basic account info which was generated via Web3DB with the corresponding address
|
||||
cache_db.insert_account_info(pool_address, acc_info);
|
||||
|
||||
// insert our pre-loaded storage slot to the corresponding contract key (address) in the DB
|
||||
cache_db
|
||||
.insert_account_storage(pool_address, slot, value)
|
||||
.unwrap();
|
||||
|
||||
// initialise an empty (default) EVM
|
||||
let mut evm = EVM::new();
|
||||
|
||||
// insert pre-built database from above
|
||||
evm.database(cache_db);
|
||||
|
||||
// fill in missing bits of env struc
|
||||
// change that to whatever caller you want to be
|
||||
evm.env.tx.caller = B160::from_str("0x0000000000000000000000000000000000000000")?;
|
||||
// account you want to transact with
|
||||
evm.env.tx.transact_to = TransactTo::Call(pool_address);
|
||||
// calldata formed via abigen
|
||||
evm.env.tx.data = Bytes::from(hex::decode(hex::encode(&encoded))?);
|
||||
// transaction value in wei
|
||||
evm.env.tx.value = rU256::try_from(0)?;
|
||||
|
||||
// execute transaction without writing to the DB
|
||||
let ref_tx = evm.transact_ref().unwrap();
|
||||
// select ExecutionResult struct
|
||||
let result = ref_tx.result;
|
||||
|
||||
// unpack output call enum into raw bytes
|
||||
let value = match result {
|
||||
ExecutionResult::Success { output, .. } => match output {
|
||||
Output::Call(value) => Some(value),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
};
|
||||
|
||||
// decode bytes to reserves + ts via ethers-rs's abi decode
|
||||
let (reserve0, reserve1, ts): (u128, u128, u32) =
|
||||
abi.decode_output("getReserves", value.unwrap())?;
|
||||
|
||||
// Print emulated getReserves() call output
|
||||
println!("Reserve0: {:#?}", reserve0);
|
||||
println!("Reserve1: {:#?}", reserve1);
|
||||
println!("Timestamp: {:#?}", ts);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue