/// <summary> /// Internal implementation of delete topic method. /// </summary> private async Task <TransactionReceipt> DeleteTopicImplementationAsync(Address topicToDelete, Signatory?signatory, Action <IContext>?configure) { topicToDelete = RequireInputParameter.AddressToDelete(topicToDelete); await using var context = CreateChildContext(configure); RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var signatories = Transactions.GatherSignatories(context, signatory); var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateTransactionBody(context, transactionId); transactionBody.ConsensusDeleteTopic = new ConsensusDeleteTopicTransactionBody { TopicID = Protobuf.ToTopicID(topicToDelete) }; var request = await Transactions.SignTransactionAsync(transactionBody, signatories); var precheck = await Transactions.ExecuteSignedRequestWithRetryAsync(context, request, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, precheck); var receipt = await GetReceiptAsync(context, transactionId); if (receipt.Status != ResponseCodeEnum.Success) { throw new TransactionException($"Unable to Delete Topic, status: {receipt.Status}", Protobuf.FromTransactionId(transactionId), (ResponseCode)receipt.Status); } var result = new TransactionReceipt(); Protobuf.FillReceiptProperties(transactionId, receipt, result); return(result);
/// <summary> /// Retreives the accounts that are proxy staking to this account. /// </summary> /// <param name="address"> /// The Hedera Network Address to retrieve the stakers of. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A dictionary mapping account addresses to the amount of stake. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// /// <remarks> /// Marked internal at this point because it is not yet implemented by the network /// </remarks> internal async Task <Dictionary <Address, long> > GetStakers(Address address, Action <IContext>?configure = null) { address = RequireInputParameter.Address(address); await using var context = CreateChildContext(configure); var query = new Query { CryptoGetProxyStakers = new CryptoGetStakersQuery { Header = Transactions.CreateAskCostHeader(), AccountID = Protobuf.ToAccountID(address) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.CryptoGetProxyStakers.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.CryptoGetProxyStakers.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(response.CryptoGetProxyStakers.Stakers.ProxyStaker.ToDictionary(ps => Protobuf.FromAccountID(ps.AccountID), ps => ps.Amount));
/// <summary> /// Retrieves the contents of a file from the network. /// </summary> /// <param name="file"> /// The address of the file contents to retrieve. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The contents of the file as a blob of bytes. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// <exception cref="ConsensusException">If the network was unable to come to consensus before the duration of the transaction expired.</exception> /// <exception cref="TransactionException">If the network rejected the create request as invalid or had missing data.</exception> public async Task <ReadOnlyMemory <byte> > GetFileContentAsync(Address file, Action <IContext>?configure = null) { file = RequireInputParameter.File(file); await using var context = CreateChildContext(configure); var query = new Query { FileGetContents = new FileGetContentsQuery { Header = Transactions.CreateAskCostHeader(), FileID = Protobuf.ToFileId(file) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.FileGetContents.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.FileGetContents.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(new ReadOnlyMemory <byte>(response.FileGetContents.FileContents.Contents.ToByteArray()));
/// <summary> /// Retrieves the bytecode for the specified contract. /// </summary> /// <param name="contract"> /// The Hedera Network Address of the Contract. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The bytecode for the specified contract instance. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// /// <remarks> /// For now this is marked internal because this method cannot be implemented /// in a safe maner that does not waste hBars. The cost of the query is variable /// and there is no public information on how to efficiently compute the cost prior /// to calling the method. So the query fee must be in excess of the actual cost. /// </remarks> internal async Task <ReadOnlyMemory <byte> > GetContractBytecodeAsync(Address contract, Action <IContext>?configure = null) { contract = RequireInputParameter.Contract(contract); await using var context = CreateChildContext(configure); var query = new Query { ContractGetBytecode = new ContractGetBytecodeQuery { Header = Transactions.CreateAskCostHeader(), ContractID = Protobuf.ToContractID(contract) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.ContractGetBytecodeResponse.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.ContractGetBytecode.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(response.ContractGetBytecodeResponse.Bytecode.ToByteArray());
/// <summary> /// Retrieves the transaction record for a given transaction ID. /// </summary> /// <param name="transaction"> /// Transaction identifier of the record /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A transaction record with the specified id, or an exception if not found. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// <exception cref="TransactionException">If the network has no record of the transaction or request has invalid or had missing data.</exception> public async Task <TransactionRecord> GetTransactionRecordAsync(TxId transaction, Action <IContext>?configure = null) { transaction = RequireInputParameter.Transaction(transaction); await using var context = CreateChildContext(configure); var transactionId = Protobuf.ToTransactionID(transaction); // For the public version of this method, we do not know // if the transaction in question has come to consensus so // we need to get the receipt first (and wait if necessary). var query = new Query { TransactionGetReceipt = new TransactionGetReceiptQuery { TransactionID = transactionId } }; await Transactions.ExecuteNetworkRequestWithRetryAsync(context, query, getServerMethod, shouldRetry); // The Receipt status returned does notmatter in this case. // We may be retrieving a failed record (the status would not equal OK). var record = await GetTransactionRecordAsync(context, transactionId); var result = new TransactionRecord(); Protobuf.FillRecordProperties(record, result); return(result);
/// <summary> /// Retrieves the records associated with an contract that are presently /// held within the network. /// </summary> /// <param name="contract"> /// The Hedera Network Contract Address to retrieve associated records. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A detailed description of the account. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <TransactionRecord[]> GetContractRecordsAsync(Address contract, Action <IContext>?configure = null) { contract = RequireInputParameter.Contract(contract); await using var context = CreateChildContext(configure); var query = new Query { ContractGetRecords = new ContractGetRecordsQuery { Header = Transactions.CreateAskCostHeader(), ContractID = Protobuf.ToContractID(contract) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.ContractGetRecordsResponse.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.ContractGetRecords.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(response.ContractGetRecordsResponse.Records.Select(record => { var result = new TransactionRecord(); Protobuf.FillRecordProperties(record, result); return result; }).ToArray());
/// <summary> /// Retrieves the network address associated with the specified smart contract id. /// </summary> /// <param name="smartContractId"> /// The smart contract ID to look up. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The network address associated with the smart contract ID. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <Address> GetAddressFromSmartContractId(string smartContractId, Action <IContext>?configure = null) { smartContractId = RequireInputParameter.SmartContractId(smartContractId); var context = CreateChildContext(configure); var gateway = RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var transfers = Transactions.CreateCryptoTransferList((payer, -context.FeeLimit), (gateway, context.FeeLimit)); var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateCryptoTransferTransactionBody(context, transfers, transactionId, "Get Contract By Solidity ID"); var query = new Query { GetBySolidityID = new GetBySolidityIDQuery { Header = Transactions.SignQueryHeader(transactionBody, payer), SolidityID = smartContractId } }; var response = await Transactions.ExecuteRequestWithRetryAsync(context, query, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, getResponseCode(response)); var data = response.GetBySolidityID; if (data.ContractID != null) { return(Protobuf.FromContractID(data.ContractID)); } if (data.AccountID != null) { return(Protobuf.FromAccountID(data.AccountID)); } if (data.FileID != null) { return(Protobuf.FromFileID(data.FileID)); } throw new TransactionException($"Address from Smart Contract ID {smartContractId} was not found.", Protobuf.FromTransactionId(transactionId), ResponseCode.Unknown);
/// <summary> /// Retrieves the account records associated with an account that are presently /// held within the network. /// </summary> /// <param name="address"> /// The Hedera Network Address to retrieve associated records. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A detailed description of the account. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <TransactionRecord[]> GetAccountRecordsAsync(Address address, Action <IContext>?configure = null) { address = RequireInputParameter.Address(address); var context = CreateChildContext(configure); var gateway = RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var transfers = Transactions.CreateCryptoTransferList((payer, -context.FeeLimit), (gateway, context.FeeLimit)); var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateCryptoTransferTransactionBody(context, transfers, transactionId, "Get Account Records"); var query = new Query { CryptoGetAccountRecords = new CryptoGetAccountRecordsQuery { Header = Transactions.SignQueryHeader(transactionBody, payer), AccountID = Protobuf.ToAccountID(address) } }; var response = await Transactions.ExecuteRequestWithRetryAsync(context, query, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, getResponseCode(response)); return(response.CryptoGetAccountRecords.Records.Select(record => { var result = new TransactionRecord(); Protobuf.FillRecordProperties(record, result); return result; }).ToArray());
/// <summary> /// Deletes a contract instance from the network returning the remaining /// crypto balance to the specified address. Must be signed /// by the admin key. /// </summary> /// <param name="contractToDelete"> /// The Contract instance that will be deleted. /// </param> /// <param name="transferToAddress"> /// The address that will receive any remaining balance from the deleted Contract. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A transaction receipt indicating a successful operation. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// <exception cref="ConsensusException">If the network was unable to come to consensus before the duration of the transaction expired.</exception> /// <exception cref="TransactionException">If the network rejected the create request as invalid or had missing data.</exception> public async Task <TransactionReceipt> DeleteContractAsync(Address contractToDelete, Address transferToAddress, Action <IContext>?configure = null) { contractToDelete = RequireInputParameter.ContractToDelete(contractToDelete); transferToAddress = RequireInputParameter.TransferToAddress(transferToAddress); var context = CreateChildContext(configure); RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateEmptyTransactionBody(context, transactionId, "Delete Contract"); transactionBody.ContractDeleteInstance = new ContractDeleteTransactionBody { ContractID = Protobuf.ToContractID(contractToDelete), TransferAccountID = Protobuf.ToAccountID(transferToAddress) }; var request = Transactions.SignTransaction(transactionBody, payer); var precheck = await Transactions.ExecuteRequestWithRetryAsync(context, request, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, precheck.NodeTransactionPrecheckCode); var receipt = await GetReceiptAsync(context, transactionId); if (receipt.Status != ResponseCodeEnum.Success) { throw new TransactionException($"Unable to delete contract, status: {receipt.Status}", Protobuf.FromTransactionId(transactionId), (ResponseCode)receipt.Status); } var result = new TransactionReceipt(); Protobuf.FillReceiptProperties(transactionId, receipt, result); return(result);
/// <summary> /// Calls a smart contract function locally on the gateway node. /// </summary> /// <remarks> /// This is performed locally on the gateway node. It cannot change the state of the contract instance /// (and so, cannot spend anything from the instance's cryptocurrency account). It will not have a /// consensus timestamp nor a record or a receipt. The response will contain the output returned /// by the function call. /// </remarks> /// <param name="queryParameters"> /// The parameters identifying the contract and function method to call. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The results from the local contract query call. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <ContractCallResult> QueryContractAsync(QueryContractParams queryParameters, Action <IContext>?configure = null) { queryParameters = RequireInputParameter.QueryParameters(queryParameters); await using var context = CreateChildContext(configure); var query = new Query { ContractCallLocal = new ContractCallLocalQuery { Header = Transactions.CreateAskCostHeader(), ContractID = Protobuf.ToContractID(queryParameters.Contract), Gas = queryParameters.Gas, FunctionParameters = Abi.EncodeFunctionWithArguments(queryParameters.FunctionName, queryParameters.FunctionArgs).ToByteString(), MaxResultSize = queryParameters.MaxAllowedReturnSize } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.ContractCallLocal.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.ContractCallLocal.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost + queryParameters.ReturnValueCharge, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(Protobuf.FromContractCallResult(response.ContractCallLocal.FunctionResult));
/// <summary> /// Internal implementation of the update Contract functionality. /// </summary> private async Task <TResult> UpdateContractImplementationAsync <TResult>(UpdateContractParams updateParameters, Action <IContext>?configure) where TResult : new() { updateParameters = RequireInputParameter.UpdateParameters(updateParameters); await using var context = CreateChildContext(configure); RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var signatory = Transactions.GatherSignatories(context, updateParameters.Signatory); var updateContractBody = new ContractUpdateTransactionBody { ContractID = Protobuf.ToContractID(updateParameters.Contract) }; if (updateParameters.Expiration.HasValue) { updateContractBody.ExpirationTime = Protobuf.ToTimestamp(updateParameters.Expiration.Value); } if (!(updateParameters.Administrator is null)) { updateContractBody.AdminKey = Protobuf.ToPublicKey(updateParameters.Administrator); } if (updateParameters.RenewPeriod.HasValue) { updateContractBody.AutoRenewPeriod = Protobuf.ToDuration(updateParameters.RenewPeriod.Value); } if (!(updateParameters.File is null)) { updateContractBody.FileID = Protobuf.ToFileId(updateParameters.File); } if (!string.IsNullOrWhiteSpace(updateParameters.Memo)) { updateContractBody.Memo = updateParameters.Memo; } var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateTransactionBody(context, transactionId); transactionBody.ContractUpdateInstance = updateContractBody; var request = await Transactions.SignTransactionAsync(transactionBody, signatory); var precheck = await Transactions.ExecuteSignedRequestWithRetryAsync(context, request, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, precheck); var receipt = await GetReceiptAsync(context, transactionId); if (receipt.Status != ResponseCodeEnum.Success) { throw new TransactionException($"Unable to update Contract, status: {receipt.Status}", Protobuf.FromTransactionId(transactionId), (ResponseCode)receipt.Status); } var result = new TResult(); if (result is TransactionRecord arec) { var record = await GetTransactionRecordAsync(context, transactionId); Protobuf.FillRecordProperties(record, arec); } else if (result is TransactionReceipt arcpt) { Protobuf.FillReceiptProperties(transactionId, receipt, arcpt); } return(result);
public void ExposesValidStartNano() { var transactionId = Generator.TransactionID(); var txId = Protobuf.FromTransactionId(transactionId); Assert.Equal(txId.ValidStartNanos, transactionId.TransactionValidStart.Nanos); }
/// <summary> /// Retrieves the account records associated with an account that are presently /// held within the network because they exceeded the receive or send threshold /// values for autogeneration of records. /// </summary> /// <param name="address"> /// The Hedera Network Address to retrieve associated records. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A detailed description of the account. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <TransactionRecord[]> GetAccountRecordsAsync(Address address, Action <IContext>?configure = null) { address = RequireInputParameter.Address(address); await using var context = CreateChildContext(configure); var query = new Query { CryptoGetAccountRecords = new CryptoGetAccountRecordsQuery { Header = Transactions.CreateAskCostHeader(), AccountID = Protobuf.ToAccountID(address) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.CryptoGetAccountRecords.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.CryptoGetAccountRecords.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); var precheckCode = getResponseHeader(response)?.NodeTransactionPrecheckCode ?? ResponseCodeEnum.Unknown; if (precheckCode != ResponseCodeEnum.Ok) { throw new TransactionException("Unable to retrieve transaction records.", Protobuf.FromTransactionId(transactionId), (ResponseCode)precheckCode); } } return(response.CryptoGetAccountRecords.Records.Select(record => { var result = new TransactionRecord(); Protobuf.FillRecordProperties(record, result); return result; }).ToArray());
/// <summary> /// Internal implementation for Multi Account Transfer Crypto. /// Returns either a receipt or record or throws an exception. /// </summary> private async Task <TResult> TransferImplementationAsync <TResult>(Dictionary <Account, long> sendAccounts, Dictionary <Address, long> receiveAddresses, Action <IContext>?configure) where TResult : new() { var transferList = RequireInputParameter.MultiTransfers(sendAccounts, receiveAddresses); var context = CreateChildContext(configure); RequireInContext.Gateway(context); var payers = sendAccounts.Keys.ToArray <ISigner>().Append(RequireInContext.Payer(context)).ToArray(); var transfers = Transactions.CreateCryptoTransferList(transferList); var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateCryptoTransferTransactionBody(context, transfers, transactionId, "Transfer Crypto"); var request = Transactions.SignTransaction(transactionBody, payers); var precheck = await Transactions.ExecuteRequestWithRetryAsync(context, request, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, precheck.NodeTransactionPrecheckCode); var receipt = await GetReceiptAsync(context, transactionId); if (receipt.Status != ResponseCodeEnum.Success) { throw new TransactionException($"Unable to execute crypto transfer, status: {receipt.Status}", Protobuf.FromTransactionId(transactionId), (ResponseCode)receipt.Status); } var result = new TResult(); if (result is TransferRecord rec) { var record = await GetTransactionRecordAsync(context, transactionId); Protobuf.FillRecordProperties(record, rec); rec.Transfers = Protobuf.FromTransferList(record.TransferList); } else if (result is TransactionReceipt rcpt) { Protobuf.FillReceiptProperties(transactionId, receipt, rcpt); } return(result);
public void ExposesAccountValue() { var transactionId = Generator.TransactionID(); var txId = Protobuf.FromTransactionId(transactionId); Assert.Equal(txId.Address, Protobuf.FromAccountID(transactionId.AccountID)); }
/// <summary> /// Retrieves detailed information regarding a Topic Instance. /// </summary> /// <param name="topic"> /// The Hedera Network Address of the Topic instance to retrieve. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A detailed description of the contract instance. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <TopicInfo> GetTopicInfoAsync(Address topic, Action <IContext>?configure = null) { topic = RequireInputParameter.Topic(topic); await using var context = CreateChildContext(configure); var query = new Query { ConsensusGetTopicInfo = new ConsensusGetTopicInfoQuery { Header = Transactions.CreateAskCostHeader(), TopicID = Protobuf.ToTopicID(topic) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); long cost = (long)response.ConsensusGetTopicInfo.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.ConsensusGetTopicInfo.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(Protobuf.FromTopicInfo(response.ConsensusGetTopicInfo.TopicInfo));
public byte[] Encode(Protobuf protobuf) { try { MemoryStream serializeStream = new MemoryStream(); ProtoSerializer.Serialize(protobuf.ProtoID, serializeStream, protobuf.Proto); // 整个数据流结构为 // 4个字节的包长度(不算在长度中), 2个字节的包长度, 2个字节的请求类型 MemoryStream sendStream = new MemoryStream(); sendStream.SetLength(serializeStream.Length + 8); sendStream.Position = 0; sendStream.Write(BitConverter.GetBytes((int)serializeStream.Length + 4), 0, 4); sendStream.Write(BitConverter.GetBytes((short)serializeStream.Length + 4), 0, 2); sendStream.Write(BitConverter.GetBytes((short)protobuf.ProtoID), 0, 2); sendStream.Write(serializeStream.GetBuffer(), 0, (int)serializeStream.Length); var res = new byte[sendStream.Length]; Array.Copy(sendStream.GetBuffer(), res, sendStream.Length); return(res); } catch (Exception ex) { UnityEngine.Debug.LogError("Encode protobuf fail!"); UnityEngine.Debug.LogException(ex); } return(null); }
/// <summary> /// Retrieves the balance in tinybars from the network for a given contract. /// </summary> /// <param name="contract"> /// The hedera network contract address to retrieve the balance of. /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The balance of the associated contract. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> public async Task <ulong> GetContractBalanceAsync(Address contract, Action <IContext>?configure = null) { contract = RequireInputParameter.Contract(contract); await using var context = CreateChildContext(configure); var query = new Query { CryptogetAccountBalance = new CryptoGetAccountBalanceQuery { Header = Transactions.CreateAskCostHeader(), ContractID = Protobuf.ToContractID(contract) } }; var response = await Transactions.ExecuteUnsignedAskRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); var cost = (long)response.CryptogetAccountBalance.Header.Cost; if (cost > 0) { var transactionId = Transactions.GetOrCreateTransactionID(context); query.CryptogetAccountBalance.Header = await Transactions.CreateAndSignQueryHeaderAsync(context, cost, transactionId); response = await Transactions.ExecuteSignedRequestWithRetryAsync(context, query, getRequestMethod, getResponseHeader); ValidateResult.ResponseHeader(transactionId, getResponseHeader(response)); } return(response.CryptogetAccountBalance.Balance);
/// <summary> /// Retrieves the current USD to hBar exchange rate information from the /// network. /// </summary> /// <remarks> /// NOTE: this method incours a charge to retrieve the file from the network. /// </remarks> /// <param name="client">Client Object</param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// An Exchange Rates object providing the current and next /// exchange rates. /// </returns> public static async Task <ExchangeRates> GetExchangeRatesAsync(this Client client, Action <IContext>?configure = null) { var file = await client.GetFileContentAsync(EXCHANGE_RATE_FILE_ADDRESS, configure); var set = Proto.ExchangeRateSet.Parser.ParseFrom(file.ToArray()); return(new ExchangeRates(Protobuf.FromExchangeRate(set.CurrentRate), Protobuf.FromExchangeRate(set.NextRate))); }
/// <summary> /// Retrieves the metrics for calculating fees from the network. /// network. /// </summary> /// <remarks> /// NOTE: this method incours a charge to retrieve the file from the network. /// </remarks> /// <param name="client">Client Object</param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// The structure representing the metrics of the Network's Fee Schedule. /// </returns> public static async Task <FeeSchedules> GetFeeScheduleAsync(this Client client, Action <IContext>?configure = null) { var file = await client.GetFileContentAsync(FEE_SCHEDULE_FILE_ADDRESS, configure); var set = Proto.CurrentAndNextFeeSchedule.Parser.ParseFrom(file.ToArray()); return(new FeeSchedules(Protobuf.FromFeeSchedule(set.CurrentFeeSchedule), Protobuf.FromFeeSchedule(set.NextFeeSchedule))); }
/// <summary> /// Retrieves the current USD to hBar exchange rate information from the /// network. /// </summary> /// <remarks> /// NOTE: this method incours a charge to retrieve the file from the network. /// </remarks> /// <param name="client">Client Object</param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// An Exchange Rates object providing the current and next /// exchange rates. /// </returns> public static async Task <NodeInfo[]> GetAddressBookAsync(this Client client, Action <IContext>?configure = null) { var file = await client.GetFileContentAsync(ADDRESS_BOOK_FILE_ADDRESS, configure); var book = Proto.NodeAddressBook.Parser.ParseFrom(file.ToArray()); return(Protobuf.FromNodeAddressBook(book)); }
/// <summary> /// Creates a new Transaction Id /// </summary> /// <param name="configure"></param> /// <returns></returns> public TxId CreateNewTxId(Action <IContext>?configure = null) { var context = CreateChildContext(configure); var result = Protobuf.FromTransactionId(Transactions.GetOrCreateTransactionID(context)); _ = context.DisposeAsync(); return(result); }
public void DisimilarTxIdesAreNotConsideredEqual() { var txId1 = Protobuf.FromTransactionId(Generator.TransactionID()); var txId2 = Protobuf.FromTransactionId(Generator.TransactionID()); Assert.NotEqual(txId1, txId2); Assert.False(txId1 == txId2); Assert.True(txId1 != txId2); Assert.NotEqual(txId1.GetHashCode(), txId2.GetHashCode()); }
private static void Main(string[] args) { //Tests.RunTest(1); //Tests.RunTest(2); //Tests.RunTest(3); //Capability.Run(); Protobuf.Run(); }
public void EquivalentTxIdAreConsideredEqual() { var transactionId = Generator.TransactionID(); var txId1 = Protobuf.FromTransactionId(transactionId); var txId2 = Protobuf.FromTransactionId(transactionId); Assert.Equal(txId1, txId2); Assert.True(txId1 == txId2); Assert.False(txId1 != txId2); Assert.Equal(txId1.GetHashCode(), txId2.GetHashCode()); }
private object ConvertObject(PropertyInfo property, ITable element) { var value = property.GetValue(element); if (value == null) { return(null); } if (property.PropertyType == typeof(DateTime)) { value = ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"); } else if (property.PropertyType == typeof(Boolean)) { value = Convert.ToByte(value); } else if (property.CustomAttributes.Count() > 0 && property.GetCustomAttribute <ProtoSerializeAttribute>() != null) { byte[] content = Protobuf.Serialize(value); return(content); } else if (CustomSerializationMethods.ContainsKey(property.PropertyType)) { value = CustomSerializationMethods[property.PropertyType].Invoke(null, new object[] { value }); } else if (value is Enum) { value = value.ToString(); } else if (property.PropertyType.IsGenericType) { List <object> results = new List <object>(); Type genericType = property.PropertyType.GetGenericTypeDefinition(); if (genericType == typeof(List <>)) { var values = (IList)value; foreach (var v in values) { results.Add(v); } return(string.Join(",", results)); } else { throw new Exception("Unhandled generic type " + property.PropertyType.Name); } } return(value); }
/// <summary> /// Retrieves the transaction record for a given transaction ID. /// </summary> /// <param name="transaction"> /// Transaction identifier of the record /// </param> /// <param name="configure"> /// Optional callback method providing an opportunity to modify /// the execution configuration for just this method call. /// It is executed prior to submitting the request to the network. /// </param> /// <returns> /// A transaction record with the specified id, or an exception if not found. /// </returns> /// <exception cref="ArgumentOutOfRangeException">If required arguments are missing.</exception> /// <exception cref="InvalidOperationException">If required context configuration is missing.</exception> /// <exception cref="PrecheckException">If the gateway node create rejected the request upon submission.</exception> /// <exception cref="TransactionException">If the network rejected the create request as invalid or had missing data.</exception> public async Task <TransactionRecord> GetTransactionRecordAsync(TxId transaction, Action <IContext>?configure = null) { transaction = RequireInputParameter.Transaction(transaction); var context = CreateChildContext(configure); var transactionId = Protobuf.ToTransactionID(transaction); var record = await GetTransactionRecordAsync(context, transactionId); var result = new TransactionRecord(); Protobuf.FillRecordProperties(record, result); return(result); }
private void OnApplicationQuit() { GpuManager.Shutdown(); if (_isGlogInitialized) { Glog.Shutdown(); } Protobuf.ResetLogHandler(); Logger.SetLogger(null); }
public void ShouldAddAllTypesToRuntimeTypeModel_WhenCreated() { var typeMembers = RuntimeTypeModel.Default.GetTypes().Cast <MetaType>() .Select(x => x.Type); Assert.DoesNotContain(typeof(AMessage), typeMembers); Assert.DoesNotContain(typeof(BMessage), typeMembers); _ = new Protobuf(new[] { typeof(AMessage), typeof(BMessage) }); typeMembers = RuntimeTypeModel.Default.GetTypes().Cast <MetaType>() .Select(x => x.Type); Assert.Contains(typeof(AMessage), typeMembers); Assert.Contains(typeof(BMessage), typeMembers); }
/// <summary> /// Internal helper method implementing the file update service. /// </summary> public async Task <TResult> UpdateFileImplementationAsync <TResult>(UpdateFileParams updateParameters, Action <IContext>?configure) where TResult : new() { updateParameters = RequireInputParameter.UpdateParameters(updateParameters); await using var context = CreateChildContext(configure); RequireInContext.Gateway(context); var payer = RequireInContext.Payer(context); var signatory = Transactions.GatherSignatories(context, updateParameters.Signatory); var updateFileBody = new FileUpdateTransactionBody { FileID = Protobuf.ToFileId(updateParameters.File) }; if (!(updateParameters.Endorsements is null)) { updateFileBody.Keys = Protobuf.ToPublicKeyList(updateParameters.Endorsements); } if (updateParameters.Contents.HasValue) { updateFileBody.Contents = ByteString.CopyFrom(updateParameters.Contents.Value.ToArray()); } var transactionId = Transactions.GetOrCreateTransactionID(context); var transactionBody = Transactions.CreateTransactionBody(context, transactionId); transactionBody.FileUpdate = updateFileBody; var request = await Transactions.SignTransactionAsync(transactionBody, signatory); var precheck = await Transactions.ExecuteSignedRequestWithRetryAsync(context, request, getRequestMethod, getResponseCode); ValidateResult.PreCheck(transactionId, precheck); var receipt = await GetReceiptAsync(context, transactionId); if (receipt.Status != ResponseCodeEnum.Success) { throw new TransactionException($"Unable to update file, status: {receipt.Status}", Protobuf.FromTransactionId(transactionId), (ResponseCode)receipt.Status); } var result = new TResult(); if (result is TransactionRecord rec) { var record = await GetTransactionRecordAsync(context, transactionId); Protobuf.FillRecordProperties(record, rec); } else if (result is TransactionReceipt rcpt) { Protobuf.FillReceiptProperties(transactionId, receipt, rcpt); } return(result);
/// <summary> /// Sends request to Clusterpoint Server. Returned CPS_Response should be casted to command-specific response class. /// </summary> /// <param name="request">Request to send.</param> /// <returns>Command-specific CPS_Response object instance.</returns> public CPS_Response sendRequest(CPS_Request request) { bool firstSend = true; string previousRenderedStorage = ""; string requestXml = ""; byte[] requestBytes = null; string rawResponse = ""; bool quit = true; if (this.p_connectionSwitcher != null) this.p_connectionSwitcher.newRequest(request); do { CPS_Exception e = null; if (this.p_connectionSwitcher != null) this.p_connectionString = this.parseConnectionString(this.p_connectionSwitcher.getConnectionString(ref this.p_storageName)); try { if (this.p_transactionId != null) request.setParam("transaction_id", this.p_transactionId); if (firstSend || previousRenderedStorage != this.p_storageName) { requestXml = this.renderRequest(request); requestBytes = Encoding.UTF8.GetBytes(requestXml); previousRenderedStorage = this.p_storageName; if (this.p_debug) { FileStream fs = new FileStream("request.xml", FileMode.Create); fs.Write(requestBytes, 0, requestBytes.Length); fs.Close(); } } firstSend = false; this.p_lastRequestSize = requestXml.Length; this.p_lastNetworkDuration = 0; Stopwatch totTimer = new Stopwatch(); Stopwatch netTimer = new Stopwatch(); totTimer.Start(); if (this.p_connectionString.Scheme.ToLower() == "http") { // TODO: implement HMAC support when server side supports it HttpWebRequest webreq = (HttpWebRequest)HttpWebRequest.Create(this.p_connectionString.OriginalString); webreq.UserAgent = this.p_applicationId; webreq.Method = "POST"; webreq.ContentType = "application/x-www-form-urlencoded"; webreq.ContentLength = requestBytes.Length; webreq.Headers["Recipient"] = this.p_storageName; webreq.Proxy = null; Stream webreq_data; try { webreq_data = webreq.GetRequestStream(); } catch (Exception) { throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING); } netTimer.Start(); webreq_data.Write(requestBytes, 0, requestBytes.Length); webreq_data.Close(); netTimer.Stop(); HttpWebResponse webrsp; try { webrsp = (HttpWebResponse)webreq.GetResponse(); } catch (Exception) { throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING); } Stream webrsp_data = webrsp.GetResponseStream(); StreamReader webrsp_reader = new StreamReader(webrsp_data); netTimer.Start(); rawResponse = webrsp_reader.ReadToEnd(); webrsp_reader.Close(); netTimer.Stop(); } if (this.p_connectionString.Scheme.ToLower() == "tcp" || this.p_connectionString.Scheme.ToLower() == "tcps") { int port = this.p_connectionString.Port; if (port <= 0) port = 5550; TcpClient tcp; try { netTimer.Start(); tcp = new TcpClient(this.p_connectionString.Host, port); netTimer.Stop(); } catch (SocketException) { netTimer.Stop(); throw new CPS_Exception("Cannot connect to specified server").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR); } catch (Exception) // all other cases { netTimer.Stop(); throw new CPS_Exception("Invalid connection string").SetCode(CPS_Exception.ERROR_CODE.INVALID_CONNECTION_STRING); } NetworkStream net = tcp.GetStream(); System.IO.Stream strm = net; if (this.p_connectionString.Scheme.ToLower() == "tcps") { System.Net.Security.SslStream ssl = new System.Net.Security.SslStream(strm, false, new System.Net.Security.RemoteCertificateValidationCallback(ConnectionServerValidationCallback), null); try { ssl.AuthenticateAsClient(this.p_connectionString.Host); } catch (Exception) { throw new CPS_Exception("Error establishing SSL connection").SetCode(CPS_Exception.ERROR_CODE.SSL_HANDSHAKE); } strm = ssl; } Protobuf pb = new Protobuf(); pb.CreateField(1, Protobuf.WireType.LengthDelimited, requestBytes); pb.CreateStringField(2, this.p_storageName); if (this.p_hmacUserKey != null && this.p_hmacSignKey != null) { string characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; char[] tokenchars = new char[16]; for (int i = 0; i < 16; i++) tokenchars[i] = characters[this.p_random.Next(characters.Length)]; string token = new string(tokenchars); System.DateTime epoch = new System.DateTime(1970, 1, 1, 0, 0, 0, 0).ToUniversalTime(); System.DateTime validity = System.DateTime.Now.ToUniversalTime(); validity.AddSeconds(10); System.TimeSpan dtdiff = validity - epoch; UInt64 unixvalidity = (UInt64)dtdiff.TotalSeconds; pb.CreateStringField(14, token); pb.CreateFixed64Field(15, unixvalidity); pb.CreateStringField(16, this.p_hmacUserKey); pb.CreateStringField(17, CPS_Hasher.SHA1(CPS_Hasher.SHA1(requestXml) + token + unixvalidity + this.p_hmacSignKey)); pb.CreateStringField(18, CPS_Hasher.SHA1_HMAC(this.p_hmacSignKey, requestXml + token + unixvalidity)); } MemoryStream ms = new MemoryStream(); Protobuf_Streamer pbs = new Protobuf_Streamer(ms); pb.WriteToStream(pbs); byte[] header = CPS_Length2Header((int)(ms.Length)); netTimer.Start(); try { strm.Write(header, 0, 8); strm.Write(ms.GetBuffer(), 0, (int)(ms.Length)); } catch (Exception) { netTimer.Stop(); throw new CPS_Exception("Error sending request").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR); } strm.Flush(); try { strm.Read(header, 0, 8); netTimer.Stop(); } catch (Exception) { netTimer.Stop(); throw new CPS_Exception("Error receiving response").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR); } int len = CPS_Header2Length(header); if (len <= 0) throw new CPS_Exception("Invalid response from server").SetCode(CPS_Exception.ERROR_CODE.INVALID_RESPONSE); byte[] recv = new byte[len]; int got = 0; netTimer.Start(); while (got < len) { int br = 0; try { br = strm.Read(recv, got, len - got); if (br == 0) { netTimer.Stop(); throw new CPS_Exception("Server unexpectedly closed connection").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR); } } catch (Exception) { netTimer.Stop(); throw new CPS_Exception("Error receiving response").SetCode(CPS_Exception.ERROR_CODE.SOCKET_ERROR); } got += br; } strm.Close(); netTimer.Stop(); ms = new MemoryStream(recv); pbs = new Protobuf_Streamer(ms); pb = new Protobuf(pbs); rawResponse = pb.GetStringField(1); } totTimer.Stop(); this.p_lastRequestDuration = totTimer.ElapsedMilliseconds; this.p_lastRequestDuration = this.p_lastRequestDuration / 1000.0; this.p_lastNetworkDuration = netTimer.ElapsedMilliseconds; this.p_lastNetworkDuration = this.p_lastNetworkDuration / 1000.0; this.p_lastResponseSize = rawResponse.Length; if (this.p_debug) { FileStream fs = new FileStream("response.xml", FileMode.Create); byte[] responseBytes = Encoding.UTF8.GetBytes(rawResponse); fs.Write(responseBytes, 0, responseBytes.Length); fs.Close(); } } catch (CPS_Exception e_) { e = e_; } if (this.p_connectionSwitcher != null) quit = !this.p_connectionSwitcher.shouldRetry(rawResponse, e); else quit = true; if (quit && e != null) throw e; } while (!quit); switch (request.getCommand()) { case "search": case "similar": return new CPS_SearchResponse(this, request, rawResponse); case "update": case "delete": case "replace": case "partial-replace": case "partial-xreplace": case "insert": case "create-alert": case "update-alerts": case "delete-alerts": return new CPS_ModifyResponse(this, request, rawResponse); case "alternatives": return new CPS_AlternativesResponse(this, request, rawResponse); case "list-words": return new CPS_ListWordsResponse(this, request, rawResponse); case "status": return new CPS_StatusResponse(this, request, rawResponse); case "retrieve": case "list-last": case "list-first": case "retrieve-last": case "retrive-first": case "lookup": case "show-history": return new CPS_LookupResponse(this, request, rawResponse); case "search-delete": return new CPS_SearchDeleteResponse(this, request, rawResponse); case "list-paths": return new CPS_ListPathsResponse(this, request, rawResponse); case "list-facets": return new CPS_ListFacetsResponse(this, request, rawResponse); case "list-alerts": return new CPS_Response(this, request, rawResponse); // TODO: change this !!! default: CPS_Response ret = new CPS_Response(this, request, rawResponse); // This is explicitly processed here, because of .NET limitations. PHP API changes this directly from CPS_Response constructor. if (request.getCommand() == "begin-transaction" || request.getCommand() == "commit-transaction" || request.getCommand() == "rollback-transaction") this.p_transactionId = ret.getTransactionId(); return ret; } }
public Task<string> TestPassClass(Protobuf.Interface.TestParam param) { var requestMessage = new RequestMessage { InvokePayload = new IPedantic_PayloadTable.TestPassClass_Invoke { param = param } }; return SendRequestAndReceive<string>(requestMessage); }
void IPedantic_NoReply.TestPassClass(Protobuf.Interface.TestParam param) { var requestMessage = new RequestMessage { InvokePayload = new IPedantic_PayloadTable.TestPassClass_Invoke { param = param } }; SendRequest(requestMessage); }