class CreateTCD(Resource):
path = "/dapps/<addr>/create-tcd"
@with_args(
Argument("minProviderStake", type=int, dest="min_provider_stake"),
Argument("maxProviderCount", type=int, dest="max_provider_count"),
Argument("ownerRevenuePct", type=int, dest="owner_revenue_pct"),
Argument("queryPrice", type=int, dest="query_price"),
)
def post(
self,
addr,
min_provider_stake,
max_provider_count,
owner_revenue_pct,
query_price,
):
return create_transaction(
None,
addr,
"createTCD(uint256,uint256,uint256,uint256)",
("uint256", min_provider_stake),
("uint256", max_provider_count),
("uint256", owner_revenue_pct),
("uint256", query_price),
)
class CommitVote(Resource):
path = "/voting/<addr>/<int:on_chain_id>/commitvote"
@with_poll_contract(addr="addr")
@with_args(
Argument("sender", type=address),
Argument("commitHash", type=str, dest="commit_hash"),
Argument("totalWeight", type=int, dest="total_weight"),
)
def post(
self,
addr,
sender,
commit_hash,
total_weight,
on_chain_id,
poll_contract,
):
return create_transaction(
sender,
get_voting_address(poll_contract.address),
"commitVote(address,address,uint256,bytes32,bytes32,uint256,uint256 )",
("address", sender),
("address", poll_contract.address),
("uint256", on_chain_id),
("bytes32", to_bytes(hexstr=commit_hash)),
("bytes32", b""),
("uint256", total_weight),
("uint256", 0),
)
class BuyToken(Resource):
path = "/dapps/<addr>/buy"
@with_args(
Argument("sender", type=address),
Argument("value", type=int),
Argument("priceLimit", type=int, dest="price_limit"),
)
@with_community(addr="addr")
@with_curve(addr="addr")
def post(self, sender, value, price_limit, addr, comm, curve):
# get band address first
band_contract = (
db.session.query(Contract)
.filter_by(contract_type="BAND_TOKEN")
.one_or_none()
) or abort(400)
return create_transaction_raw(
sender,
band_contract.address,
create_transfer_and_call(
sender,
curve.address,
price_limit,
"buy(address,uint256,uint256)",
("uint256", value),
),
)
class SellToken(Resource):
path = "/dapps/<addr>/sell"
@with_args(
Argument("sender", type=address),
Argument("value", type=int),
Argument("priceLimit", type=int, dest="price_limit"),
)
@with_community(addr="addr")
@with_curve(addr="addr")
def post(self, sender, value, price_limit, addr, comm, curve):
# get token address first
token_contract = comm.token_collection[0]
return create_transaction_raw(
sender,
token_contract.address,
create_transfer_and_call(
sender,
curve.address,
value,
"sell(address,uint256,uint256)",
("uint256", price_limit),
),
)
class TokenRequest(Resource):
path = "/dapps/<addr>/request"
@with_args(Argument("to", type=address), Argument("value", type=int))
@with_community(addr="addr")
def post(self, addr, comm, to, value):
token_contract = comm.token_collection[0]
curve_contract = comm.curve_collection[0]
request_tx = eth_sendTransaction(
token_contract.address,
create_transaction_data(
"transferFeeless(address,address,uint256)",
("address", "0xDaD2AD37536FB7a44D2C3DaF75E3FdaBAe3d28Be"),
("address", to),
("uint256", value),
),
)
# get band address
band_contract = (db.session.query(Contract).filter_by(
contract_type="BAND_TOKEN").one_or_none()) or abort(400)
eth_sendTransaction(
band_contract.address,
create_transfer_and_call(
"0xDaD2AD37536FB7a44D2C3DaF75E3FdaBAe3d28Be",
curve_contract.address,
int(1.5 * get_buy_price(curve_contract.address, value)),
"buy(address,uint256,uint256)",
("uint256", value),
),
)
return {"result": request_tx}
class BandScheduler(Resource):
path = "/band/scheduler"
@with_args(
Argument("to", type=address),
Argument("data", type=str),
Argument("when", type=str),
)
def post(self, to, data, when):
send_scheduler(to, data, when)
return {"status": "OK"}
class TCRClaimReward(Resource):
path = "/tcr/<addr>/claim-reward"
@with_args(
Argument("rewardOwner", type=address, dest="reward_owner"),
Argument("challengeId", type=int, dest="challenge_id"),
)
def post(self, addr, reward_owner, challenge_id):
return create_transaction(
reward_owner,
addr,
"claimReward(address,uint256)",
("address", reward_owner),
("uint256", challenge_id),
)
class TCRExit(Resource):
path = "/tcr/<addr>/exit"
@with_args(
Argument("sender", type=address),
Argument("dataHash", type=str, dest="data_hash"),
)
def post(self, addr, sender, data_hash):
return create_transaction(
sender,
addr,
"exit(address,bytes32)",
("address", sender),
("bytes32", to_bytes(hexstr=data_hash)),
)
class KickSource(Resource):
path = "/data/<addr>/kick"
@with_args(Argument("dataSource", type=address, dest="data_source"))
def post(self, data_source, addr):
return create_transaction(None, addr, "kick(address)",
("address", data_source))
class GetDataAsNumber(Resource):
path = "/data/<addr>/get-number"
@with_args(Argument("key", type=str))
def post(self, key, addr):
return create_transaction(None, addr, "getAsNumber(bytes32)",
("bytes32", to_bytes(text=key)))
class DistributeFee(Resource):
path = "/data/<addr>/distribute-fee"
@with_args(Argument("tokenAmount", type=int, dest="token_amount"))
def post(self, token_amount, addr):
return create_transaction(None, addr, "distributeFee(uint256)",
("uint256", token_amount))
class WithdrawSource(Resource):
path = "/data/<addr>/withdraw"
@with_args(
Argument("sender", type=address),
Argument("withdrawOwnership", type=int, dest="withdraw_ownership"),
Argument("dataSource", type=address, dest="data_source"),
)
def post(self, sender, withdraw_ownership, data_source, addr):
return create_transaction(
sender,
addr,
"withdraw(address,uint256,address)",
("address", sender),
("uint256", withdraw_ownership),
("address", data_source),
)
class TCRWithdraw(Resource):
path = "/tcr/<addr>/withdraw"
@with_args(
Argument("sender", type=address),
Argument("dataHash", type=str, dest="data_hash"),
Argument("amount", type=int),
)
def post(self, addr, sender, data_hash, amount):
return create_transaction(
sender,
addr,
"withdraw(address,bytes32,uint256)",
("address", sender),
("bytes32", to_bytes(hexstr=data_hash)),
("uint256", amount),
)
class CreateDapp(Resource):
path = "/band/create-dapp"
@with_args(
Argument("name", type=str),
Argument("symbol", type=str),
Argument(
"bondingCollateralEquation",
type=list,
location="json",
dest="bonding_collateral_equation",
),
Argument(
"bondingLiquiditySpread", type=int, dest="bonding_liquidity_spread"
),
Argument(
"paramsExpirationTime", type=int, dest="params_expiration_time"
),
Argument(
"paramsMinParticipationPct",
type=int,
dest="params_min_participation_pct",
),
Argument(
"paramsSupportRequiredPct",
type=int,
dest="params_support_required_pct",
),
)
def post(
self,
name,
symbol,
bonding_collateral_equation,
bonding_liquidity_spread,
params_expiration_time,
params_min_participation_pct,
params_support_required_pct,
):
return create_transaction(
None,
(
db.session.query(Contract)
.filter_by(contract_type="BAND_FACTORY")
.one_or_none()
or abort(400, message="Band factory not found")
).address,
"createCommunity(string,string,uint256[],uint256,uint256,uint256,uint256)",
("string", name),
("string", symbol),
(
"uint256[]",
[int(token, 0) for token in bonding_collateral_equation],
),
("uint256", bonding_liquidity_spread),
("uint256", params_expiration_time),
("uint256", params_min_participation_pct),
("uint256", params_support_required_pct),
)
class BandRequest(Resource):
path = "/band/request"
@with_args(Argument("to", type=address), Argument("value", type=int))
def post(self, to, value):
band_contract = (db.session.query(Contract).filter_by(
contract_type="BAND_TOKEN").one_or_none()) or abort(400)
return {
"result":
eth_sendTransaction(
band_contract.address,
create_transaction_data(
"transferFeeless(address,address,uint256)",
("address", "0xDaD2AD37536FB7a44D2C3DaF75E3FdaBAe3d28Be"),
("address", to),
("uint256", value),
),
)
}
class TokenTransfer(Resource):
path = "/dapps/<addr>/transfer"
@with_args(
Argument("sender", type=address),
Argument("to", type=address),
Argument("value", type=int),
)
@with_community(addr="addr")
def post(self, sender, to, value, addr, comm):
token_contract = comm.token_collection[0]
return create_transaction(
sender,
token_contract.address,
"transferFeeless(address,address,uint256)",
("address", sender),
("address", to),
("uint256", value),
)
class CreateTCR(Resource):
path = "/dapps/<addr>/create-tcr"
@with_args(
Argument("prefix", type=str),
Argument("decayFunction",
type=list,
location="json",
dest="decay_function"),
Argument("minDeposit", type=int, dest="min_deposit"),
Argument("applyStageLength", type=int, dest="apply_stage_length"),
Argument("dispensationPercentage",
type=int,
dest="dispensation_percentage"),
Argument("commitTime", type=int, dest="commit_time"),
Argument("revealTime", type=int, dest="reveal_time"),
Argument("minParticipationPct", type=int,
dest="min_participation_pct"),
Argument("supportRequiredPct", type=int, dest="support_required_pct"),
)
def post(
self,
addr,
prefix,
decay_function,
min_deposit,
apply_stage_length,
dispensation_percentage,
commit_time,
reveal_time,
min_participation_pct,
support_required_pct,
):
return create_transaction(
None,
addr,
"createTCR(bytes8,uint256[],uint256,uint256,uint256,uint256,uint256,uint256,uint256)",
("bytes8", bytes(prefix, "utf-8")),
("uint256[]", [int(token, 0) for token in decay_function]),
("uint256", min_deposit),
("uint256", apply_stage_length),
("uint256", dispensation_percentage),
("uint256", commit_time),
("uint256", reveal_time),
("uint256", min_participation_pct),
("uint256", support_required_pct),
)
class VoteSource(Resource):
path = "/data/<addr>/vote"
@with_args(
Argument("sender", type=address),
Argument("stake", type=int),
Argument("dataSource", type=address, dest="data_source"),
)
def post(self, sender, stake, data_source, addr):
return create_transaction_raw(
sender,
get_community_token_address(addr),
create_transfer_and_call(
sender,
addr,
stake,
"vote(address,uint256,address)",
("address", data_source),
),
)
class TCREntries(Resource):
path = "/tcr/<addr>/entries"
@with_args(
Argument("sender", type=address),
Argument("dataHash", type=str, dest="data_hash"),
Argument("deposit", type=int),
)
def post(self, addr, sender, data_hash, deposit):
return create_transaction_raw(
sender,
get_community_token_address(addr),
create_transfer_and_call(
sender,
addr,
deposit,
"applyEntry(address,uint256,bytes32)",
("bytes32", to_bytes(hexstr=data_hash)),
),
)
class CastVote(Resource):
path = "/voting/<addr>/<int:on_chain_id>/castvote"
@with_poll_contract(addr="addr")
@with_args(
Argument("sender", type=address),
Argument("yesVote", type=int, dest="yes_vote"),
Argument("noVote", type=int, dest="no_vote"),
)
def post(self, addr, sender, yes_vote, no_vote, on_chain_id,
poll_contract):
return create_transaction(
sender,
get_voting_address(poll_contract.address),
"castVote(address,address,uint256,uint256,uint256)",
("address", sender),
("address", poll_contract.address),
("uint256", on_chain_id),
("uint256", yes_vote),
("uint256", no_vote),
)
class ProposeProposal(Resource):
path = "/parameter/<addr>/propose"
@with_community(addr="addr")
@with_parameter(addr="addr")
@with_args(
Argument("sender", type=address),
Argument("reasonHash", type=str, dest="reason_hash"),
Argument("keys", type=list, location="json"),
Argument("values", type=list, location="json"),
)
def post(self, sender, reason_hash, addr, comm, param, keys, values):
return create_transaction(
sender,
param.address,
"propose(address,bytes32,bytes32[],uint256[])",
("address", sender),
("bytes32", to_bytes(hexstr=reason_hash)),
("bytes32[]", [bytes(key, "utf-8") for key in keys]),
("uint256[]", [int(value, 0) for value in values]),
)
class TCRChallenge(Resource):
path = "/tcr/<addr>/challenge"
@with_args(
Argument("sender", type=address),
Argument("entryHash", type=str, dest="entry_hash"),
Argument("amount", type=int),
Argument("reasonHash", type=str, dest="reason_hash"),
)
def post(self, addr, sender, entry_hash, amount, reason_hash):
return create_transaction_raw(
sender,
get_community_token_address(addr),
create_transfer_and_call(
sender,
addr,
amount,
"initiateChallenge(address,uint256,bytes32,bytes32)",
("bytes32", to_bytes(hexstr=entry_hash)),
("bytes32", to_bytes(hexstr=reason_hash)),
),
)
class BandTransfer(Resource):
path = "/band/transfer"
@with_args(
Argument("sender", type=address),
Argument("to", type=address),
Argument("value", type=int),
)
def post(self, sender, to, value):
band_contract = (
db.session.query(Contract)
.filter_by(contract_type="BAND_TOKEN")
.one_or_none()
) or abort(400)
return create_transaction(
sender,
band_contract.address,
"transferFeeless(address,address,uint256)",
("address", sender),
("address", to),
("uint256", value),
)
class BandFeeless(Resource):
path = "/band/feeless"
@with_args(
Argument("sender", type=address),
Argument("to", type=address),
Argument("newTimestamp", type=int, dest="new_timestamp"),
Argument("funcInterface", type=str, dest="function_interface"),
Argument("data", type=str),
Argument("senderSig", type=str, dest="sender_signature"),
)
def post(
self,
sender,
to,
function_interface,
new_timestamp,
data,
sender_signature,
):
band_factory = (
db.session.query(Contract)
.filter_by(contract_type="BAND_FACTORY")
.first()
)
return {
"result": eth_sendTransaction(
band_factory.address,
create_transaction_data(
"sendDelegatedExecution(address,address,bytes4,uint256,bytes,bytes)",
("address", sender),
("address", to),
(
"bytes4",
bytes.fromhex(remove_0x_prefix(function_interface)),
),
("uint256", new_timestamp),
("bytes", bytes.fromhex(remove_0x_prefix(data))),
(
"bytes",
bytes.fromhex(remove_0x_prefix(sender_signature)),
),
),
)
}
class BandExec(Resource):
path = "/band/exec"
@with_args(Argument("to", type=address), Argument("data", type=str))
def post(self, to, data):
return {"result": eth_sendTransaction(to, data)}
