def test_should_require_positive_coefficient(self):
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 60, 0)
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 60, 1)
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 60, -1)
def test_behaves_with_realistic_values(self):
# given
GWEI = 1000000000
geometric_gas_price = GeometricGasPrice(100 * GWEI, 10,
1 + (0.125 * 2))
for seconds in [0, 1, 10, 12, 30, 60]:
print(
f"gas price after {seconds} seconds is {geometric_gas_price.get_gas_price(seconds)/GWEI}"
)
assert round(geometric_gas_price.get_gas_price(0) / GWEI, 1) == 100.0
assert round(geometric_gas_price.get_gas_price(1) / GWEI, 1) == 100.0
assert round(geometric_gas_price.get_gas_price(10) / GWEI, 1) == 125.0
assert round(geometric_gas_price.get_gas_price(12) / GWEI, 1) == 125.0
assert round(geometric_gas_price.get_gas_price(30) / GWEI, 1) == 195.3
assert round(geometric_gas_price.get_gas_price(60) / GWEI, 1) == 381.5
def test_simultaneous(self):
gas = GeometricGasPrice(initial_price=int(0.5 * GWEI),
every_secs=30,
max_price=2000 * GWEI)
self._run_future(
collateral.adapter.join(our_address,
Wad(1)).transact_async(gas_price=gas))
self._run_future(
collateral.adapter.join(our_address,
Wad(5)).transact_async(gas_price=gas))
asyncio.sleep(6)
def setup_class(self):
""" I'm excluding initialization of a specific collateral perchance we use multiple collaterals
to improve test speeds. This prevents us from instantiating the keeper as a class member. """
self.web3 = web3()
self.mcd = mcd(self.web3)
self.keeper_address = keeper_address(self.mcd.web3)
self.web3.eth.defaultAccount = self.keeper_address.address
self.collateral = self.mcd.collaterals['ETH-A']
self.collateral.approve(self.keeper_address)
assert self.collateral.gem.deposit(Wad.from_number(1)).transact()
self.ilk = self.collateral.ilk
self.gas = GeometricGasPrice(initial_price=int(1.1*GeometricGasPrice.GWEI), every_secs=2)
def test_gas_price_should_increase_with_time(self):
# given
geometric_gas_price = GeometricGasPrice(100, 10)
# expect
assert geometric_gas_price.get_gas_price(0) == 100
assert geometric_gas_price.get_gas_price(1) == 100
assert geometric_gas_price.get_gas_price(10) == 113
assert geometric_gas_price.get_gas_price(15) == 113
assert geometric_gas_price.get_gas_price(20) == 127
assert geometric_gas_price.get_gas_price(30) == 143
assert geometric_gas_price.get_gas_price(50) == 181
assert geometric_gas_price.get_gas_price(100) == 325
def get_gas_price(self, time_elapsed: int) -> Optional[int]:
# start with fast price from the configured gas API
fast_price = self.gas_station.fast_price() if self.gas_station else None
# if API produces no price, or remote feed not configured, start with a fixed price
if fast_price is None:
initial_price = self.fixed_gas if self.fixed_gas else 10 * self.GWEI
# otherwise, use the API's fast price, adjusted by a coefficient, as our starting point
else:
initial_price = int(round(fast_price * self.initial_multiplier))
return GeometricGasPrice(initial_price=initial_price,
every_secs=61,
coefficient=self.reactive_multiplier,
max_price=self.gas_maximum).get_gas_price(time_elapsed)
def test_gas_price_should_obey_max_value(self):
# given
geometric_gas_price = GeometricGasPrice(1000, 60, 1.125, 2500)
# expect
assert geometric_gas_price.get_gas_price(0) == 1000
assert geometric_gas_price.get_gas_price(1) == 1000
assert geometric_gas_price.get_gas_price(59) == 1000
assert geometric_gas_price.get_gas_price(60) == 1125
assert geometric_gas_price.get_gas_price(119) == 1125
assert geometric_gas_price.get_gas_price(120) == 1266
assert geometric_gas_price.get_gas_price(1200) == 2500
assert geometric_gas_price.get_gas_price(3000) == 2500
assert geometric_gas_price.get_gas_price(1000000) == 2500
if len(sys.argv) > 3:
web3.eth.defaultAccount = sys.argv[2]
register_keys(web3, [sys.argv[3]])
our_address = Address(web3.eth.defaultAccount)
run_transactions = True
elif len(sys.argv) > 2:
our_address = Address(sys.argv[2])
run_transactions = False
else:
our_address = None
run_transactions = False
gas_strategy = DefaultGasPrice() if len(sys.argv) <= 4 else \
GeometricGasPrice(web3=web3,
initial_price=None,
initial_tip=int(float(sys.argv[4]) * GeometricGasPrice.GWEI),
every_secs=5,
max_price=50 * GeometricGasPrice.GWEI)
eth = EthToken(web3, Address.zero())
class TestApp:
def main(self):
with Lifecycle(web3) as lifecycle:
lifecycle.on_block(self.on_block)
def on_block(self):
block = web3.eth.blockNumber
logging.info(f"Found block; web3.eth.blockNumber={block}")
logging.getLogger('urllib3').setLevel(logging.INFO)
logging.getLogger("web3").setLevel(logging.INFO)
logging.getLogger("asyncio").setLevel(logging.INFO)
logging.getLogger("requests").setLevel(logging.INFO)
pool_size = int(sys.argv[3]) if len(sys.argv) > 3 else 10
web3 = web3_via_http(endpoint_uri=os.environ['ETH_RPC_URL'], http_pool_size=pool_size)
web3.eth.defaultAccount = sys.argv[1] # ex: 0x0000000000000000000000000000000aBcdef123
register_keys(web3, [sys.argv[2]]) # ex: key_file=~keys/default-account.json,pass_file=~keys/default-account.pass
mcd = DssDeployment.from_node(web3)
our_address = Address(web3.eth.defaultAccount)
weth = DssDeployment.from_node(web3).collaterals['ETH-A'].gem
GWEI = 1000000000
slow_gas = GeometricGasPrice(initial_price=int(0.8 * GWEI), every_secs=30, max_price=2000 * GWEI)
fast_gas = GeometricGasPrice(initial_price=int(1.1 * GWEI), every_secs=30, max_price=2000 * GWEI)
class TestApp:
def main(self):
self.test_replacement()
self.test_simultaneous()
self.shutdown()
def test_replacement(self):
first_tx = weth.deposit(Wad(4))
logging.info(f"Submitting first TX with gas price deliberately too low")
self._run_future(first_tx.transact_async(gas_price=slow_gas))
time.sleep(0.5)
pool_size = int(sys.argv[3]) if len(sys.argv) > 3 else 10
web3 = web3_via_http(endpoint_uri=os.environ['ETH_RPC_URL'],
http_pool_size=pool_size)
web3.eth.defaultAccount = sys.argv[
1] # ex: 0x0000000000000000000000000000000aBcdef123
register_keys(
web3, [sys.argv[2]]
) # ex: key_file=~keys/default-account.json,pass_file=~keys/default-account.pass
mcd = DssDeployment.from_node(web3)
our_address = Address(web3.eth.defaultAccount)
weth = DssDeployment.from_node(web3).collaterals['ETH-A'].gem
GWEI = 1000000000
slow_gas = GeometricGasPrice(initial_price=int(15 * GWEI),
every_secs=42,
max_price=200 * GWEI)
fast_gas = GeometricGasPrice(initial_price=int(30 * GWEI),
every_secs=42,
max_price=200 * GWEI)
class TestApp:
def main(self):
self.test_replacement()
self.test_simultaneous()
self.shutdown()
def test_replacement(self):
first_tx = weth.deposit(Wad(4))
logging.info(
web3 = web3_via_http(endpoint_uri=os.environ['ETH_RPC_URL'],
http_pool_size=pool_size)
web3.eth.defaultAccount = sys.argv[
1] # ex: 0x0000000000000000000000000000000aBcdef123
register_keys(
web3, [sys.argv[2]]
) # ex: key_file=~keys/default-account.json,pass_file=~keys/default-account.pass
mcd = DssDeployment.from_node(web3)
our_address = Address(web3.eth.defaultAccount)
weth = DssDeployment.from_node(web3).collaterals['ETH-A'].gem
GWEI = 1000000000
slow_gas = GeometricGasPrice(web3=web3,
initial_price=None,
initial_tip=int(0.1 * GWEI),
every_secs=42,
max_price=200 * GWEI)
fast_gas = GeometricGasPrice(web3=web3,
initial_price=None,
initial_tip=int(4.5 * GWEI),
every_secs=42,
max_price=200 * GWEI)
class TestApp:
def main(self):
self.test_replacement()
self.test_simultaneous()
self.shutdown()
def test_max_price_should_exceed_initial_price(self):
with pytest.raises(AssertionError):
GeometricGasPrice(6000, 30, 2.25, 5000)
def test_should_require_positive_max_price_if_provided(self):
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 60, 1.125, 0)
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 60, 1.125, -1)
def test_should_require_positive_every_secs_value(self):
with pytest.raises(AssertionError):
GeometricGasPrice(1000, 0)
with pytest.raises(AssertionError):
GeometricGasPrice(1000, -1)
def test_should_require_positive_initial_price(self):
with pytest.raises(AssertionError):
GeometricGasPrice(0, 60)
with pytest.raises(AssertionError):
GeometricGasPrice(-1, 60)
logging.getLogger("asyncio").setLevel(logging.INFO)
logging.getLogger("requests").setLevel(logging.INFO)
pool_size = int(sys.argv[3]) if len(sys.argv) > 3 else 10
web3 = web3_via_http(endpoint_uri=os.environ['ETH_RPC_URL'])
web3.eth.defaultAccount = sys.argv[
1] # ex: 0x0000000000000000000000000000000aBcdef123
register_keys(
web3, [sys.argv[2]]
) # ex: key_file=~keys/default-account.json,pass_file=~keys/default-account.pass
our_address = Address(web3.eth.defaultAccount)
weth = DssDeployment.from_node(web3).collaterals['ETH-A'].gem
GWEI = 1000000000
increasing_gas = GeometricGasPrice(initial_price=int(1 * GWEI),
every_secs=30,
coefficient=1.5,
max_price=100 * GWEI)
class TestApp:
def main(self):
self.startup()
pending_txes = get_pending_transactions(web3)
pprint(
list(
map(lambda t: f"{t.name()} with gas {t.current_gas}",
pending_txes)))
if len(pending_txes) > 0:
while len(pending_txes) > 0:
