def create(user, bounty): uf = UserFund() uf.user = user uf.bounty = bounty uf.funding_address = asset_control.get_manager(bounty.asset).new_address() uf.save() return uf
def amount(self):
if self.imported:
from apps.asset import control
am = control.get_manager(self.asset)
return am.get_balance(self.address)
else:
return Decimal(sum(map(lambda p: p.amount, self.payments.all())))
def create(user, bounty):
uf = UserFund()
uf.user = user
uf.bounty = bounty
uf.funding_address = asset_control.get_manager(bounty.asset).new_address()
uf.save()
return uf
def amount(self):
if self.imported:
from apps.asset import control
am = control.get_manager(self.asset)
return am.get_balance(self.address)
else:
return Decimal(sum(map(lambda p: p.amount, self.payments.all())))
def display_fees(self):
if self.awarded and self.awarded.payout:
received = (self.awarded.payout.amount / self.fraction_reward)
else:
usetarget = self.state == "PENDING" and self.target_funds > self.received
received = usetarget and self.target_funds or self.received
amount = received * self.fraction_fees
return asset_control.get_manager(self.asset).quantize(amount)
def process_payouts(self):
# TODO batch payments, split payments by asset
for claim in Claim.objects.filter(successful=True, payout=None):
outputs = [
{"destination" : claim.address, "amount" : claim.bounty.reward},
]
am = asset_control.get_manager(claim.bounty.asset)
log = am.send(outputs).get(claim.address)
if log: # may not have sent if funds in wallet but not available
claim.payout = log
claim.save()
signals.payout.send(sender=self.process_payouts, claim=claim)
def clean_amount(self):
am = control.get_manager(self.asset)
amount = am.quantize(self.cleaned_data["amount"])
# check max amount
if amount > am.get_wallet_balance():
raise ValidationError(_("INSUFFICIENT_HOT_FUNDS"))
# cold storage wallet exists
coldstorages = ColdStorage.objects.filter(asset=self.asset)
coldstorages = filter(lambda cs: cs.imported == False, coldstorages)
if len(coldstorages) == 0:
raise ValidationError(_("ERROR_NO_COLD_STORAGE"))
return amount
def process_payouts(self):
# TODO batch payments, split payments by asset
for claim in Claim.objects.filter(successful=True, payout=None):
outputs = [
{
"destination": claim.address,
"amount": claim.bounty.reward
},
]
am = asset_control.get_manager(claim.bounty.asset)
log = am.send(outputs).get(claim.address)
if log: # may not have sent if funds in wallet but not available
claim.payout = log
claim.save()
signals.payout.send(sender=self.process_payouts, claim=claim)
def squash(self, asset, balances):
am = control.get_manager(asset)
squashto = self.get_squash_number(asset)
balances = sorted(balances, key=lambda b: b["amount"], reverse=True)
for balancespart in parts(balances, squashto):
if len(balancespart) < 2:
continue
# always a new address to keep user funding unambiguous
dest = am.new_address()
for balance in balancespart:
print "SQUASH: %s %s @ %s > %s" % (
balance["amount"], asset, balance["address"], dest
)
if not self.dryrun:
am.counterpartysend(balance["address"], dest, balance["amount"])
def process_refunds(self):
userfunds = UserFund.objects.all()
# exclude ongoing bounties
ongoing_states = ['PENDING', 'ACTIVE', 'MEDIATION']
ongoing_bounties = Bounty.objects.filter(state__in=ongoing_states)
userfunds = userfunds.exclude(bounty__in=ongoing_bounties)
# exclude successful bounties not yet payed
successful_claims = Claim.objects.filter(successful=True, payout=None)
successful_bounties = Bounty.objects.filter(
claims__in=successful_claims)
userfunds = userfunds.exclude(bounty__in=successful_bounties)
# exclude without funds
userfunds = filter(lambda uf: uf.has_min_refund_amount, userfunds)
# email users with refunds but no refund address
for userfund in filter(lambda uf: not bool(uf.refund_address),
userfunds):
signals.cannot_refund.send(sender=self.process_refunds,
userfund=userfund)
# refund users
for uf in filter(lambda uf: bool(uf.refund_address), userfunds):
outputs = [{
"destination": uf.refund_address,
"amount": uf.torefund
}]
am = asset_control.get_manager(uf.bounty.asset)
log = am.send(outputs).get(uf.refund_address)
if log: # may not have sent if funds in wallet but not available
uf.refund_payments.add(log)
signals.refunded.send(
sender=self.process_refunds,
userfund=uf,
payment={ # mock because counterpartyd can't get unconfirmed tx :(
"amount" : outputs[0]["amount"],
"address" : outputs[0]["destination"],
"asset" : uf.bounty.asset,
},
)
def process_refunds(self):
userfunds = UserFund.objects.all()
# exclude ongoing bounties
ongoing_states = ['PENDING', 'ACTIVE', 'MEDIATION']
ongoing_bounties = Bounty.objects.filter(state__in=ongoing_states)
userfunds = userfunds.exclude(bounty__in=ongoing_bounties)
# exclude successful bounties not yet payed
successful_claims = Claim.objects.filter(successful=True, payout=None)
successful_bounties = Bounty.objects.filter(claims__in=successful_claims)
userfunds = userfunds.exclude(bounty__in=successful_bounties)
# exclude without funds
userfunds = filter(lambda uf: uf.has_min_refund_amount, userfunds)
# email users with refunds but no refund address
for userfund in filter(lambda uf: not bool(uf.refund_address), userfunds):
signals.cannot_refund.send(sender=self.process_refunds, userfund=userfund)
# refund users
for uf in filter(lambda uf: bool(uf.refund_address), userfunds):
outputs = [{"destination" : uf.refund_address, "amount" : uf.torefund}]
am = asset_control.get_manager(uf.bounty.asset)
log = am.send(outputs).get(uf.refund_address)
if log: # may not have sent if funds in wallet but not available
uf.refund_payments.add(log)
signals.refunded.send(
sender=self.process_refunds,
userfund=uf,
payment={ # mock because counterpartyd can't get unconfirmed tx :(
"amount" : outputs[0]["amount"],
"address" : outputs[0]["destination"],
"asset" : uf.bounty.asset,
},
)
def reward(self):
if self.awarded and self.awarded.payout:
return self.awarded.payout.amount
am = asset_control.get_manager(self.asset)
return self.received - am.quantize(self.received * self.fraction_fees)
def __init__(self, *args, **kwargs):
self.asset = kwargs.pop("asset")
am = control.get_manager(self.asset)
super(ColdStorageSend, self).__init__(*args, **kwargs)
self.fields["amount"].initial = 0.0
self.fields["amount"].decimal_places = am.decimal_places
def clean_address(self):
am = control.get_manager(self.asset)
address = self.cleaned_data["address"]
if not am.validate(address):
raise ValidationError(_("ERROR_INVALID_ADDRESS"))
return address
def target_funds(self): amount = (self.target_reward / self.fraction_reward) return asset_control.get_manager(self.asset).quantize(amount)
def render_asset(amount, asset):
fs = "%0." + str(asset_control.get_manager(asset).decimal_places) + "f%s"
return fs % (amount, asset)
def render_address_link(address, asset):
am = asset_control.get_manager(asset)
return mark_safe('<a href="%(link)s" target="_blank">%(label)s</a>' % {
"link" : am.get_address_link(address),
"label" : render_address(address)
})
def transaction(self):
from apps.asset import control
am = control.get_manager(self.asset)
return am.get_receive(self.address, self.txid)
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
self.bitcoinmanager = control.get_manager("BTC")
self.dryrun = False
def gen_request_qrcode(tag_id, address, amount, asset):
am = asset_control.get_manager(asset)
return gen_qrcode(8, tag_id, am.get_qrcode_request_data(address, amount))
def render_transaction_link(txid, asset):
am = asset_control.get_manager(asset)
return mark_safe('<a href="%(link)s" target="_blank">%(label)s</a>' % {
"link": am.get_transaction_link(txid),
"label": render_transaction(txid)
})
def imported(self): from apps.asset import control am = control.get_manager(self.asset) return am.address_in_wallet(self.address)
def transaction(self): from apps.asset import control am = control.get_manager(self.asset) return am.get_receive(self.address, self.txid)
def render_transaction_link(txid, asset):
am = asset_control.get_manager(asset)
return mark_safe('<a href="%(link)s" target="_blank">%(label)s</a>' % {
"link" : am.get_transaction_link(txid),
"label" : render_transaction(txid)
})
def _am(self): from apps.asset import control as asset_control return asset_control.get_manager(self.bounty.asset)
def gen_address_qrcode(tag_id, address, asset): am = asset_control.get_manager(asset) return gen_qrcode(5, tag_id, am.get_qrcode_address_data(address))
def imported(self):
from apps.asset import control
am = control.get_manager(self.asset)
return am.address_in_wallet(self.address)
def render_asset(amount, asset): fs = "%0." + str(asset_control.get_manager(asset).decimal_places) + "f%s" return fs % (amount, asset)
def gen_address_qrcode(tag_id, address, asset):
am = asset_control.get_manager(asset)
return gen_qrcode(5, tag_id, am.get_qrcode_address_data(address))
def gen_request_qrcode(tag_id, address, amount, asset): am = asset_control.get_manager(asset) return gen_qrcode(8, tag_id, am.get_qrcode_request_data(address, amount))
def render_address_link(address, asset):
am = asset_control.get_manager(asset)
return mark_safe('<a href="%(link)s" target="_blank">%(label)s</a>' % {
"link": am.get_address_link(address),
"label": render_address(address)
})
def clean_address(self):
address = self.cleaned_data["address"]
asset = self.userfund.bounty.asset
if not asset_control.get_manager(asset).validate(address):
raise ValidationError(_("ERROR_INVALID_ADDRESS"))
return address
def _am(self):
from apps.asset import control as asset_control
return asset_control.get_manager(self.bounty.asset)
def clean_address(self):
address = self.cleaned_data["address"]
asset = self.userfund.bounty.asset
if not asset_control.get_manager(asset).validate(address):
raise ValidationError(_("ERROR_INVALID_ADDRESS"))
return address