def buy(accounts):
# Buy 2 kitties for each account.
ret_set = db.saleauctions.aggregate([{
'$sample': {
'size': len(accounts) * 2
}
}])
targets = []
for i in ret_set:
targets.append(i)
#print(targets)
txs = {}
hashes = []
for i in range(len(accounts)):
for j in range(2):
raw_tx, tx_hash = accounts[i].sign(
sale_auction_contract.functions.bid(
targets[i * 2 + j]['id']).buildTransaction({
'value':
targets[i * 2 + j]['startingPrice'],
'gas':
1000000000,
'gasPrice':
1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
print('buy {} kitties'.format(len(txs)))
# Remove from saleauctions.
idsToRemove = []
idsToReturn = []
receipts = wait_for_receipts(cli, hashes)
ok = 0
fail = 0
for i in range(len(hashes)):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
#print(receipt)
fail += 1
idsToReturn.append(None)
continue
processed_receipt = sale_auction_contract.processReceipt(receipt)
if 'AuctionSuccessful' in processed_receipt:
ok += 1
idsToRemove.append(
processed_receipt['AuctionSuccessful']['tokenId'])
idsToReturn.append(
processed_receipt['AuctionSuccessful']['tokenId'])
else:
fail += 1
print('ok = {}, fail = {}'.format(ok, fail))
db.saleauctions.remove({'id': {'$in': idsToRemove}})
return idsToReturn
def make_one_batch():
users = []
idsToRemove = []
ret_set = db.candidates.aggregate([{
'$sample': {
'size': num_per_batch * 2
}
}])
for i in ret_set:
users.append(i)
idsToRemove.append(i['_id'])
if len(users) < num_per_batch * 2:
assert False
db.candidates.remove({'_id': {'$in': idsToRemove}})
txs = {}
hashes = []
for i in range(num_per_batch):
acc = Account(users[i]['private_key'])
raw_tx, tx_hash = acc.sign(
kitty_core_contract.functions.createSaleAuction(
users[i]['kitty'],
int(1e15),
0,
86400,
).buildTransaction({
'value': 0,
'gas': 100000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
receipts = wait_for_receipts(cli, hashes)
with open(output, 'a') as f:
for i in range(num_per_batch):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
assert False
processed_receipt = sale_auction_contract.processReceipt(receipt)
if 'AuctionCreated' not in processed_receipt:
assert False
acc = Account(users[i + num_per_batch]['private_key'])
raw_tx, tx_hash = acc.sign(
sale_auction_contract.functions.bid(
users[i]['kitty']).buildTransaction({
'value': int(1e15),
'gas': 100000000,
'gasPrice': 1,
}))
f.write('{},{}\n'.format(raw_tx.hex(), tx_hash.hex()))
def breed(accounts, kitties, n):
# Breed.
txs = {}
hashes = []
m = []
for i in range(len(accounts)):
if kitties[i * 2] is None or kitties[i * 2 + 1] is None:
continue
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.breedWithAuto(
kitties[i * 2], kitties[i * 2 + 1]).buildTransaction({
'value':
int(1e15),
'gas':
1000000000,
'gasPrice':
1,
'nonce':
n,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
m.append(kitties[i * 2])
cli.sendTransactions(txs)
print('txs = {}'.format(len(txs)))
receipts = wait_for_receipts(cli, hashes)
matrons = []
for i in range(len(hashes)):
receipt = receipts[hashes[i]]
#print(receipt)
if receipt['status'] != 1:
print(hashes[i].hex())
continue
matrons.append(m[i])
if i == 0:
print(hashes[0].hex())
print('ok = {}'.format(len(matrons)))
# Wait for the birth of children.
found = 0
notfound = len(matrons)
for matron in matrons:
#print('try {}'.format(matron))
while True:
item = db.newborns.find_one({'matronId': matron})
if item is not None:
db.newborns.delete_one({'matronId': matron})
#found += 1
#notfound -= 1
#print('found = {}, not found = {}'.format(found, notfound))
break
time.sleep(1)
def bid_on_siring_auction(accounts, kitties):
# Find a sire for each matron we owned.
targets = []
while True:
ret_set = db.siringauctions.aggregate([{
'$sample': {
'size': len(accounts)
}
}])
for i in ret_set:
targets.append(i['id'])
if len(targets) == len(accounts):
break
time.sleep(3)
targets = []
txs = {}
for i in range(len(accounts)):
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.bidOnSiringAuction(
targets[i], kitties[i]).buildTransaction({
'value': int(1e15 * 2),
'gas': 1000000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
cli.sendTransactions(txs)
# Remove from siringauctions.
idsToRemove = []
receipts = wait_for_receipts(cli, list(txs.keys()))
for receipt in receipts.values():
if receipt['status'] != 1:
continue
processed_receipt = siring_auction_contract.processReceipt(receipt)
if 'AuctionSuccessful' in processed_receipt:
idsToRemove.append(
processed_receipt['AuctionSuccessful']['tokenId'])
print(processed_receipt)
db.siringauctions.remove({'id': {'$in': idsToRemove}})
# Wait for the sirings complete.
# TODO
for id in idsToRemove:
while True:
item = db.siringauctioncomplete.find_one({'sireId': id})
if item is not None:
db.siringauctioncomplete.delete_one({'sireId': id})
print(id)
break
time.sleep(1)
def transfer(accounts, kitties, n):
count = len(kitties)
# print(count)
# print(kitties)
txs = {}
hashes = []
for i in range(count):
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.transfer(
accounts[i + count].address(),
kitties[i],
).buildTransaction({
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
'nonce': n + 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
for i in range(count):
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.transfer(
accounts[i + count * 2].address(),
kitties[i],
).buildTransaction({
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
'nonce': n + 2,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
ret_accounts = [0] * len(accounts)
receipts = wait_for_receipts(cli, hashes)
for i in range(len(hashes)):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
ret_accounts[int(i / 2 + count)] = accounts[i + count]
print(receipt)
continue
processed_receipt = kitty_core_contract.processReceipt(receipt)
if 'Transfer' in processed_receipt:
ret_accounts[int(i / 2)] = accounts[i + count]
ret_accounts[int(i / 2 + count * 2)] = accounts[int(i / 2)]
print(processed_receipt)
return ret_accounts, kitties
def create_siring_auction(accounts, kitties):
# Create a siring auction for each kitty.
txs = {}
for i in range(len(accounts)):
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.createSiringAuction(
kitties[i], int(1e15), 0, 60).buildTransaction({
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
cli.sendTransactions(txs)
auctions = []
receipts = wait_for_receipts(cli, list(txs.keys()))
for receipt in receipts.values():
if receipt['status'] != 1:
print(receipt)
continue
processed_receipt = siring_auction_contract.processReceipt(receipt)
if 'AuctionCreated' in processed_receipt:
newAuction = {
'id':
processed_receipt['AuctionCreated']['tokenId'],
'startingPrice':
int(processed_receipt['AuctionCreated']['startingPrice'], 16),
'endingPrice':
int(processed_receipt['AuctionCreated']['endingPrice'], 16),
'duration':
int(processed_receipt['AuctionCreated']['duration'], 16),
}
auctions.append(newAuction)
db.siringauctions.insert_many(auctions)
print(auctions)
# Wait for the sirings complete.
# TODO
for auction in auctions:
while True:
item = db.newborns.find_one({'sireId': auction['id']})
if item is not None:
db.newborns.delete_one({'kittyId': item['kittyId']})
db.siringauctioncomplete.insert_one({'sireId': auction['id']})
print('auction complete')
break
time.sleep(1)
def buy(accounts):
# Buy 1 kitty for each account.
ret_set = db.saleauctions.aggregate([{
'$sample': {
'size': len(accounts) / 3
}
}])
targets = []
for i in ret_set:
targets.append(i)
txs = {}
hashes = []
for i in range(len(targets)):
raw_tx, tx_hash = accounts[i].sign(
sale_auction_contract.functions.bid(
targets[i]['id']).buildTransaction({
'value':
targets[i]['startingPrice'],
'gas':
1000000000,
'gasPrice':
1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
# Remove from saleauctions.
idsToRemove = []
receipts = wait_for_receipts(cli, hashes)
for i in range(len(hashes)):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
continue
processed_receipt = sale_auction_contract.processReceipt(receipt)
if 'AuctionSuccessful' in processed_receipt:
idsToRemove.append(
processed_receipt['AuctionSuccessful']['tokenId'])
db.saleauctions.remove({'id': {'$in': idsToRemove}})
return idsToRemove
storage_svc_contract = cli.eth.contract(abi=storage_svc['abi'],
bytecode=storage_svc['bin'])
computing_svc_contract = cli.eth.contract(abi=computing_svc['abi'],
bytecode=computing_svc['bin'])
main_svc_contract = cli.eth.contract(abi=main_svc['abi'],
bytecode=main_svc['bin'])
account = Account(private_key)
raw_tx, tx_hash = account.sign(
storage_svc_contract.constructor().buildTransaction({
'nonce': 1,
'gas': 1000000000,
'gasPrice': 1,
}))
cli.sendTransactions({tx_hash: raw_tx})
receipts = wait_for_receipts(cli, [tx_hash])
storage_svc_address = receipts[tx_hash]['contractAddress']
raw_tx, tx_hash = account.sign(
computing_svc_contract.constructor().buildTransaction({
'nonce': 2,
'gas': 1000000000,
'gasPrice': 1,
}))
cli.sendTransactions({tx_hash: raw_tx})
receipts = wait_for_receipts(cli, [tx_hash])
computing_svc_address = receipts[tx_hash]['contractAddress']
raw_tx, tx_hash = account.sign(
main_svc_contract.constructor().buildTransaction({
'nonce': 3,
txs = {}
hashes = []
for j in range(batch_start, batch_end):
raw_tx, tx_hash = coo.sign(
kitty_core_contract.functions.createPromoKitty(
j, addresses[j]).buildTransaction({
'nonce': j,
'gas': 1000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
candidates = []
receipts = wait_for_receipts(cli, hashes)
for j in range(len(hashes)):
receipt = receipts[hashes[j]]
if receipt['status'] != 1:
assert False
processed_receipt = kitty_core_contract.processReceipt(receipt)
if 'Birth' not in processed_receipt:
assert False
candidates.append({
'private_key': private_keys[batch_start + j],
'address': addresses[batch_start + j],
'kitty': processed_receipt['Birth']['kittyId'],
})
db.candidates.insert_many(candidates)
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
time.sleep(30)
print(i)
#print(txs.keys())
for i in range(10):
print(i)
l = hashes[i*kitty_count:(i+1)*kitty_count]
auctions = []
kitties = []
receipts = wait_for_receipts(cli, l)
for receipt in receipts.values():
#print(receipt)
processed_receipt = sale_auction_contract.processReceipt(receipt)
# print(processed_receipt)
if 'AuctionCreated' in processed_receipt:
newAuction = {
'id': processed_receipt['AuctionCreated']['tokenId'],
'startingPrice': int(processed_receipt['AuctionCreated']['startingPrice'], 16),
'endingPrice': int(processed_receipt['AuctionCreated']['endingPrice'], 16),
'duration': int(processed_receipt['AuctionCreated']['duration'], 16),
}
auctions.append(newAuction)
processed_receipt = kitty_core_contract.processReceipt(receipt)
if 'Birth' in processed_receipt:
# 1. Deploy KittyCore.
ceo = Account(ceo_private_key)
coo = Account(coo_private_key)
cfo = Account(cfo_private_key)
raw_tx, tx_hash = ceo.sign(kitty_core_contract.constructor().buildTransaction({
'nonce':
1,
'gas':
10000000000,
'gasPrice':
1,
}))
cli.sendTransactions({tx_hash: raw_tx})
receipts = wait_for_receipts(cli, [tx_hash])
check_receipts(receipts)
kitty_core_address = receipts[tx_hash]['contractAddress']
kitty_core_contract.setAddress(kitty_core_address)
# 2. Deploy SaleClockAuction, SiringAuction and GeneScience.
sale_auction_contract = cli.eth.contract(abi=sale_auction['abi'],
bytecode=sale_auction['bin'])
raw_tx1, tx_hash1 = ceo.sign(
sale_auction_contract.constructor(kitty_core_address,
100).buildTransaction({
'nonce': 2,
'gas': 10000000000,
'gasPrice': 1,
}))
siring_auction_contract = cli.eth.contract(abi=siring_auction['abi'],
def buy_and_sale(accounts, n):
# Buy 1 kitty for each account.
ret_set = db.saleauctions.aggregate([{'$sample': {'size': len(accounts)/2}}])
targets = []
for i in ret_set:
targets.append(i)
print(targets)
txs = {}
hashes = []
for i in range(len(targets)):
raw_tx, tx_hash = accounts[i*2].sign(sale_auction_contract.functions.bid(targets[i]['id']).buildTransaction({
'value': targets[i]['startingPrice'],
'gas': 1000000000,
'gasPrice': 1,
'nonce': n+i,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
raw_tx, tx_hash = accounts[i*2+1].sign(sale_auction_contract.functions.bid(targets[i]['id']).buildTransaction({
'value': targets[i]['startingPrice'],
'gas': 1000000000,
'gasPrice': 1,
'nonce': n+i,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
# Remove from saleauctions, then create a new sale auction.
txs = {}
idsToRemove = []
receipts = wait_for_receipts(cli, hashes)
for i in range(len(accounts)):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
print('bid kitty {} failed: {}'.format(targets[int(i/2)], receipt))
continue
processed_receipt = sale_auction_contract.processReceipt(receipt)
print(processed_receipt)
if 'AuctionSuccessful' in processed_receipt:
idsToRemove.append(processed_receipt['AuctionSuccessful']['tokenId'])
raw_tx, tx_hash = accounts[i].sign(kitty_core_contract.functions.createSaleAuction(
processed_receipt['AuctionSuccessful']['tokenId'],
int(1e15),
0,
86400
).buildTransaction({
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
'nonce': n+i,
}))
txs[tx_hash] = raw_tx
processed_receipt = kitty_core_contract.processReceipt(receipt)
print(processed_receipt)
cli.sendTransactions(txs)
db.saleauctions.remove({'id': {'$in': idsToRemove}})
auctions = []
receipts = wait_for_receipts(cli, list(txs.keys()))
for receipt in receipts.values():
if receipt['status'] != 1:
print('create sale auction failed: {}'.format(receipt))
continue
processed_receipt = sale_auction_contract.processReceipt(receipt)
print(processed_receipt)
if 'AuctionCreated' in processed_receipt:
newAuction = {
'id': processed_receipt['AuctionCreated']['tokenId'],
'startingPrice': int(processed_receipt['AuctionCreated']['startingPrice'], 16),
'endingPrice': int(processed_receipt['AuctionCreated']['endingPrice'], 16),
'duration': int(processed_receipt['AuctionCreated']['duration'], 16),
}
auctions.append(newAuction)
db.saleauctions.insert_many(auctions)
def make_one_batch():
users = []
idsToRemove = []
ret_set = db.candidates.aggregate([{
'$sample': {
'size': num_per_batch * 2
}
}])
for i in ret_set:
users.append(i)
idsToRemove.append(i['_id'])
if len(users) < num_per_batch * 2:
assert False
db.candidates.remove({'_id': {'$in': idsToRemove}})
txs = {}
hashes = []
for i in range(num_per_batch):
acc = Account(users[i]['private_key'])
raw_tx, tx_hash = acc.sign(
kitty_core_contract.functions.approveSiring(
users[i + num_per_batch]['address'],
users[i]['kitty'],
).buildTransaction({
'value': 0,
'gas': 100000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
cli.sendTransactions(txs)
receipts = wait_for_receipts(cli, hashes)
txs = {}
hashes2 = []
for i in range(num_per_batch):
receipt = receipts[hashes[i]]
if receipt['status'] != 1:
assert False
acc = Account(users[i + num_per_batch]['private_key'])
raw_tx, tx_hash = acc.sign(
kitty_core_contract.functions.breedWithAuto(
users[i + num_per_batch]['kitty'],
users[i]['kitty'],
).buildTransaction({
'value': int(1e15),
'gas': 100000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes2.append(tx_hash)
cli.sendTransactions(txs)
receipts = wait_for_receipts(cli, hashes2)
miner = Account(miner_private_key)
with open(output, 'a') as f:
for i in range(num_per_batch):
receipt = receipts[hashes2[i]]
if receipt['status'] != 1:
assert False
raw_tx, tx_hash = miner.sign(
kitty_core_contract.functions.giveBirth(
users[i + num_per_batch]['kitty']).buildTransaction({
'value':
0,
'gas':
100000000,
'gasPrice':
1,
}))
f.write('{},{}\n'.format(raw_tx.hex(), tx_hash.hex()))
def transfer(accounts, kitties, n):
count = len(accounts)
# print(count)
# print(kitties)
txs = {}
hashes = []
hashes_to_trace = []
for i in range(int(count / 2)):
#print(i)
if kitties[i] is None:
hashes_to_trace.append(None)
continue
raw_tx, tx_hash = accounts[i].sign(
kitty_core_contract.functions.transfer(
accounts[int(i + count / 2)].address(),
kitties[i],
).buildTransaction({
'nonce': n,
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
hashes_to_trace.append(tx_hash)
print(tx_hash.hex(), file=sys.stderr)
cli.sendTransactions(txs)
print(len(txs))
kitties = [None] * len(kitties)
receipts = wait_for_receipts(cli, hashes)
for i in range(len(hashes_to_trace)):
if hashes_to_trace[i] is None:
continue
receipt = receipts[hashes_to_trace[i]]
if receipt['status'] != 1:
print(hashes_to_trace[i].hex())
exit(1)
#continue
processed_receipt = kitty_core_contract.processReceipt(receipt)
if 'Transfer' in processed_receipt:
print('tx hash = {}, receipt = {}'.format(hashes_to_trace[i],
processed_receipt),
file=sys.stderr)
if i < count / 2:
kitties[int(i + count /
2)] = processed_receipt['Transfer']['tokenId']
else:
kitties[int(i - count /
2)] = processed_receipt['Transfer']['tokenId']
txs = {}
hashes = []
for i in range(int(count / 2)):
if kitties[int(i + count / 2)] is None:
hashes_to_trace.append(None)
continue
raw_tx, tx_hash = accounts[int(i + count / 2)].sign(
kitty_core_contract.functions.transfer(
accounts[i].address(),
kitties[int(i + count / 2)],
).buildTransaction({
'nonce': n,
'value': 0,
'gas': 1000000000,
'gasPrice': 1,
}))
txs[tx_hash] = raw_tx
hashes.append(tx_hash)
hashes_to_trace.append(tx_hash)
print(tx_hash.hex(), file=sys.stderr)
cli.sendTransactions(txs)
print(len(txs))
receipts = wait_for_receipts(cli, hashes)
for i in range(int(count / 2), len(hashes_to_trace)):
if hashes_to_trace[i] is None:
continue
receipt = receipts[hashes_to_trace[i]]
if receipt['status'] != 1:
print(hashes_to_trace[i].hex())
exit(1)
#continue
processed_receipt = kitty_core_contract.processReceipt(receipt)
if 'Transfer' in processed_receipt:
print('sender = {}, tx hash = {}, receipt = {}'.format(
accounts[i].address(), hashes_to_trace[i], processed_receipt),
file=sys.stderr)
if i < count / 2:
kitties[int(i + count /
2)] = processed_receipt['Transfer']['tokenId']
else:
kitties[int(i - count /
2)] = processed_receipt['Transfer']['tokenId']
return kitties
frontend = sys.argv[1]
input = sys.argv[2]
cli = Cli(HTTPProvider(frontend))
hashes = []
with open(input, 'r') as f:
for line in f:
line = line.rstrip('\n')
segments = line.split(',')
hashes.append(bytes(bytearray.fromhex(segments[1])))
batch = []
for h in hashes:
batch.append(h)
if len(batch) == 1000:
receipts = wait_for_receipts(cli, batch)
batch = []
for h in receipts.keys():
receipt = receipts[h]
if receipt['status'] != 1:
assert False
if len(batch) != 0:
receipts = wait_for_receipts(cli, batch)
for h in receipts.keys():
receipt = receipts[h]
if receipt['status'] != 1:
assert False
