public QueryContractCreate ContractCreate(string address)
{
IMongoQueryable <CirrusContractTable> cirrusContract = mongoDb.CirrusContractTable.AsQueryable()
.Where(q => q.NewContractAddress == address);
var res = cirrusContract.ToList();
if (res.Count > 1)
{
throw new ApplicationException("This is unexpected"); // todo: remove this temporary code
}
CirrusContractTable lastEntry = mongoDb.CirrusContractTable.AsQueryable()
.OrderByDescending(b => b.BlockIndex)
.Where(q => q.ToAddress == address)
.FirstOrDefault();
return(res.Select(item => new QueryContractCreate
{
Success = item.Success,
ContractAddress = item.NewContractAddress,
ContractCodeType = item.ContractCodeType,
GasUsed = item.GasUsed,
GasPrice = item.GasPrice,
Amount = item.Amount,
ContractBalance = lastEntry?.ContractBalance ?? 0,
FromAddress = item.FromAddress,
Error = item.Error,
ContractOpcode = item.ContractOpcode,
BlockIndex = item.BlockIndex,
TransactionId = item.TransactionId
}).FirstOrDefault());
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
StandardTokenComputedTable computedTable)
{
if (contractTransaction.Logs == null || !contractTransaction.Logs.Any())
{
return; //Need to understand why this happens (example transaction id - a03a7c0122668c9c6d5a7bb47494f903a89519d8fbec2df135eb6687047c58d5)
}
string fromAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["from"];
string toAddress = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["to"];
long? amount = (long?)contractTransaction.Logs.SingleOrDefault().Log.Data["amount"];
if (fromAddress is null || toAddress is null || !amount.HasValue)
{
Console.WriteLine("");
}
var fromHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == fromAddress);
fromHolder = AddStandardTokenAccountHolder(computedTable, fromHolder, fromAddress);
fromHolder.Amount -= amount.Value;
var toHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == toAddress);
toHolder = AddStandardTokenAccountHolder(computedTable, toHolder, toAddress);
toHolder.Amount += amount.Value;
}
public StandardTokenComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
{
var logs = createContractTransaction.Logs.SingleOrDefault()?.Log;
if (logs is null)
{
throw new InvalidOperationException("Missing logs for create transaction of smart contract");
}
return(new()
{
ContractAddress = createContractTransaction.NewContractAddress,
ContractCreateTransactionId = createContractTransaction.TransactionId,
LastProcessedBlockHeight = createContractTransaction.BlockIndex,
Decimals = (logs.Data["tokenDecimals"] == null ? 0 : (long)logs.Data["tokenDecimals"]),
Name = (string)logs.Data["tokenName"],
Symbol = (string)logs.Data["tokenSymbole"],
TotalSupply = (long)logs.Data["tokenTotalSupply"],
TokenHolders = new List <StandardTokenHolder>
{
new()
{
Address = createContractTransaction.FromAddress,
Amount = (long)logs.Data["tokenTotalSupply"]
}
}
});
}
public DaoContractComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
{
return(new()
{
ContractAddress = createContractTransaction.NewContractAddress,
ContractCreateTransactionId = createContractTransaction.TransactionId,
LastProcessedBlockHeight = createContractTransaction.BlockIndex
});
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
if (!contractTransaction.Logs.Any())
{
return;
}
computedTable.MinVotingDuration = (long)contractTransaction.Logs.Single().Log.Data["minVotingDuration"];
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
object tokenId = contractTransaction.Logs.SingleOrDefault().Log.Data["tokenId"];
string id = tokenId is string?(string)tokenId : Convert.ToString(tokenId);
computedTable.Tokens.Single(_ => _.Id == id)
.IsBurned = true;
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
var log = contractTransaction.Logs.SingleOrDefault();
if (log == null)
{
return;
// throw new ArgumentException(contractTransaction.TransactionId);
}
computedTable.MaxVotingDuration = (long)log.Log.Data["maxVotingDuration"];
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
var auctionLog = contractTransaction.Logs?[0];
string tokenId = (string)auctionLog.Log.Data["tokenId"];
var token = computedTable.Tokens.Single(_ => _.Id == tokenId);
var auctionEvent = (Auction)token.SalesHistory.Last(_ => _ is Auction);
auctionEvent.HighestBid = (long)auctionLog.Log.Data["bid"];
auctionEvent.HighestBidder = (string)auctionLog.Log.Data["bidder"];
auctionEvent.HighestBidTransactionId = contractTransaction.TransactionId;
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
long amount = (long)contractTransaction.Logs[0].Log.Data["amount"];
computedTable.Deposits ??= new List <DaoContractDeposit>();
computedTable.Deposits.Add(new DaoContractDeposit
{
Amount = amount,
SenderAddress = (string)contractTransaction.Logs[0].Log.Data["sender"],
TransactionId = contractTransaction.TransactionId
});
computedTable.CurrentAmount += amount; //TODO sum the deposits subtract the proposals
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
if (contractTransaction.Logs.Length == 0)
{
//TODO need to handle this wierd issue (example transaction id - 5faa9c5347ba378ea1b4dd9e957e398867f724a6ba4951ed65cde6529dbfd6a0)
return;
}
int id = (int)(long)contractTransaction.Logs.First().Log.Data["proposalId"];
bool voteYesNo = (bool)contractTransaction.Logs.First().Log.Data["vote"];
string voterAddress = (string)contractTransaction.Logs.First().Log.Data["voter"];
var proposal = computedTable.Proposals.SingleOrDefault(_ => _.Id == id);
if (proposal is null)
{
throw new InvalidOperationException(
$"Proposal {id} not found for the vote transaction id - {contractTransaction.TransactionId}");
}
var vote = proposal.Votes.FirstOrDefault(_ => _.VoterAddress == voterAddress);
if (vote != null)
{
vote.PreviousVotes ??= new List <DaoContractVote>();
vote.PreviousVotes.Add(new DaoContractVote {
IsApproved = vote.IsApproved, VotedOnBlock = vote.VotedOnBlock
});
vote.IsApproved = voteYesNo;
vote.VotedOnBlock = contractTransaction.BlockIndex;
}
else
{
proposal.Votes.Add(new DaoContractVoteDetails
{
IsApproved = voteYesNo,
ProposalId = id,
VoterAddress = voterAddress,
VotedOnBlock = contractTransaction.BlockIndex,
});
}
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
var log = contractTransaction.Logs.First().Log.Data;
computedTable.CurrentAmount -= (long)log["amount"];
int proposalId = (int)(long)log["proposalId"];
var proposal = computedTable.Proposals[proposalId - 1];
if (proposal.Id != proposalId || proposal.Recipient != (string)log["recipent"])
{
throw new ArgumentException(nameof(proposalId));
}
proposal.WasProposalAccepted = true;
proposal.ProposalCompletedAtBlock = contractTransaction.BlockIndex;
proposal.PayoutTransactionId = contractTransaction.TransactionId;
}
public NonFungibleTokenComputedTable BuildSmartContract(CirrusContractTable createContractTransaction)
{
var logs = createContractTransaction.Logs.SingleOrDefault()?.Log;
if (logs is null)
{
throw new InvalidOperationException("Missing logs for create transaction of smart contract");
}
return(new()
{
ContractAddress = createContractTransaction.NewContractAddress,
ContractCreateTransactionId = createContractTransaction.TransactionId,
LastProcessedBlockHeight = createContractTransaction.BlockIndex,
Name = (string)logs.Data["nftName"],
Symbol = (string)logs.Data["nftSymbole"],
Owner = (string)logs.Data["nftOwner"],
OwnerOnlyMinting = (bool)logs.Data["nftOwnerOnlyMinting"],
Tokens = new List <Token>()
});
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
var log = contractTransaction.Logs.First()?.Log;
var uriLog = contractTransaction.Logs.Last()?.Log;
if (log is null || uriLog is null)
{
throw new ArgumentNullException(nameof(log));
}
object tokenId = log.Data["tokenId"];
string id = tokenId is string?(string)tokenId : Convert.ToString(tokenId);
computedTable.Tokens.Add(new Token
{
Owner = (string)log.Data["to"],
Id = id,
Uri = (string)uriLog.Data["tokenUri"]
});
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
StandardTokenComputedTable computedTable)
{
string fromAddress = (string)contractTransaction.Logs.Single().Log.Data["from"];
string toAddress = (string)contractTransaction.Logs.Single().Log.Data["to"];
long amount = (long)contractTransaction.Logs.Single().Log.Data["amount"];
var fromHolder = computedTable.TokenHolders.Single(_ => _.Address == fromAddress);
fromHolder.Amount -= amount;
var toHolder = computedTable.TokenHolders.SingleOrDefault(_ => _.Address == toAddress);
if (toHolder is null)
{
toHolder = new StandardTokenHolder {
Address = toAddress
};
computedTable.TokenHolders.Add(toHolder);
}
toHolder.Amount += amount;
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
var log = contractTransaction.Logs?.First();
if (log is null)
{
throw new ArgumentNullException(nameof(log));
}
string tokenId = (string)log.Log.Data["tokenId"];
var token = computedTable.Tokens.First(_ => _.Id == tokenId);
token.Owner = (string)log.Log.Data["to"];
token.SalesHistory.Add(new OwnershipTransfer
{
From = (string)log.Log.Data["from"],
To = (string)log.Log.Data["to"],
TransactionId = contractTransaction.TransactionId,
});
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
var logData = contractTransaction.Logs.First().Log.Data;
var proposal = new DaoContractProposal
{
Recipient = (string)logData["recipent"],
Amount = (long)logData["amount"],
Id = (int)(long)logData["proposalId"],
Description = (string)logData["description"],
ProposalStartedAtBlock = contractTransaction.BlockIndex,
Votes = new List <DaoContractVoteDetails>()
};
computedTable.Proposals ??= new List <DaoContractProposal>(proposal.Id);
if (computedTable.Proposals.Capacity < proposal.Id)
{
computedTable.Proposals.Capacity = (proposal.Id);
}
computedTable.Proposals.Insert(proposal.Id - 1, proposal);
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
StandardTokenComputedTable computedTable)
{
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
DaoContractComputedTable computedTable)
{
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
computedTable.PendingOwner = (string)contractTransaction.Logs.SingleOrDefault()?.Log.Data["PendingOwner"] ?? string.Empty;
}
public void UpdateContractFromTransactionLog(CirrusContractTable contractTransaction,
NonFungibleTokenComputedTable computedTable)
{
computedTable.Owner = (string)contractTransaction.Logs.SingleOrDefault().Log.Data["NewOwner"];
computedTable.PreviousOwners.Add((string)contractTransaction.Logs.SingleOrDefault().Log.Data["PreviousOwner"]);
}
