def create_contract_v1(body: dict) -> dict:
"""Deploy a new contract on the chain
Args:
body: The parsed body, supplied by user. This is used to create a data model
Returns:
DTO of the contract at rest which is being created
"""
# Before anything else, check to see if this chain has too many contracts
if elasticsearch.get_count(folder=smart_contract_dao.FOLDER) >= MAX_CONTRACT_LIMIT:
raise exceptions.ContractLimitExceeded(MAX_CONTRACT_LIMIT)
# Create model and validate fields
_log.info(f"Creating data model for {body['txn_type']}")
contract = smart_contract_model.new_contract_from_user(body)
# Register new trasnsaction type for smart contract
_log.info("Registering new smart contract transaction type")
transaction_type_dao.register_smart_contract_transaction_type(contract)
# Start build task
try:
job_processor.begin_task(contract, task_type=smart_contract_model.ContractActions.CREATE)
except RuntimeError:
transaction_type_dao.remove_existing_transaction_type(contract.txn_type)
raise
return contract.export_as_at_rest()
def update_contract_v1(contract_id: str, update: dict) -> dict:
"""Update an existing contract on the chain
Args:
contract_id: The contract_id of the contract
update: The parsed body, supplied by user. This is used to create an update data model
Returns:
DTO of the contract at rest which has been updated
"""
# Get existing model, and check state
contract = smart_contract_dao.get_contract_by_id(contract_id)
contract_update = smart_contract_model.new_update_contract(
update, existing_contract=contract)
if smart_contract_model.ContractState.is_updatable_state(
contract.status["state"]):
raise exceptions.BadStateError(
f'State {contract.status["state"]} not valid to begin updates')
# Create and validate update model
contract_update.start_state = contract.status["state"]
# Set state to updating
contract.set_state(smart_contract_model.ContractState.UPDATING)
contract.save()
try:
job_processor.begin_task(
contract_update,
task_type=smart_contract_model.ContractActions.UPDATE)
except RuntimeError:
contract.set_state(
state=smart_contract_model.ContractState.ACTIVE,
msg="Contract update failed: could not start update.")
contract.save()
raise
return contract.export_as_at_rest()
def delete_contract_v1(contract_id: str) -> None:
"""Delete a contract
Args:
contract_id (str): The contract_id of the contract
Returns:
smart contract at rest which was deleted
"""
_log.info(f"Getting contract {contract_id} to delete")
contract = smart_contract_dao.get_contract_by_id(contract_id)
_log.info("Setting delete state..")
contract.set_state(smart_contract_model.ContractState.DELETING)
contract.save()
try:
job_processor.begin_task(contract, task_type=smart_contract_model.ContractActions.DELETE)
except RuntimeError:
_log.exception("Could not begin delete, rolling back state.")
contract.set_state(state=smart_contract_model.ContractState.ACTIVE, msg="Contract delete failed: could not start deletion")
contract.save()
raise
def create_contract_v1(body: dict) -> dict:
"""Deploy a new contract on the chain
Args:
body: The parsed body, supplied by user. This is used to create a data model
Returns:
DTO of the contract at rest which is being created
"""
# Before anything else, check to see if this chain has too many contracts
if redisearch.get_document_count(
redisearch.Indexes.smartcontract.value) >= MAX_CONTRACT_LIMIT:
raise exceptions.ContractLimitExceeded(MAX_CONTRACT_LIMIT)
# Create model and validate fields
_log.info(f"Creating data model for {body['txn_type']}")
contract = smart_contract_model.new_contract_from_user(body)
# Check that this transaction type isn't already taken
try:
transaction_type_dao.get_registered_transaction_type(contract.txn_type)
raise exceptions.TransactionTypeConflict(
f"Transaction type {contract.txn_type} already registered")
except exceptions.NotFound:
pass
# Start build task
job_processor.begin_task(
contract, task_type=smart_contract_model.ContractActions.CREATE)
try:
# Register new transaction type for smart contract
_log.info("Registering new smart contract transaction type")
smart_contract_dao.add_smart_contract_index(contract)
transaction_type_dao.register_smart_contract_transaction_type(
contract, body.get("custom_indexes"))
return contract.export_as_at_rest()
except Exception: # Try to cleanup if contract doesn't create successfully
_log.exception(
"Error creating contract index or transaction type. Reverting")
job_processor.begin_task(
contract, task_type=smart_contract_model.ContractActions.DELETE)
raise
