"Die Transaktionsausführung wird wahrscheinlich fehlschlagen. Möchten Sie das Senden erzwingen? VM-Ausnahme während der Verarbeitung der Transaktion: kein Gas mehr"
Fragesteller
testRPCWenn ich einen Vertrag mit und bereitstellen möchte remix, erhalte ich die folgende Fehlermeldung:
Fehlerhafte Gasschätzung mit folgender Meldung (siehe unten). Die Ausführung der Transaktion wird wahrscheinlich fehlschlagen. Möchten Sie das Senden erzwingen? VM-Ausnahme während der Verarbeitung der Transaktion: kein Benzin mehr
Und es wird nicht durch Erhöhen von behoben gas limit.
Wie kann ich dieses Problem lösen?
Hier ist der Solidity-Code:
pragma solidity 0.4.24;
contract AM {
using SafeMath for uint256;
struct StateStruct {
mapping(bytes32 => bytes32) subSt;
}
struct AStruct {
StateStruct st;
address owner;
bool isAs;
bytes32 rev;
bytes32 act;
bytes32 pl;
bytes32 actSt;
bytes32 asSte;
bool isOw;
}
mapping(uint256 => AStruct) asStr;
uint256[] public aList;
uint256 public _public_id = 0;
mapping(address => uint) public balance;
mapping(uint256 => mapping (address => mapping(address => bool))) public isPDM;
mapping(uint256 => mapping (address => bool)) public isPDU;
event LNAF(address sender, uint256 indexed _id, bytes32 subStsTypes, bytes32 subSatesValues, address owner, bytes32 _asSte);
event LNAFPay(address sender, uint256 indexed _id, bytes32 subStsTypes, bytes32 subSatesValues, address owner, bytes32 _asSte, uint256 _token);
event LCASF(address sender, uint256 indexed _id, bytes32 subStsTypes, bytes32 subSatesValues, bytes32 _asSte);
event LNANF(address sender, uint256 indexed _id, bytes32 _rev, address _owner);
event LNANFPay(address sender, uint256 indexed _id, bytes32 _rev, address _owner, uint256 _token);
event LCASNF(address sender, uint256 indexed _id, bytes32 _rev);
event LNAOA(uint256 indexed _id, bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner);
event LNAOAPay(uint256 indexed _id, bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner, uint256 _token);
event LCASOA(address sender, uint256 indexed _public_id, bytes32 _act, bytes32 _pl, bytes32 _actSt);
event LCAO(address sender, uint256 indexed _id, address newOwner);
event LCASFPay(address sender, uint256 indexed _id, bytes32 subStsTypes, bytes32 subSatesValues, bytes32 _asSte, uint256 _token);
event LCASNFPay(address sender, uint256 indexed _id, bytes32 _rev, uint256 _token);
function isAs(uint256 _id) public view returns(bool isIndeed) {
return asStr[_id].isAs;
}
function isOw(uint256 _id, address _pl) public view returns(bool isIndeed) {
if(asStr[_id].owner == _pl)
return true;
else
return false;
}
function plPM(uint256 _id, address _pl, uint256 _token) public returns(bool isIndeed) {
require(_token > balance[_pl]);
address _owner;
_owner = asStr[_id].owner;
balance[_owner] = balance[_owner].add(_token);
balance[_pl] = balance[_pl].sub(_token);
isPDM[_id][_pl][_owner] = true;
return true;
}
function plPU(uint256 _id, address _pl, uint256 _token) public returns(bool isIndeed) {
balance[_pl] = balance[_pl].sub(_token);
isPDU[_id][_pl] = true;
return true;
}
function updateBalance(address _pl, uint256 newBalance) public {
balance[_pl] = newBalance;
}
function getAC() public view returns(uint count) {
return aList.length;
}
function newAFMID(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LNAF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte));
}
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
aList.push(_id);
return true;
}
function newAFMIDpayU(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LNAFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte), uint256(_token));
}
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
aList.push(_id);
return true;
}
function newAFMIDonlyLog(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LNAF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte));
}
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
aList.push(_id);
return true;
}
function newAFMIDonlyLogPayU(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LNAFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte), uint256(_token));
}
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
aList.push(_id);
return true;
}
function newAssetFieldAutoID(uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_public_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_public_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LNAF(address(msg.sender), uint256(_public_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte));
}
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newAFAIDpayU(uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_public_id));
plPU(_public_id, msg.sender, _token);
require(isPDU[_public_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_public_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LNAFPay(address(msg.sender), uint256(_public_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte), uint256(_token));
}
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newAssetFieldAutoIDonlyLog(uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_public_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LNAF(address(msg.sender), uint256(_public_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte));
}
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newAFieldAutoIDonlyLogPayU(uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_public_id));
plPU(_public_id, msg.sender, _token);
require(isPDU[_public_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LNAFPay(address(msg.sender), uint256(_public_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), address(_owner), bytes32(_asSte), uint256(_token));
}
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newANoFMID(uint256 _id, bytes32 _rev, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_id));
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
asStr[_id].rev = _rev;
emit LNANF(address(msg.sender), uint256(_id), bytes32(_rev), address(_owner));
aList.push(_id);
return true;
}
function newANoFMIDpayU(uint256 _id, bytes32 _rev, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
asStr[_id].rev = _rev;
emit LNANFPay(address(msg.sender), uint256(_id), bytes32(_rev), address(_owner), uint256(_token));
aList.push(_id);
return true;
}
function newANoFMIDonlyLog(uint256 _id, bytes32 _rev, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_id));
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
emit LNANF(address(msg.sender), uint256(_id), bytes32(_rev), address(_owner));
aList.push(_id);
return true;
}
function newANoFMIDonlyLogPayU(uint256 _id, bytes32 _rev, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
emit LNANFPay(address(msg.sender), uint256(_id), bytes32(_rev), address(_owner), uint256(_token));
aList.push(_id);
return true;
}
function newAssetNoFieldAutoID(bytes32 _rev, address _owner, bytes32 _asSte) public returns(bool success) {
require(isAs(_public_id));
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
asStr[_public_id].rev = _rev;
emit LNANF(address(msg.sender), uint256(_public_id), bytes32(_rev), address(_owner));
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newANoFieldAutoIDpayUni(bytes32 _rev, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_public_id));
plPU(_public_id, msg.sender, _token);
require(isPDU[_public_id][msg.sender]);
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
asStr[_public_id].rev = _rev;
emit LNANFPay(address(msg.sender), uint256(_public_id), bytes32(_rev), address(_owner), uint256(_token));
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newANoFieldAutoIDonlyLog(bytes32 _rev, address _owner, bytes32 _asSte) public returns(bool success) {
require(isAs(_public_id));
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
emit LNANF(address(msg.sender), uint256(_public_id), bytes32(_rev), address(_owner));
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newANoFieldAutoIDonlyLogPayU(bytes32 _rev, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_public_id));
plPU(_public_id, msg.sender, _token);
require(isPDU[_public_id][msg.sender]);
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
emit LNANFPay(address(msg.sender), uint256(_public_id), bytes32(_rev), address(_owner), uint256(_token));
aList.push(_public_id);
_public_id = _public_id + 1;
return true;
}
function newAOneActManID(uint256 _id, bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_id));
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
asStr[_id].act = _act;
asStr[_id].pl = _pl;
asStr[_id].actSt = _actSt;
aList.push(_id);
emit LNAOA(uint256(_id), bytes32(_act), bytes32(_pl), bytes32(_actSt), address(_owner));
return true;
}
function newAOneActManIDpayU(uint256 _id, bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
asStr[_id].owner = _owner;
asStr[_id].isAs = true;
asStr[_id].asSte = _asSte;
asStr[_id].act = _act;
asStr[_id].pl = _pl;
asStr[_id].actSt = _actSt;
aList.push(_id);
emit LNAOAPay(uint256(_id), bytes32(_act), bytes32(_pl), bytes32(_actSt), address(_owner), uint256(_token));
return true;
}
function newAOneActionAID(bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner, bytes32 _asSte) public returns(bool success) {
require(!isAs(_public_id));
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
asStr[_public_id].act = _act;
asStr[_public_id].pl = _pl;
asStr[_public_id].actSt = _actSt;
aList.push(_public_id);
emit LNAOA(uint256(_public_id), bytes32(_act), bytes32(_pl), bytes32(_actSt), address(_owner));
_public_id = _public_id + 1;
return true;
}
function newAOneActAIDpayUnil(bytes32 _act, bytes32 _pl, bytes32 _actSt, address _owner, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(!isAs(_public_id));
plPU(_public_id, msg.sender, _token);
require(isPDU[_public_id][msg.sender]);
asStr[_public_id].owner = _owner;
asStr[_public_id].isAs = true;
asStr[_public_id].asSte = _asSte;
asStr[_public_id].act = _act;
asStr[_public_id].pl = _pl;
asStr[_public_id].actSt = _actSt;
aList.push(_public_id);
emit LNAOAPay(uint256(_public_id), bytes32(_act), bytes32(_pl), bytes32(_actSt), address(_owner), uint256(_token));
_public_id = _public_id + 1;
return true;
}
function changeASField(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte) public returns(bool success) {
require(isAs(_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte));
}
return true;
}
function changeASFPer(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte));
}
return true;
}
function changeASFieldOnlyL(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte) public returns(bool success) {
require(isAs(_id));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LCASF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte));
}
return true;
}
function changeASFieldOnlyLPer(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LCASF(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte));
}
return true;
}
function changeAssetStateNoF(uint256 _id, bytes32 _rev) public returns(bool success) {
require(isAs(_id));
asStr[_id].rev = _rev;
emit LCASNF(address(msg.sender), uint256(_id), bytes32(_rev));
return true;
}
function changeAStateNoFPer(uint256 _id, bytes32 _rev) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
asStr[_id].rev = _rev;
emit LCASNF(address(msg.sender), uint256(_id), bytes32(_rev));
return true;
}
function changeAStateNoFOnlyLog(uint256 _id, bytes32 _rev) public returns(bool success) {
require(isAs(_id));
emit LCASNF(address(msg.sender), uint256(_id), bytes32(_rev));
return true;
}
function changeAStateNoFOnlyLogPer(uint256 _id, bytes32 _rev) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
emit LCASNF(address(msg.sender), uint256(_id), bytes32(_rev));
return true;
}
function changeASFieldPayMu(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
address _owner;
_owner = asStr[_id].owner;
plPM(_id, msg.sender, _token);
require(isPDM[_id][msg.sender][_owner]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
isPDM[_id][msg.sender][_owner] = false;
return true;
}
function changeASFieldPayMuPer(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
address _owner;
_owner = asStr[_id].owner;
plPM(_id, msg.sender, _token);
require(isPDM[_id][msg.sender][_owner]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
isPDM[_id][msg.sender][_owner] = false;
return true;
}
function changeASFieldPayUn(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
isPDU[_id][msg.sender] = false;
return true;
}
function changeASFieldPayUnPer(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
asStr[_id].st.subSt[subStsTypes[counter]] = subSatesValues[counter];
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
isPDU[_id][msg.sender] = false;
return true;
}
function changeASFieldOnlyLPayMu(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
address _owner;
_owner = asStr[_id].owner;
plPM(_id, msg.sender, _token);
require(isPDM[_id][msg.sender][_owner]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
return true;
}
function changeASFieldOnlyLPayMuPer(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
require(isOw(_id, msg.sender));
address _owner;
_owner = asStr[_id].owner;
plPM(_id, msg.sender, _token);
require(isPDM[_id][msg.sender][_owner]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
return true;
}
function changeASFieldOnlyLPayUn(uint256 _id, uint256 numberOfSubStates, bytes32[50] subStsTypes, bytes32[50] subSatesValues, bytes32 _asSte, uint256 _token) public returns(bool success) {
require(isAs(_id));
plPU(_id, msg.sender, _token);
require(isPDU[_id][msg.sender]);
uint256 counter=0;
for(counter; counter < numberOfSubStates; counter++) {
emit LCASFPay(address(msg.sender), uint256(_id), bytes32(subStsTypes[counter]), bytes32(subSatesValues[counter]), bytes32(_asSte), uint256(_token));
}
return true;
}
}
/////////////////////////////////////////////////////////////////
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
Antworten (2)
Lauri Peltonen
Ich würde sagen, Ihr Vertrag ist einfach zu groß. Es überschreitet wahrscheinlich die Gasgrenzen der Netze.
Transaktionen haben aus technischen Gründen ein durch Gas erzwungenes Gaslimit, aber es ist auch eine sehr gute Richtlinie für die Verwaltung Ihres Codes - Sie sollten niemals Verträge haben, die das Limit überschreiten (naja, das können Sie nicht haben, also Problem gelöst). Wenn ein Vertrag so groß ist, ist er zu groß und muss aus technischen und Wartbarkeitsgründen in separate Verträge aufgeteilt werden.
Teilen Sie Ihren Vertrag also einfach in mehrere Verträge auf. Trennen Sie es zum Beispiel nach Funktionalität – wenn Sie einige Speicherinhalte haben, können Sie einen „Speichervertrag“ erstellen und so weiter. Das hilft auch sehr für die Aufrüstbarkeit. Google gibt Ihnen Ideen, aber hier ist ein Link zu aktualisierbaren Verträgen: https://blog.indorse.io/ethereum-upgradeable-smart-contract-strategies-456350d0557c
Fragesteller
testRPCVielen Dank. Könnten Sie sich bitte diese Frage zur Bereitstellung eines Vertrags mit und
ansehen remix? Das Problem steht noch aus ... Ist es normal? Danke. ethereum.stackexchange.com/questions/54413/…Badr Bellaj
Dieser Fehler tritt normalerweise auf, wenn der Compiler eine potenzielle Ausnahme erkennt. Zum Beispiel
Wenn Sie eine Funktion mit einem Modifikator haben, sagen wir:
function f() onlyOwner {..}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
Wenn Sie diese Funktion mit einem anderen Konto als dem Eigentümer aufrufen, wird der von Ihnen erhaltene Fehler generiert, da wir hier eine potenzielle Ausnahme erkennen (require).
Remix IDE – Transaktion zu ___ Fehler: VM-Ausnahme während der Verarbeitung der Transaktion: kein Gas mehr
"Fehler: Grundgebühr überschreitet Gaslimit" bei Verwendung des Entnahmemusters
Warum brauchen View/Pure-Funktionen Gas?
Ethereum-Gasgebühren
Vertragsgasproblem erstellen
Ist es möglich, dass das Blockgaslimit unter sein aktuelles Niveau sinkt?
TX auf Ropsten zurückgesetzt, aber Gaslimit nicht erreicht
Müllabfuhr
Wieso muss ich ein höheres gasLimit als schätzenGas angeben?
Wie simuliert man Out-of-Gas-Ereignisse auf einer privaten Blockchain?
Lauri Peltonen