def main(source, name):
# Create keypair for the contract owner
provider1 = Entity()
address1 = Address(provider1)
provider2 = Entity()
address2 = Address(provider2)
scooter1 = Entity()
scooter_address1 = Address(scooter1)
# Setting API up
api = LedgerApi('127.0.0.1', 8100)
# Need funds to deploy contract
api.sync(api.tokens.wealth(provider1, 59000000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(provider1, contract, 2456766))
if name.endswith("contract.etch"):
contract.action(api, 'addProvider', 2456766, [provider2, provider1], address2, address1)
contract.action(api, 'addScooter', 2456766, [provider2, provider1], address2, address1, 22, 1)
print("Wait for txs to be mined ...")
time.sleep(5)
# Printing balance of the creating address1
print(contract.query(api, 'getFleetSize'), " scooter in fleet")
def call(name: str) -> SmartContract:
# Create keypair for the contract owner
provider1 = Entity()
address1 = Address(provider1)
# Setting API up
api = LedgerApi('185.91.52.11', 10002)
# Need funds to deploy contract
api.sync(api.tokens.wealth(provider1, 59000000))
with open(name, "r") as fb:
source = fb.read()
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(provider1, contract, 2456766))
print("Wait for txs to be mined ...")
time.sleep(5)
# Printing balance of the creating address1
print(contract.query(api, 'getAccountRides', acc_id="1"))
def main(source):
# Create keypair for the contract owner
entity = Entity()
address = Address(entity)
# Setting API up
api = LedgerApi('127.0.0.1', 8100)
# Need funds to deploy contract
api.sync(api.tokens.wealth(entity, 5000000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(entity, contract, 2456766))
# Printing balance of the creating address
print(contract.query(api, 'balanceOf', owner=address))
# Getting the 9'th token id.
token_id = contract.query(api, 'getTokenId', number=9)
# Testing
contract.query(api, 'isEqual', number=9, expected=token_id)
# Locating the owner of a token
print("Finding the owner of ", token_id)
print(contract.query(api, 'ownerOf', token_id=token_id))
def main():
# create our first private key pair
entity1 = Entity()
address1 = Address(entity1)
# create a second private key pair
entity2 = Entity()
address2 = Address(entity2)
# build the ledger API
api = LedgerApi('127.0.0.1', 8100)
# create wealth so that we have the funds to be able to create contracts on the network
api.sync(api.tokens.wealth(entity1, 10000))
# create the smart contract
contract = SmartContract(CONTRACT_TEXT)
# deploy the contract to the network
api.sync(api.contracts.create(entity1, contract, 2000))
# print the current status of all the tokens
print('-- BEFORE --')
print_address_balances(api, contract, [address1, address2])
# transfer from one to the other using our newly deployed contract
tok_transfer_amount = 200
fet_tx_fee = 40
api.sync(
contract.action(api, 'transfer', fet_tx_fee, [entity1], address1,
address2, tok_transfer_amount))
print('-- BEFORE --')
print_address_balances(api, contract, [address1, address2])
def prepare_contract(self, price):
# Setting API up
self._api = LedgerApi('127.0.0.1', 8100)
self.scheduler = {}
self.price = price
self.rate = 22
self.max_count = 10
# Need funds to deploy contract
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(
self._api.contracts.create(self._entity, self._contract, 2456766))
self.chargers = [
Entity(),
]
self._contract.action(self._api, 'addCharger', 2456766, [self._entity],
Address(self.chargers[0]),
int(self.latitude * 1000),
int(self.longitude * 1000), self.price,
self.rate, self.max_count)
def main():
print('Loading private key...')
# load up the previously created private key
with open('private.key', 'r') as private_key_file:
entity1 = Entity.load(private_key_file)
print('Loading private key...complete')
# build the ledger API
api = LedgerApi('127.0.0.1', 8000)
# create the smart contract
contract = SmartContract(CONTRACT_TEXT)
print('Deploying contract...')
# deploy the contract to the network
api.sync(api.contracts.create(entity1, contract, 2000))
print('Deploying contract...complete')
# save the contract to the disk
with open('sample.contract', 'w') as contract_file:
contract.dump(contract_file)
def main(source, name):
# Create keypair for the contract owner
charge_provider1 = Entity()
charge_address1 = Address(charge_provider1)
charge_provider2 = Entity()
charge_address2 = Address(charge_provider2)
parking_provider1 = Entity()
parking_address1 = Address(parking_provider1)
parking_provider2 = Entity()
parking_address2 = Address(parking_provider2)
charge1 = Entity()
charge_station_address1 = Address(charge1)
parking1 = Entity()
parking_place_address1 = Address(parking1)
# Setting API up
api = LedgerApi('127.0.0.1', 8100)
# Need funds to deploy contract
api.sync(api.tokens.wealth(charge_provider1, 59000000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(charge_provider1, contract, 2456766))
if name.endswith("contract.etch"):
contract.action(api, 'addChargeProvider', 2456766,
[charge_provider2, charge_provider1], charge_address2,
charge_address1)
contract.action(api, 'addCharge', 2456766,
[charge_provider2, charge_provider1], charge_address2,
charge_address1, 22, 1)
print("Wait for charge txs to be mined ...")
time.sleep(5)
# Printing balance of the creating address1
print(contract.query(api, 'getChargeFleetSize'), " charge in fleet")
contract.action(api, 'addParkingProvider', 2456766,
[parking_provider2, parking_provider1],
parking_address2, parking_address1)
contract.action(api, 'addParking', 2456766,
[parking_provider2, parking_provider1],
parking_address2, parking_address1, 22, 1)
print("Wait for parking txs to be mined ...")
time.sleep(5)
# Printing balance of the creating address1
print(contract.query(api, 'getParkingFleetSize'), " parking in fleet")
def prepare_contract(self):
# Setting API up
self._api = LedgerApi('185.91.52.11', 10002)
# Need funds to deploy contract
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766))
def prepare_contract(self, price):
# Setting API up
self._api = LedgerApi('127.0.0.1', 8100)
self.longitude = 10
self.latitude = 10
self.scheduler = {}
self.price = price
self.rate = 22
self.max_count = 10
# Need funds to deploy contract
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(
self._api.contracts.create(self._entity, self._contract, 2456766))
self.chargers = [
Entity(),
]
#self._contract.action(self._api, 'test', 2456755, [self._entity], Address(self.chargers[0]), Address(self.chargers[0]))
self._contract.action(self._api, 'addCharger', 2456766, [self._entity],
Address(self.chargers[0]), self.longitude,
self.latitude, self.price, self.rate,
self.max_count)
scooter = Entity()
scooter_start_time = 150000
scooter_end_time = 151000
tx_digest = self._contract.action(self._api, 'book', 2456766,
[self._entity],
Address(self.chargers[0]),
Address(scooter), scooter_start_time,
scooter_end_time)
time.sleep(3)
tx_status = self._api.tx.status(tx_digest)
if tx_status == "Executed":
self.scheduler[str(
Address(scooter))] = [scooter_start_time, scooter_end_time]
query = self._contract.query(api=self._api,
name='getSlotInfo',
charger=Address(self.chargers[0]))
print(query)
def submit_contract():
if request.method != 'POST':
return json.dumps({"status": "only POST requests are accepted"})
source = request.form['source']
name = request.form['name']
gas = request.form['gas']
contract = SmartContract(source)
contracts[name] = contract
api.sync(api.contracts.create(entity, contract, gas))
return json.dumps({"status": "done"})
def test_dumps_and_loads_without_owner(self):
# create the contract
orig = SmartContract(CONTRACT_TEXT)
# encode the contract
encoded = orig.dumps()
# re-create the contract
new = SmartContract.loads(encoded)
# checks
self.assertIsInstance(new, SmartContract)
self.assertEqual(orig.owner, new.owner)
self.assertEqual(orig.digest, new.digest)
self.assertEqual(orig.source, new.source)
def main():
# create our first private key pair
entity1 = Entity()
# build the ledger API
api = LedgerApi('127.0.0.1', 8100)
# create wealth so that we have the funds to be able to create contracts on the network
api.sync(api.tokens.wealth(entity1, 1000000000000000))
# create the smart contract
contract = SmartContract(CONTRACT_TEXT)
# deploy the contract to the network
api.sync(api.contracts.create(entity1, contract, 1000000000))
# update the graph with a new model
fet_tx_fee = 100000000
with open(GRAPH_FILE_NAME, mode='rb') as file:
print("reading in graph file...")
rfile = file.read()
print("encoding to base64 string...")
b64obj = base64.b64encode(rfile)
obj = b64obj.decode()
print("updating smart contract graph...")
api.sync(
contract.action(api, 'updateGraph', fet_tx_fee, [entity1], obj))
print("finished updating smart contract graph")
# set one real example input data set
fet_tx_fee = 100000000
api.sync(
contract.action(api, 'setHistorics', fet_tx_fee, [entity1],
EXAMPLE_INPUT_HISTORICS))
current_historics = contract.query(api, 'getHistorics')
print("current historics: " + current_historics)
# make a prediction
current_prediction = contract.query(api, 'makePrediction')
print("current prediction: " + current_prediction)
def run(options):
entity1 = Entity()
# build the ledger API
api = LedgerApi(options['host'], options['port'])
# create wealth so that we have the funds to be able to create contracts on the network
api.sync(api.tokens.wealth(entity1, 100000))
# create the smart contract
contract = SmartContract(CONTRACT_TEXT)
# deploy the contract to the network
api.sync(api.contracts.create(entity1, contract, 2000))
api.sync(contract.action(api, 'set_block_number_state', 400, [entity1]))
assert contract.query(api, 'query_block_number_state') > 0
def prepare_contract(self):
# Setting API up
self._api = LedgerApi('127.0.0.1', 8100)
# Need funds to deploy contract
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(
self._api.contracts.create(self._entity, self._contract, 2456766))
ff = open('contract.txt', 'w')
ff.write(str(self._contract._digest) + "\n")
ff.write(str(Address(self._entity)))
ff.close()
def main(source):
# Create keypair for the contract owner
entity = Entity()
address = Address(entity)
# Setting API up
api = LedgerApi('127.0.0.1', 8100)
# Need funds to deploy contract
api.sync(api.tokens.wealth(entity, 1000000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(entity, contract, 20000))
# Printing message
print(contract.query(api, 'totalSupply'))
def __init__(self, *args, start=(30.28, 59.91), finish=(30.34, 59.97), n_points=3, charge=0.6, **kwargs):
super(ScooterAgent, self).__init__(*args, **kwargs)
self._api = LedgerApi('127.0.0.1', 8100)
self._entity = Entity()
self.speed = 0.0005
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
self._address = Address(self._entity)
with open("../02_full_contract.etch", "r") as fb:
self._source = fb.read()
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766))
with open('contract.txt','r') as ff:
self.digest = ff.readline().split('\n')[0]
self.owner = ff.readline()
self._loop = asyncio.get_event_loop()
self.provider = Entity()
self.scooter = Entity()
self.path = make_path(start, finish, n_points, 0.01)
self.charge = charge
self._contract.action(self._api, 'addProvider', 2456, [self._entity, self.provider],
Address(self.provider), self._address)
self._contract.action(self._api, 'addScooter', 2456, [self.provider], Address(self.scooter),
Address(self.provider), int(start[1]*1000), int(start[0]*1000), 100, 1, 15)
def __init__(self, *args, n_providers=3, scooter_per_provider=5, **kwargs):
super(ScooterAgent, self).__init__(*args, **kwargs)
self._api = LedgerApi('127.0.0.1', 8100)
self._entity = Entity()
self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
self._address = Address(self._entity)
with open("../02_full_contract.etch", "r") as fb:
self._source = fb.read()
# Create contract
self._contract = SmartContract(self._source)
# Deploy contract
self._api.sync(
self._api.contracts.create(self._entity, self._contract, 2456766))
self._loop = asyncio.get_event_loop()
self.providers = []
self.scooters = []
for i in range(n_providers):
self.providers.append(Entity())
scooters = [Entity() for j in range(scooter_per_provider)]
self.scooters.extend(scooters)
self._contract.action(self._api, 'addProvider', 2456766,
[self._entity, self.providers[0]],
Address(self.providers[0]), self._address)
self._contract.action(self._api, 'addScooter', 2456766,
[self.providers[0]], Address(self.scooters[0]),
Address(self.providers[0]), 22, 23, 100, 1, 15)
print(Address(self.scooters[0]))
def main(source):
# Create keypair for the contract owner
entity = Entity()
address = Address(entity)
# Setting API up
api = LedgerApi('10.168.172.59', 8000)
# Need funds to deploy contract
api.sync(api.tokens.wealth(entity, 100000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(entity, contract, 10000))
# Printing message
print(
contract.query(api,
'register',
owner='artyom',
scooter='bike1',
price='100'))
def main(source):
# Create keypair for the contract owner
entity = Entity()
address = Address(entity)
# Setting API up
api = LedgerApi('localhost', 8000)
# Need funds to deploy contract
api.sync(api.tokens.wealth(entity, 100000))
# Create contract
contract = SmartContract(source)
# Deploy contract
api.sync(api.contracts.create(entity, contract, 100000))
# Printing message
contract.action(api, 'add', 100, [entity], "first")
time.sleep(5)
print(contract.query(api, 'getSize'))
from fetchai.ledger.api import LedgerApi
from fetchai.ledger.contract import SmartContract
from fetchai.ledger.crypto import Entity, Address
import time
contract_owner = Entity.from_hex(
'c25ace8a7a485b396f30e4a0332d0d18fd2e462b3f1404f85a1b7bcac4b4b19d')
contract_owner_address = Address(
contract_owner) # atsREugsanXS828FnTvmLM9vCkBsWnDgushDH9YjEgsdBuRGv
with open("./cbns_token.etch", "r") as fb:
contract_source = fb.read()
api = LedgerApi('127.0.0.1', 8000)
api.sync(api.tokens.wealth(contract_owner, 5000000))
contract = SmartContract(contract_source)
api.sync(api.contracts.create(contract_owner, contract, 2456766))
time.sleep(10)
print('Deployed contract address:', Address(contract.digest))
print('my balance:',
contract.query(api, 'balanceOf', owner=contract_owner_address))
endfunction
@query
function balance(address: Address) : UInt64
var supply_state = State<UInt64>(address);
return supply_state.get(0u64);
endfunction
"""
# build the ledger API
api = LedgerApi(HOST, PORT)
# create wealth so that we have the funds to be able to create contracts on the network
api.sync(api.tokens.wealth(entity1, 10000))
# create the smart contract
contract = SmartContract(CONTRACT_TEXT)
# deploy the contract to the network
api.sync(api.contracts.create(entity1, contract, 2000))
@app.route('/rentStop')
def rentStop():
global address1
global address2
global api
global contract
api.sync(contract.action(api, 'transfer', 40, [entity1], address1, address2, 200))
return jsonify(True)
@app.route('/getUsers')
def getUsers():
import requests
app = Flask(__name__)
wallet_owner = Entity()
wallet_address = Address(wallet_owner)
api = LedgerApi('127.0.0.1', 8100)
contracts = {}
contract_user = Entity()
user_address = Address(contract_user)
with open(sys.argv[1], "r") as fb:
source = fb.read()
# Create contract
contract = SmartContract(source)
@app.route('/balance')
def balance():
balance = api.tokens.balance(wallet_address)
return json.dumps({"address": str(wallet_address), "balance": balance})
@app.route('/address')
def address():
return json.dumps({"address", str(wallet_address)})
@app.route('/create-tokens')
def create_tokens():