public TransactionAtom(TronAddress @from, TronAddress to, long amount, byte[] hashTransaction)
{
From = @from;
To = to;
Amount = amount;
HashTransaction = hashTransaction;
}
public void AddressToBytesToAddressTest(string addressHex)
{
TronAddress tronAddress = TronAddress.CreateTronAddress(addressHex);
string tronAddressAddressBase58 = tronAddress.AddressBase58;
Assert.AreEqual(addressHex, tronAddressAddressBase58);
}
public bool validateTransactionOptions(ITransactionOptions options)
{
IOutputAgent optionsAgent = options.agent;
if (options.value < 0)
{
return(false);
}
bool isValidTronAddress = TronAddress.ValidateAddress(optionsAgent.address);
if (!isValidTronAddress)
{
return(false);
}
byte[] primaryKeyBytes = StringHelper.GetBytesAdressFromString(optionsAgent.privateKey);
try
{
KeyTriple keyTriple = new KeyTriple(primaryKeyBytes.ToHexString2());
}
catch (FormatException)
{
return(false);
}
bool isBelongsPublicKeyToPrivateKey =
TronAddress.isBelongsPublicKeyToPrivateKey(optionsAgent.privateKey, optionsAgent.address);
if (!isBelongsPublicKeyToPrivateKey)
{
return(false);
}
ITransactionCredentials credentials = options.credentials;
bool isValidTronCredentialsAddress = TronAddress.ValidateAddress(credentials.address);
if (!isValidTronCredentialsAddress)
{
return(false);
}
if (!isValidateAmountInSatoshiByMax(options.value))
{
return(false);
}
long balanceAgent = balanceByAddress(optionsAgent.address);
if (balanceAgent < options.value)
{
return(false);
}
return(true);
}
private List <TransactionAtom> GetTransactionByRangeBlocks(long startBlockId, long endBlockId)
{
List <TransactionAtom> transferContractList = new List <TransactionAtom>();
long startPosition = 1;
long endPosition = 1600000;
long step = 100;
long currentPosition = startBlockId;
while (currentPosition <= endBlockId)
{
long currentStartPosition = currentPosition;
long currentEndPosition = currentStartPosition + step;
var blocklimit = new BlockLimit
{
StartNum = currentStartPosition,
EndNum = currentEndPosition
};
BlockList qqqq = _walletClient.GetBlockByLimitNext(blocklimit);
foreach (Block block1 in qqqq.Block)
{
foreach (Transaction transaction in block1.Transactions)
{
foreach (Transaction.Types.Contract contract1 in transaction.RawData.Contract)
{
if (contract1.Type == Transaction.Types.Contract.Types.ContractType.TransferContract)
{
ByteString parameterValue = contract1.Parameter.Value;
TransferContract transferContract =
TransferContract.Parser.ParseFrom(parameterValue.ToByteArray());
TronAddress fromAccount = new TronAddress(transferContract.OwnerAddress.ToByteArray());
TronAddress toAccount = new TronAddress(transferContract.ToAddress.ToByteArray());
TransactionAtom ta = new TransactionAtom(transferContract.OwnerAddress.ToByteArray(), transferContract.ToAddress.ToByteArray(),
transferContract.Amount,
transaction.RawData);
transferContractList.Add(ta);
}
}
}
}
currentPosition = currentEndPosition;
}
return(transferContractList);
}
public void HexAddressTest(string addressHex, bool isValid, object exceptionCode)
{
try
{
TronAddress tronAddress = TronAddress.CreateTronAddress(addressHex);
Assert.IsTrue(tronAddress != null);
}
catch (ParseAddressException parseAddressException)
{
if (exceptionCode != null)
{
Assert.AreEqual((ParseAddressException.CodeEnum)exceptionCode, parseAddressException.Code);
}
}
}
public List <TransactionAtom> txListTransactionModelByAddress(string address)
{
TronAddress tronAddress = TronAddress.CreateTronAddress(address);
List <TransactionAtom> result = new List <TransactionAtom>();
foreach (TransactionAtom transactionByRangeBlock in GetTransactionAtomsFromCache())
{
if (transactionByRangeBlock.From.Equals(tronAddress) || transactionByRangeBlock.To.Equals(tronAddress))
{
result.Add(transactionByRangeBlock);
}
}
return(result);
}
public void Base64AddressTest(string addressBase64, bool isValid, object exceptionCode)
{
byte[] bytesAdressFromString = StringHelper.GetBytesAdressFromString("TPwJS5eC5BPGyMGtYTHNhPTB89sUWjDSSu");
var decode = bytesAdressFromString.ToHexString2();
try
{
TronAddress tronAddress = TronAddress.CreateTronAddress(addressBase64);
Assert.IsTrue(tronAddress != null);
}
catch (ParseAddressException parseAddressException)
{
if (exceptionCode != null)
{
Assert.AreEqual((ParseAddressException.CodeEnum)exceptionCode, parseAddressException.Code);
}
}
}
// [DataRow("TMy3cNNSZHY5d6F39BUbwUExJR93QDpGeh", StringType.Base58, TypeNet.Main)]
public void DockerConnectTest(string addressBase58, StringType stringType, TypeNet typeNet)
{
// ProtocolConfiguration protocolConfiguration = new ProtocolConfiguration(typeNet, "172.17.0.2", 50051);
// ProtocolConfiguration protocolConfiguration = new ProtocolConfiguration(typeNet);
// ProtocolConfiguration protocolConfiguration = new ProtocolConfiguration(typeNet, "10.0.75.1", 50041);
ProtocolConfiguration protocolConfiguration = new ProtocolConfiguration(typeNet, "10.0.75.1", 50051);
// ProtocolConfiguration protocolConfiguration = new ProtocolConfiguration(typeNet, "18.184.238.21", 50051);
Wallet.WalletClient walletClient = new Latoken.CurrencyProvider.Protocol.Tron.Grpc.Api.Wallet.WalletClient(protocolConfiguration.Channel);
NodeList listNodes = walletClient.ListNodes(new EmptyMessage());
CurrencyProvider.Protocol.Tron.CurrencyProvider currencyProvider = new CurrencyProvider.Protocol.Tron.CurrencyProvider(protocolConfiguration);
var rr = BitConverter.GetBytes(152948);
var ddd = rr.ToHexString2();
BytesMessage numberMessa = new BytesMessage();
numberMessa.Value = Google.Protobuf.ByteString.CopyFrom(ddd.FromHexToByteArray2());
var dd = walletClient.GetBlockById(numberMessa);
var block = walletClient.GetNowBlock(new EmptyMessage());
// long balance = currencyProvider.balanceByAddress(addressBase58);
// Console.WriteLine($"{addressBase58}:{balance}");
// Assert.IsTrue(balance > 0);
List <TransactionAtom> transferContractList = new List <TransactionAtom>();
int startPosition = 1;
int endPosition = 1600000;
int step = 100;
int currentPosition = startPosition;
while (currentPosition <= endPosition)
{
int currentStartPosition = currentPosition;
int currentEndPosition = currentStartPosition + step;
var blocklimit = new BlockLimit();
blocklimit.StartNum = currentStartPosition;
blocklimit.EndNum = currentEndPosition;
BlockList qqqq = walletClient.GetBlockByLimitNext(blocklimit);
foreach (Block block1 in qqqq.Block)
{
foreach (Transaction transaction in block1.Transactions)
{
foreach (Transaction.Types.Contract contract1 in transaction.RawData.Contract)
{
if (contract1.Type == Transaction.Types.Contract.Types.ContractType.TransferContract)
{
ByteString parameterValue = contract1.Parameter.Value;
TransferContract transferContract = TransferContract.Parser.ParseFrom(parameterValue.ToByteArray());
TronAddress fromAccount = new TronAddress(transferContract.OwnerAddress.ToByteArray());
TronAddress toAccount = new TronAddress(transferContract.ToAddress.ToByteArray());
TransactionAtom ta = new TransactionAtom(fromAccount, toAccount, transferContract.Amount, new TransactionHelper().GetTransactionHash(transaction));
transferContractList.Add(ta);
}
}
}
}
currentPosition = currentEndPosition;
}
// var eeede = qqqq.Block[0].Transactions[0];
// var contract = eeede.RawData.Contract[0].Parameter;
}
public bool validateAddress(string address)
{
return(TronAddress.ValidateAddress(address));
}
