private void DelegateResource(byte[] owner_address, byte[] receiver_address, bool is_bandwidth, long balance, long expire_time)
{
byte[] key = DelegatedResourceCapsule.CreateDatabaseKey(owner_address, receiver_address);
DelegatedResourceCapsule delegated_resource = this.db_manager.DelegatedResource.Get(key);
if (delegated_resource != null)
{
if (is_bandwidth)
{
delegated_resource.AddFrozenBalanceForBandwidth(balance, expire_time);
}
else
{
delegated_resource.AddFrozenBalanceForEnergy(balance, expire_time);
}
}
else
{
delegated_resource = new DelegatedResourceCapsule(
ByteString.CopyFrom(owner_address),
ByteString.CopyFrom(receiver_address));
if (is_bandwidth)
{
delegated_resource.SetFrozenBalanceForBandwidth(balance, expire_time);
}
else
{
delegated_resource.SetFrozenBalanceForEnergy(balance, expire_time);
}
}
this.db_manager.DelegatedResource.Put(key, delegated_resource);
DelegatedResourceAccountIndexCapsule delegate_account_index = this.db_manager.DelegateResourceAccountIndex.Get(owner_address);
if (delegate_account_index == null)
{
delegate_account_index = new DelegatedResourceAccountIndexCapsule(
ByteString.CopyFrom(owner_address));
}
List <ByteString> to_accounts = new List <ByteString>(delegate_account_index.ToAccounts);
if (!to_accounts.Contains(ByteString.CopyFrom(receiver_address)))
{
delegate_account_index.AddToAccount(ByteString.CopyFrom(receiver_address));
}
this.db_manager.DelegateResourceAccountIndex.Put(owner_address, delegate_account_index);
delegate_account_index = this.db_manager.DelegateResourceAccountIndex.Get(receiver_address);
if (delegate_account_index == null)
{
delegate_account_index = new DelegatedResourceAccountIndexCapsule(
ByteString.CopyFrom(receiver_address));
}
List <ByteString> fromAccountsList = delegate_account_index.FromAccounts;
if (!fromAccountsList.Contains(ByteString.CopyFrom(owner_address)))
{
delegate_account_index.AddFromAccount(ByteString.CopyFrom(owner_address));
}
this.db_manager.DelegateResourceAccountIndex.Put(receiver_address, delegate_account_index);
AccountCapsule receiver = this.db_manager.Account.Get(receiver_address);
if (is_bandwidth)
{
receiver.AddAcquiredDelegatedFrozenBalanceForBandwidth(balance);
}
else
{
receiver.AddAcquiredDelegatedFrozenBalanceForEnergy(balance);
}
this.db_manager.Account.Put(receiver.CreateDatabaseKey(), receiver);
}
public override bool Execute(TransactionResultCapsule result)
{
long fee = CalcFee();
UnfreezeBalanceContract unfreeze_balance_contract;
try
{
unfreeze_balance_contract = contract.Unpack <UnfreezeBalanceContract>();
}
catch (InvalidProtocolBufferException e)
{
Logger.Debug(e.Message);
result.SetStatus(fee, code.Failed);
throw new ContractExeException(e.Message);
}
byte[] owner_address = unfreeze_balance_contract.OwnerAddress.ToByteArray();
AccountCapsule account = this.db_manager.Account.Get(owner_address);
long old_balance = account.Balance;
long unfreeze_balance = 0L;
byte[] receiver_address = unfreeze_balance_contract.ReceiverAddress.ToByteArray();
if (receiver_address != null && receiver_address.Length > 0 && this.db_manager.DynamicProperties.SupportDR())
{
byte[] key = DelegatedResourceCapsule.CreateDatabaseKey(unfreeze_balance_contract.OwnerAddress.ToByteArray(),
unfreeze_balance_contract.ReceiverAddress.ToByteArray());
DelegatedResourceCapsule delegated_resource = this.db_manager.DelegatedResource.Get(key);
AccountCapsule receiver = this.db_manager.Account.Get(receiver_address);
switch (unfreeze_balance_contract.Resource)
{
case ResourceCode.Bandwidth:
{
unfreeze_balance = delegated_resource.FrozenBalanceForBandwidth;
delegated_resource.SetFrozenBalanceForBandwidth(0, 0);
receiver.AddAcquiredDelegatedFrozenBalanceForBandwidth(-unfreeze_balance);
account.AddDelegatedFrozenBalanceForBandwidth(-unfreeze_balance);
}
break;
case ResourceCode.Energy:
{
unfreeze_balance = delegated_resource.FrozenBalanceForEnergy;
delegated_resource.SetFrozenBalanceForEnergy(0, 0);
receiver.AddAcquiredDelegatedFrozenBalanceForEnergy(-unfreeze_balance);
account.AddDelegatedFrozenBalanceForEnergy(-unfreeze_balance);
}
break;
default:
break;
}
account.Balance = old_balance + unfreeze_balance;
this.db_manager.Account.Put(receiver.CreateDatabaseKey(), receiver);
if (delegated_resource.FrozenBalanceForBandwidth == 0 && delegated_resource.FrozenBalanceForEnergy == 0)
{
this.db_manager.DelegatedResource.Delete(key);
DelegatedResourceAccountIndexCapsule delegate_account_index =
this.db_manager.DelegateResourceAccountIndex.Get(owner_address);
if (delegate_account_index != null)
{
List <ByteString> to_accounts = new List <ByteString>(delegate_account_index.ToAccounts);
to_accounts.Remove(ByteString.CopyFrom(receiver_address));
delegate_account_index.ToAccounts = to_accounts;
this.db_manager.DelegateResourceAccountIndex.Put(owner_address, delegate_account_index);
}
delegate_account_index = this.db_manager.DelegateResourceAccountIndex.Get(receiver_address);
if (delegate_account_index != null)
{
List <ByteString> from_accounts = new List <ByteString>(delegate_account_index.FromAccounts);
from_accounts.Remove(ByteString.CopyFrom(owner_address));
delegate_account_index.FromAccounts = from_accounts;
this.db_manager.DelegateResourceAccountIndex.Put(receiver_address, delegate_account_index);
}
}
else
{
this.db_manager.DelegatedResource.Put(key, delegated_resource);
}
}
else
{
switch (unfreeze_balance_contract.Resource)
{
case ResourceCode.Bandwidth:
{
List <Frozen> frozens = new List <Frozen>();
frozens.AddRange(account.FrozenList);
long now = this.db_manager.GetHeadBlockTimestamp();
foreach (Frozen frozen in frozens)
{
if (frozen.ExpireTime <= now)
{
unfreeze_balance += frozen.FrozenBalance;
frozens.Remove(frozen);
}
}
account.Balance = old_balance + unfreeze_balance;
account.FrozenList.Clear();
account.FrozenList.AddRange(frozens);
}
break;
case ResourceCode.Energy:
{
unfreeze_balance = account.AccountResource.FrozenBalanceForEnergy.FrozenBalance;
account.AccountResource.FrozenBalanceForEnergy = new Frozen();
account.Balance = old_balance + unfreeze_balance;
}
break;
default:
break;
}
}
switch (unfreeze_balance_contract.Resource)
{
case ResourceCode.Bandwidth:
{
this.db_manager.DynamicProperties.AddTotalNetWeight(-unfreeze_balance / 1000_000L);
}
break;
case ResourceCode.Energy:
{
this.db_manager.DynamicProperties.AddTotalEnergyWeight(-unfreeze_balance / 1000_000L);
}
break;
default:
break;
}
VotesCapsule votes = null;
if (!this.db_manager.Votes.Contains(owner_address))
{
votes = new VotesCapsule(unfreeze_balance_contract.OwnerAddress, account.GetVotesList());
}
else
{
votes = this.db_manager.Votes.Get(owner_address);
}
account.ClearVotes();
votes.ClearNewVotes();
this.db_manager.Account.Put(owner_address, account);
this.db_manager.Votes.Put(owner_address, votes);
result.UnfreezeAmount = unfreeze_balance;
result.SetStatus(fee, code.Sucess);
return(true);
}
