public TransactionCapsule GetTransaction(byte[] hash) { TransactionCapsule transaction = null; Key key = new Key(hash); if (this.transaction_cache.ContainsKey(key)) { transaction = this.transaction_cache[key].ToCapsule <TransactionCapsule, Protocol.Transaction>(); } else { if (this.parent != null) { transaction = this.parent.GetTransaction(hash); } else { try { transaction = this.db_manager.Transaction.Get(hash); } catch { transaction = null; } } if (transaction != null) { this.transaction_cache.Add(key, Value.Create(transaction.Data)); } } return(transaction); }
public static TransactionExtention CreateTransactionExtention(TransactionCapsule transaction) { TransactionExtention extention = new TransactionExtention(); extention.Result = new Return(); try { extention.Transaction = transaction.Instance; extention.Txid = ByteString.CopyFrom(transaction.Id.Hash); extention.Result.Result = true; extention.Result.Code = Return.Types.response_code.Success; } catch (ContractValidateException e) { extention.Result.Result = false; extention.Result.Code = Return.Types.response_code.ContractValidateError; extention.Result.Message = ByteString.CopyFromUtf8("Contract validate error " + e.Message); Logger.Debug( string.Format("ContractValidateException: {0}", e.Message)); } catch (System.Exception e) { extention.Result.Result = false; extention.Result.Code = Return.Types.response_code.ContractValidateError; extention.Result.Message = ByteString.CopyFromUtf8(e.Message); Logger.Debug("Exception caught" + e.Message); } return(extention); }
public void PushTransaction(TransactionCapsule trx) { try { Manager.Instance.DBManager.PushTransaction(trx); } catch (System.Exception e) { if (e is ContractSizeNotEqualToOneException || e is VMIllegalException) { throw new P2pException(P2pException.ErrorType.BAD_TRX, e.Message, e); } else if (e is ContractValidateException || e is ValidateSignatureException || e is ContractExeException || e is DupTransactionException || e is TaposException || e is TooBigTransactionException || e is TransactionExpirationException || e is ReceiptCheckErrorException || e is TooBigTransactionResultException || e is AccountResourceInsufficientException) { throw new P2pException(P2pException.ErrorType.TRX_EXE_FAILED, e.Message, e); } } }
public BlockMessage(byte[] raw_data) : base(raw_data) { this.type = (byte)MessageTypes.MsgType.BLOCK; this.block = new BlockCapsule(GetCodedInputStream(data)); if (Message.IsFilter) { Message.CompareBytes(data, block.Data); TransactionCapsule.ValidContractProto(new List <Protocol.Transaction>(block.Instance.Transactions)); } }
private void Precompiled() { TransactionCapsule tx = new TransactionCapsule(this.transaction); List <IActuator> actuators = ActuatorFactory.CreateActuator(tx, this.deposit.DBManager); foreach (IActuator actuator in actuators) { actuator.Validate(); actuator.Execute(this.result.TransactionResult); } }
public TransactionMessage(byte[] raw_data) : base(raw_data) { this.transaction = new TransactionCapsule(GetCodedInputStream(data)); this.type = (byte)MessageTypes.MsgType.TX; if (Message.IsFilter) { CompareBytes(data, this.transaction.Data); TransactionCapsule.ValidContractProto(this.transaction.Instance.RawData.Contract[0]); } }
public TransactionsMessage(byte[] data) : base(data) { this.type = (byte)MessageTypes.MsgType.TXS; this.transactions = Transactions.Parser.ParseFrom(data); if (IsFilter) { CompareBytes(data, this.transactions.ToByteArray()); TransactionCapsule.ValidContractProto(new List <Transaction>(this.transactions.Transactions_)); } }
public static byte[] GenerateContractAddress(Transaction tx) { CreateSmartContract contract = ContractCapsule.GetSmartContractFromTransaction(tx); byte[] owner_address = contract.OwnerAddress.ToByteArray(); TransactionCapsule transaction = new TransactionCapsule(tx); byte[] tx_hash = transaction.Id.Hash; byte[] combined = new byte[tx_hash.Length + owner_address.Length]; Array.Copy(tx_hash, 0, combined, 0, tx_hash.Length); Array.Copy(owner_address, 0, combined, tx_hash.Length, owner_address.Length); return(Hash.ToAddress(combined)); }
public Transaction GetTransactionById(SHA256Hash hash) { Transaction transaction = null; try { TransactionCapsule result = this.transaction_store.Get(hash.Hash); if (result != null) { transaction = result.Instance; } } catch { } return(transaction); }
public static TransactionCapsule CreateTransactionCapsule(IMessage message, ContractType type) { DatabaseManager db_manager = Manager.Instance.DBManager; TransactionCapsule transaction = new TransactionCapsule(message, type); if (type != ContractType.CreateSmartContract && type != ContractType.TriggerSmartContract) { List <IActuator> actuators = ActuatorFactory.CreateActuator(transaction, db_manager); foreach (IActuator actuator in actuators) { actuator.Validate(); } } if (type == ContractType.CreateSmartContract) { CreateSmartContract contract = ContractCapsule.GetSmartContractFromTransaction(transaction.Instance); long percent = contract.NewContract.ConsumeUserResourcePercent; if (percent < 0 || percent > 100) { throw new ContractValidateException("percent must be >= 0 and <= 100"); } } try { BlockId id = db_manager.HeadBlockId; if (Args.Instance.Transaction.ReferenceBlock.Equals("solid")) { id = db_manager.SolidBlockId; } transaction.SetReference(id.Num, id.Hash); transaction.Expiration = db_manager.GetHeadBlockTimestamp() + (long)Args.Instance.Transaction.ExpireTimeInMillis; transaction.Timestamp = Helper.CurrentTimeMillis(); } catch (System.Exception e) { Logger.Error("Create transaction capsule failed.", e); } return(transaction); }
public InternalTransaction(Transaction tx, InternalTransaction.TransactionType tx_type) { this.transaction = tx; TransactionCapsule transaction = new TransactionCapsule(tx); this.proto_encoded = transaction.Data; this.nonce = 0; this.deep = -1; if (tx_type == TransactionType.TX_CONTRACT_CREATION_TYPE) { CreateSmartContract contract = ContractCapsule.GetSmartContractFromTransaction(tx); if (contract == null) { throw new ContractValidateException("Invalid CreateSmartContract protocol"); } this.send_address = contract.OwnerAddress.ToByteArray(); this.receive_address = new byte[0]; this.transfer_to_address = Wallet.GenerateContractAddress(tx); this.note = "create"; this.value = contract.NewContract.CallValue; this.data = contract.NewContract.Bytecode.ToByteArray(); this.token_info.Add(contract.TokenId.ToString(), contract.CallTokenValue); } else if (tx_type == TransactionType.TX_CONTRACT_CALL_TYPE) { TriggerSmartContract contract = ContractCapsule.GetTriggerContractFromTransaction(tx); if (contract == null) { throw new ContractValidateException("Invalid TriggerSmartContract protocol"); } this.send_address = contract.OwnerAddress.ToByteArray(); this.receive_address = contract.ContractAddress.ToByteArray(); this.transfer_to_address = (byte[])this.receive_address.Clone(); this.note = "call"; this.value = contract.CallValue; this.data = contract.Data.ToByteArray(); this.token_info.Add(contract.TokenId.ToString(), contract.CallTokenValue); } this.hash = transaction.Id.Hash; }
public void Pay() { byte[] origin_account = null; byte[] caller_account = null; long percent = 0; long origin_energy_limit = 0; switch (this.transaction_type) { case TransactionType.TX_CONTRACT_CREATION_TYPE: { caller_account = TransactionCapsule.GetOwner(this.transaction.Instance.RawData.Contract[0]); origin_account = caller_account; } break; case TransactionType.TX_CONTRACT_CALL_TYPE: { TriggerSmartContract trigger_contract = ContractCapsule.GetTriggerContractFromTransaction(this.transaction.Instance); ContractCapsule contract = this.db_manager.Contract.Get(trigger_contract.ContractAddress.ToByteArray()); caller_account = trigger_contract.OwnerAddress.ToByteArray(); origin_account = contract.OriginAddress; percent = Math.Max(DefineParameter.ONE_HUNDRED - contract.GetConsumeUserResourcePercent(), 0); percent = Math.Min(percent, DefineParameter.ONE_HUNDRED); origin_energy_limit = contract.GetOriginEnergyLimit(); } break; default: return; } this.receipt.PayEnergyBill(this.db_manager, this.db_manager.Account.Get(origin_account), this.db_manager.Account.Get(caller_account), percent, origin_energy_limit, energy_processor, this.db_manager.WitnessController.GetHeadSlot()); }
public Message GetData(SHA256Hash hash, InventoryType type) { Message result = null; try { switch (type) { case InventoryType.Block: { result = new BlockMessage(Manager.Instance.DBManager.GetBlockById(hash)); } break; case InventoryType.Trx: { TransactionCapsule tx = Manager.Instance.DBManager.Transaction.Get(hash.Hash); if (tx == null) { throw new StoreException(); } result = new TransactionMessage(tx.Instance); } break; default: { throw new StoreException(); } } } catch (StoreException e) { throw new P2pException(Exception.P2pException.ErrorType.DB_ITEM_NOT_FOUND, "type: " + type + ", hash: " + hash.Hash.ToHexString(), e); } return(result); }
public BlocksMessage(byte[] data) : base(data) { this.type = (byte)MessageTypes.MsgType.BLOCKS; Items items = Items.Parser.ParseFrom(GetCodedInputStream(data)); if (items.Type == Items.Types.ItemType.Block) { blocks = new List <Protocol.Block>(items.Blocks); } if (IsFilter && blocks.IsNotNullOrEmpty()) { CompareBytes(data, items.ToByteArray()); foreach (Block block in blocks) { TransactionCapsule.ValidContractProto(new List <Protocol.Transaction>(block.Transactions)); } } }
public static List <IActuator> CreateActuator(TransactionCapsule transaction, DatabaseManager db_manager) { List <IActuator> actuators = new List <IActuator>(); if (transaction == null || transaction.Instance == null) { Logger.Info("Transaction capsule or Transaction is null"); return(actuators); } if (db_manager == null) { throw new NullReferenceException("Manager is null."); } Protocol.Transaction.Types.raw raw = transaction.Instance.RawData; foreach (Contract contract in raw.Contract) { actuators.Add(GetActuatorByContract(contract, db_manager)); } return(actuators); }
public TransactionTrace(TransactionCapsule tx, DatabaseManager db_manager) { this.transaction = tx; this.db_manager = db_manager; this.receipt = new ReceiptCapsule(SHA256Hash.ZERO_HASH); this.energy_processor = new EnergyProcessor(this.db_manager); ContractType contract_type = this.transaction.Instance.RawData.Contract[0].Type; switch (contract_type) { case ContractType.TriggerSmartContract: this.transaction_type = InternalTransaction.TransactionType.TX_CONTRACT_CALL_TYPE; break; case ContractType.CreateSmartContract: this.transaction_type = InternalTransaction.TransactionType.TX_CONTRACT_CREATION_TYPE; break; default: this.transaction_type = InternalTransaction.TransactionType.TX_PRECOMPILED_TYPE; break; } }
public abstract void Consume(TransactionCapsule tx, TransactionTrace tx_trace);
public TransactionMessage(Protocol.Transaction tx) { this.transaction = new TransactionCapsule(tx); this.type = (byte)MessageTypes.MsgType.TX; this.data = tx.ToByteArray(); }
public override void Consume(TransactionCapsule tx, TransactionTrace tx_trace) { throw new System.Exception("Not support"); }
public static TransactionExtention CreateTransactionExtention(IMessage message, ContractType type) { TransactionCapsule transaction = CreateTransactionCapsule(message, type); return(CreateTransactionExtention(transaction)); }
public void Go() { try { if (this.vm != null) { TransactionCapsule tx = new TransactionCapsule(this.transaction); if (null != this.block && this.block.IsGenerateMyself && tx.ContractResult != contractResult.Unknown && tx.ContractResult == contractResult.OutOfTime) { this.result = this.program.Result; this.program.SpendAllEnergy(); OutOfTimeException e = VMExceptions.AlreadyTimeOut(); this.runtime_error = e.Message; this.result.Exception = e; throw e; } vm.Play(program); this.result = this.program.Result; if (this.is_static_call) { long call_value = TransactionCapsule.GetCallValue(this.transaction.RawData.Contract[0]); long call_token_value = TransactionCapsule.GetCallTokenValue(this.transaction.RawData.Contract[0]); if (call_value > 0 || call_token_value > 0) { this.runtime_error = "constant cannot set call value or call token value."; this.result.RejectInternalTransaction(); } return; } if (this.transaction_type == TransactionType.TX_CONTRACT_CREATION_TYPE && !this.result.IsRevert) { byte[] code = this.program.Result.HReturn; long save_code_energy = (long)code.Length * EnergyCost.CREATE_DATA; long after_Spend = this.program.EnergyLimitLeft.ToLong() - save_code_energy; if (after_Spend < 0) { if (this.result.Exception == null) { this.result.Exception = VMExceptions.NotEnoughSpendEnergy( "save just created contract code", save_code_energy, this.program.EnergyLimitLeft.ToLong()); } } else { this.result.SpendEnergy(save_code_energy); if (VMConfig.AllowTvmConstantinople) { this.deposit.SaveCode(this.program.ContractAddress.GetNoLeadZeroesData(), code); } } } if (this.result.Exception != null || this.result.IsRevert) { this.result.DeleteAccount.Clear(); this.result.LogInfos.Clear(); this.result.ResetFutureRefund(); this.result.RejectInternalTransaction(); if (this.result.Exception != null) { if (!(this.result.Exception is TransferException)) { this.program.SpendAllEnergy(); } this.runtime_error = this.result.Exception.Message; throw this.result.Exception; } else { this.runtime_error = "REVERT opcode executed"; } } else { this.deposit.Commit(); if (this.log_info_parser != null) { List <ContractTrigger> triggers = this.log_info_parser.ParseLogInfos(this.program.Result.LogInfos, this.deposit); this.program.Result.Triggers = triggers; } } } else { this.deposit.Commit(); } } catch (VMStackOverFlowException e) { this.program.SpendAllEnergy(); this.result = this.program.Result; this.result.Exception = e; this.result.RejectInternalTransaction(); this.runtime_error = this.result.Exception.Message; Logger.Info("JVMStackOverFlowException : " + this.result.Exception.Message); } catch (OutOfTimeException e) { this.program.SpendAllEnergy(); this.result = this.program.Result; this.result.Exception = e; this.result.RejectInternalTransaction(); this.runtime_error = result.Exception.Message; Logger.Info("timeout : " + this.result.Exception.Message); } catch (System.Exception e) { if (!(e is TransferException)) { this.program.SpendAllEnergy(); } this.result = this.program.Result; this.result.RejectInternalTransaction(); if (this.result.Exception == null) { Logger.Error(e.Message); this.result.Exception = new System.Exception("Unknown exception"); } if (this.runtime_error == null || this.runtime_error.Length == 0) { this.runtime_error = this.result.Exception.Message; } Logger.Info("runtime result is : " + this.result.Exception.Message); } this.trace.SetBill(this.result.EnergyUsed); }
public static TransactionApprovedList GetTransactionApprovedList(Transaction transaction) { TransactionExtention transaction_extention = new TransactionExtention() { Transaction = transaction, Txid = ByteString.CopyFrom(SHA256Hash.ToHash(transaction.RawData.ToByteArray())), Result = new Return() { Result = true, Code = Return.Types.response_code.Success } }; TransactionApprovedList approved = new TransactionApprovedList() { Transaction = transaction_extention }; try { Contract contract = transaction.RawData.Contract[0]; byte[] owner_address = TransactionCapsule.GetOwner(contract); AccountCapsule account = Manager.Instance.DBManager.Account.Get(owner_address); if (account == null) { throw new PermissionException("Account is not exist."); } if (transaction.Signature.Count > 0) { byte[] hash = SHA256Hash.ToHash(transaction.RawData.ToByteArray()); foreach (var signature in transaction.Signature) { if (signature.Count() < 65) { throw new SignatureFormatException("Signature size is " + signature.Count()); } byte[] signature_address = ECKey.SignatureToAddress(hash, ECDSASignature.ExtractECDSASignature(signature.ToByteArray())); approved.ApprovedList.Add(ByteString.CopyFrom(signature_address)); } } approved.Result = new TransactionApprovedList.Types.Result() { Code = TransactionApprovedList.Types.Result.Types.response_code.Success }; } catch (SignatureFormatException e) { approved.Result = new TransactionApprovedList.Types.Result() { Code = TransactionApprovedList.Types.Result.Types.response_code.SignatureFormatError, Message = e.Message }; } catch (SignatureException e) { approved.Result = new TransactionApprovedList.Types.Result() { Code = TransactionApprovedList.Types.Result.Types.response_code.ComputeAddressError, Message = e.Message }; } catch (System.Exception e) { approved.Result = new TransactionApprovedList.Types.Result() { Code = TransactionApprovedList.Types.Result.Types.response_code.OtherError, Message = e.Message }; } return(approved); }
private void Call() { if (!this.deposit.DBManager.DynamicProperties.SupportVM()) { Logger.Info("vm work is off, need to be opened by the committee"); throw new ContractValidateException("VM work is off, need to be opened by the committee"); } TriggerSmartContract contract = ContractCapsule.GetTriggerContractFromTransaction(this.transaction); if (contract == null) { return; } if (contract.ContractAddress == null) { throw new ContractValidateException("Cannot get contract address from TriggerContract"); } byte[] contract_address = contract.ContractAddress.ToByteArray(); ContractCapsule deployed_contract = this.deposit.GetContract(contract_address); if (null == deployed_contract) { Logger.Info("No contract or not a smart contract"); throw new ContractValidateException("No contract or not a smart contract"); } long call_value = contract.CallValue; long token_value = 0; long token_id = 0; if (VMConfig.AllowTvmTransferTrc10) { token_value = contract.CallTokenValue; token_id = contract.TokenId; } if (VMConfig.EnergyLimitHardFork) { if (call_value < 0) { throw new ContractValidateException("callValue must >= 0"); } if (token_value < 0) { throw new ContractValidateException("tokenValue must >= 0"); } } byte[] caller_address = contract.OwnerAddress.ToByteArray(); CheckTokenValueAndId(token_value, token_id); byte[] code = this.deposit.GetCode(contract_address); if (code != null && code.Length > 0) { long fee_limit = this.transaction.RawData.FeeLimit; if (fee_limit < 0 || fee_limit > VMConfig.MAX_FEE_LIMIT) { Logger.Info(string.Format("invalid feeLimit {0}", fee_limit)); throw new ContractValidateException( "feeLimit must be >= 0 and <= " + VMConfig.MAX_FEE_LIMIT); } AccountCapsule caller = this.deposit.GetAccount(caller_address); long energy_limit = 0; if (this.is_static_call) { energy_limit = DefineParameter.ENERGY_LIMIT_IN_CONSTANT_TX; } else { AccountCapsule creator = this.deposit.GetAccount(deployed_contract.Instance.OriginAddress.ToByteArray()); energy_limit = GetTotalEnergyLimit(creator, caller, contract, fee_limit, call_value); } long max_cpu_time_tx = this.deposit.DBManager.DynamicProperties.GetMaxCpuTimeOfOneTx() * DefineParameter.ONE_THOUSAND; long tx_cpu_limit = (long)(max_cpu_time_tx * GetCpuLimitInUsRatio()); long vm_start = Helper.NanoTime() / DefineParameter.ONE_THOUSAND; long vm_should_end = vm_start + tx_cpu_limit; IProgramInvoke invoke = this.invoke_factory.CreateProgramInvoke(TransactionType.TX_CONTRACT_CALL_TYPE, this.executor_type, this.transaction, token_value, token_id, this.block.Instance, this.deposit, vm_start, vm_should_end, energy_limit); if (this.is_static_call) { invoke.IsStaticCall = true; } this.vm = new Vm(); this.root_internal_transaction = new InternalTransaction(this.transaction, this.transaction_type); this.program = new Program(code, invoke, this.root_internal_transaction, this.block); byte[] tx_id = new TransactionCapsule(this.transaction).Id.Hash; this.program.RootTransactionId = tx_id; // // TODO: EventPluginLoader is not Implementation //if (enableEventLinstener && // (EventPluginLoader.getInstance().isContractEventTriggerEnable() // || EventPluginLoader.getInstance().isContractLogTriggerEnable()) // && isCheckTransaction()) //{ // logInfoTriggerParser = new LogInfoTriggerParser(this.block.getNum(), this.block.getTimeStamp(), txId, callerAddress); //} } this.program.Result.ContractAddress = contract_address; if (call_value > 0) { MUtil.Transfer(this.deposit, caller_address, contract_address, call_value); } if (VMConfig.AllowTvmTransferTrc10) { if (token_value > 0) { MUtil.TransferToken(this.deposit, caller_address, contract_address, token_id.ToString(), token_value); } } }
private void Create() { if (!this.deposit.DBManager.DynamicProperties.SupportVM()) { throw new ContractValidateException("vm work is off, need to be opened by the committee"); } CreateSmartContract contract = ContractCapsule.GetSmartContractFromTransaction(this.transaction); if (contract == null) { throw new ContractValidateException("Cannot get CreateSmartContract from transaction"); } SmartContract new_contract = contract.NewContract; if (!contract.OwnerAddress.Equals(new_contract.OriginAddress)) { Logger.Info("OwnerAddress not equals OriginAddress"); throw new VMIllegalException("OwnerAddress is not equals OriginAddress"); } byte[] contract_name = Encoding.UTF8.GetBytes(new_contract.Name); if (contract_name.Length > VMParameter.CONTRACT_NAME_LENGTH) { throw new ContractValidateException("contractName's length cannot be greater than 32"); } long percent = contract.NewContract.ConsumeUserResourcePercent; if (percent < 0 || percent > DefineParameter.ONE_HUNDRED) { throw new ContractValidateException("percent must be >= 0 and <= 100"); } byte[] contract_address = Wallet.GenerateContractAddress(this.transaction); if (this.deposit.GetAccount(contract_address) != null) { throw new ContractValidateException( "Trying to create a contract with existing contract address: " + Wallet.AddressToBase58(contract_address)); } new_contract.ContractAddress = ByteString.CopyFrom(contract_address); long call_value = new_contract.CallValue; long token_value = 0; long token_id = 0; if (VMConfig.AllowTvmTransferTrc10) { token_value = contract.CallTokenValue; token_id = contract.TokenId; } byte[] caller_address = contract.OwnerAddress.ToByteArray(); try { long fee_limit = this.transaction.RawData.FeeLimit; if (fee_limit < 0 || fee_limit > VMConfig.MAX_FEE_LIMIT) { Logger.Info(string.Format("invalid feeLimit {0}", fee_limit)); throw new ContractValidateException( "feeLimit must be >= 0 and <= " + VMConfig.MAX_FEE_LIMIT); } AccountCapsule creator = this.deposit.GetAccount(new_contract.OriginAddress.ToByteArray()); long energy_limit = 0; if (VMConfig.EnergyLimitHardFork) { if (call_value < 0) { throw new ContractValidateException("callValue must >= 0"); } if (token_value < 0) { throw new ContractValidateException("tokenValue must >= 0"); } if (new_contract.OriginEnergyLimit <= 0) { throw new ContractValidateException("The originEnergyLimit must be > 0"); } energy_limit = GetAccountEnergyLimitWithFixRatio(creator, fee_limit, call_value); } else { energy_limit = GetAccountEnergyLimitWithFloatRatio(creator, fee_limit, call_value); } CheckTokenValueAndId(token_value, token_id); byte[] ops = new_contract.Bytecode.ToByteArray(); this.root_internal_transaction = new InternalTransaction(this.transaction, this.transaction_type); long max_cpu_time_tx = this.deposit.DBManager.DynamicProperties.GetMaxCpuTimeOfOneTx() * DefineParameter.ONE_THOUSAND; long tx_cpu_limit = (long)(max_cpu_time_tx * GetCpuLimitInUsRatio()); long vm_start = Helper.NanoTime() / DefineParameter.ONE_THOUSAND; long vm_should_end = vm_start + tx_cpu_limit; IProgramInvoke invoke = this.invoke_factory.CreateProgramInvoke(TransactionType.TX_CONTRACT_CREATION_TYPE, this.executor_type, this.transaction, token_value, token_id, this.block.Instance, this.deposit, vm_start, vm_should_end, energy_limit); this.vm = new Vm(); this.program = new Program(ops, invoke, this.root_internal_transaction, this.block); byte[] tx_id = new TransactionCapsule(this.transaction).Id.Hash; this.program.RootTransactionId = tx_id; // TODO: EventPluginLoader is not Implementation //if (this.enable_listener // && (EventPluginLoader.getInstance().isContractEventTriggerEnable() // || EventPluginLoader.getInstance().isContractLogTriggerEnable()) // && IsCheckTransaction) //{ // logInfoTriggerParser = new LogInfoTriggerParser(this.block.getNum(), this.block.getTimeStamp(), txId, callerAddress); //} } catch (Exception e) { Logger.Info(e.Message); throw new ContractValidateException(e.Message); } this.program.Result.ContractAddress = contract_address; this.deposit.CreateAccount(contract_address, new_contract.Name, AccountType.Contract); this.deposit.CreateContract(contract_address, new ContractCapsule(new_contract)); byte[] code = new_contract.Bytecode.ToByteArray(); if (!VMConfig.AllowTvmConstantinople) { deposit.SaveCode(contract_address, ProgramPrecompile.GetCode(code)); } if (call_value > 0) { MUtil.Transfer(this.deposit, caller_address, contract_address, call_value); } if (VMConfig.AllowTvmTransferTrc10) { if (token_value > 0) { MUtil.TransferToken(this.deposit, caller_address, contract_address, token_id.ToString(), token_value); } } }
public static TransactionSignWeight GetTransactionSignWeight(Transaction transaction) { TransactionSignWeight weight = new TransactionSignWeight(); TransactionExtention extention = new TransactionExtention(); weight.Result = new TransactionSignWeight.Types.Result(); extention.Result = new Return(); extention.Transaction = transaction; extention.Txid = ByteString.CopyFrom(SHA256Hash.ToHash(transaction.RawData.ToByteArray())); extention.Result.Result = true; extention.Result.Code = Return.Types.response_code.Success; weight.Transaction = extention; try { Contract contract = transaction.RawData.Contract[0]; byte[] owner = TransactionCapsule.GetOwner(contract); AccountCapsule account = Manager.Instance.DBManager.Account.Get(owner); if (account == null) { throw new PermissionException("Account is not exist!"); } int permission_id = contract.PermissionId; Permission permission = account.GetPermissionById(permission_id); if (permission == null) { throw new PermissionException("permission isn't exit"); } if (permission_id != 0) { if (permission.Type != Permission.Types.PermissionType.Active) { throw new PermissionException("Permission type is error"); } if (!CheckPermissionOprations(permission, contract)) { throw new PermissionException("Permission denied"); } } weight.Permission = permission; if (transaction.Signature.Count > 0) { List <ByteString> approves = new List <ByteString>(); weight.ApprovedList.AddRange(approves); weight.CurrentWeight = TransactionCapsule.CheckWeight(permission, new List <ByteString>(transaction.Signature), SHA256Hash.ToHash(transaction.RawData.ToByteArray()), approves); } if (weight.CurrentWeight >= permission.Threshold) { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.EnoughPermission; } else { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.NotEnoughPermission; } } catch (SignatureFormatException e) { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.SignatureFormatError; weight.Result.Message = e.Message; } catch (SignatureException e) { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.ComputeAddressError; weight.Result.Message = e.Message; } catch (PermissionException e) { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.PermissionError; weight.Result.Message = e.Message; } catch (System.Exception e) { weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.OtherError; weight.Result.Message = e.Message; } return(weight); }
public static Return BroadcastTransaction(Transaction signed_transaction) { Return ret = new Return(); TransactionCapsule transaction = new TransactionCapsule(signed_transaction); try { int min_effective_connection = (int)Args.Instance.Node.RPC.MinEffectiveConnection; Message message = (Message) new TransactionMessage(signed_transaction); if (min_effective_connection != 0) { if (Manager.Instance.NetDelegate.ActivePeers.Count == 0) { Logger.Warning( string.Format("Broadcast transaction {0} failed, no connection", transaction.Id)); ret.Result = false; ret.Code = Return.Types.response_code.NoConnection; ret.Message = ByteString.CopyFromUtf8("no connection"); return(ret); } int count = (Manager.Instance.NetDelegate.ActivePeers.Where(peer => { return(!peer.IsNeedSyncUs && !peer.IsNeedSyncFromPeer); })).Count(); if (count < min_effective_connection) { string info = "effective connection:" + count + " lt min_effective_connection:" + min_effective_connection; Logger.Warning( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, info)); ret.Result = false; ret.Code = Return.Types.response_code.NotEnoughEffectiveConnection; ret.Message = ByteString.CopyFromUtf8(info); return(ret); } } if (Manager.Instance.DBManager.IsTooManyPending) { ret.Result = false; ret.Code = Return.Types.response_code.ServerBusy; return(ret); } if (Manager.Instance.DBManager.IsGeneratingBlock) { Logger.Warning( string.Format("Broadcast transaction {0} failed, is generating block.", transaction.Id)); ret.Result = false; ret.Code = Return.Types.response_code.ServerBusy; return(ret); } if (Manager.Instance.DBManager.TransactionIdCache.Get(transaction.Id.ToString()) != null) { Logger.Warning( string.Format("Broadcast transaction {0} failed, is already exist.", transaction.Id)); ret.Result = false; ret.Code = Return.Types.response_code.DupTransactionError; return(ret); } else { Manager.Instance.DBManager.TransactionIdCache.Add(transaction.Id.ToString(), true); } if (Manager.Instance.DBManager.DynamicProperties.SupportVM()) { transaction.ClearTransactionResult(); } if (!Manager.Instance.DBManager.PushTransaction(transaction)) { ret.Result = false; ret.Code = Return.Types.response_code.ContractValidateError; ret.Message = ByteString.CopyFromUtf8("Push transaction error"); return(ret); } Manager.Instance.NetService.Broadcast(message); Logger.Info( string.Format("Broadcast transaction {0} successfully.", transaction.Id)); ret.Result = true; ret.Code = Return.Types.response_code.Success; } catch (ValidateSignatureException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.Sigerror; ret.Message = ByteString.CopyFromUtf8("validate signature error : " + e.Message); } catch (ContractValidateException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.ContractValidateError; ret.Message = ByteString.CopyFromUtf8("contract validate error : " + e.Message); } catch (ContractExeException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.ContractExeError; ret.Message = ByteString.CopyFromUtf8("contract execute error : " + e.Message); } catch (AccountResourceInsufficientException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.BandwithError; ret.Message = ByteString.CopyFromUtf8("AccountResourceInsufficient error"); } catch (DupTransactionException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.DupTransactionError; ret.Message = ByteString.CopyFromUtf8("dup transaction"); } catch (TaposException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.TaposError; ret.Message = ByteString.CopyFromUtf8("Tapos check error"); } catch (TooBigTransactionException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.TooBigTransactionError; ret.Message = ByteString.CopyFromUtf8("Transaction size is too big"); } catch (TransactionExpirationException e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.TransactionExpirationError; ret.Message = ByteString.CopyFromUtf8("Transaction expired"); } catch (System.Exception e) { Logger.Error( string.Format("Broadcast transaction {0} failed, {1}.", transaction.Id, e.Message)); ret.Result = false; ret.Code = Return.Types.response_code.OtherError; ret.Message = ByteString.CopyFromUtf8("Other error : " + e.Message); } return(ret); }
public override void Consume(TransactionCapsule tx, TransactionTrace tx_trace) { List <Contract> contracts = new List <Contract>(tx.Instance.RawData.Contract); if (tx.ResultSize > DefineParameter.MAX_RESULT_SIZE_IN_TX * contracts.Count) { throw new TooBigTransactionResultException(); } long size = 0; if (this.db_manager.DynamicProperties.SupportVM()) { tx.Instance.Ret.Clear(); size += tx.Instance.CalculateSize(); } else { size += tx.Size; } foreach (Contract contract in contracts) { if (this.db_manager.DynamicProperties.SupportVM()) { size += DefineParameter.MAX_RESULT_SIZE_IN_TX; } Logger.Debug(string.Format("tx id {0}, bandwidth cost {1}", tx.Id, size)); tx_trace.SetNetBill(size, 0); byte[] address = TransactionCapsule.GetOwner(contract); AccountCapsule account = this.db_manager.Account.Get(address); if (account == null) { throw new ContractValidateException("account not exists"); } long now = this.db_manager.WitnessController.GetHeadSlot(); if (ContractCreateNewAccount(contract)) { ConsumeForCreateNewAccount(account, size, now, tx_trace); continue; } if (contract.Type == ContractType.TransferAssetContract && UseAssetAccountNet(contract, account, now, size)) { continue; } if (UseAccountNet(account, size, now)) { continue; } if (UseFreeNet(account, size, now)) { continue; } if (UseTransactionFee(account, size, tx_trace)) { continue; } long fee = this.db_manager.DynamicProperties.GetTransactionFee() * size; throw new AccountResourceInsufficientException( "Account Insufficient bandwidth[" + size + "] and balance[" + fee + "] to create new account"); } }