"Es probable que la ejecución de la transacción falle. ¿Desea forzar el envío? Excepción de máquina virtual al procesar la transacción: sin combustible"
Preguntador
Cuando quiero implementar un contrato usando testRPCy remix, recibo el siguiente mensaje de error:
Error de estimación de gas con el siguiente mensaje (ver más abajo). Es probable que la ejecución de la transacción falle. ¿Quieres forzar el envío? Excepción de máquina virtual al procesar la transacción: sin combustible
Y no se soluciona aumentando el gas limit.
¿Cómo puedo manejar este problema?
Aquí está el código de solidez:
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;
}
}
Respuestas (2)
Lauri Peltonen
Yo diría que su contrato es simplemente demasiado grande. Probablemente exceda los límites de gas de las redes.
Las transacciones tienen un límite de gas impuesto por razones técnicas, pero también es una muy buena guía para administrar su código: nunca debe tener contratos que excedan el límite (bueno, no puede tener, así que problema resuelto). Si un contrato es tan grande, es demasiado grande y debe dividirse en contratos separados por razones técnicas y de mantenimiento.
Así que simplemente divida su contrato en múltiples contratos. Sepárelo, por ejemplo, por funcionalidad: si tiene algunos contenidos de almacenamiento, puede crear un contrato de "almacenamiento", etc. Eso también ayuda mucho para la capacidad de actualización. Google le dará ideas, pero aquí hay un enlace sobre contratos actualizables: https://blog.indorse.io/ethereum-upgradeable-smart-contract-strategies-456350d0557c
Preguntador
Gracias. ¿Podría echar un vistazo a esta pregunta sobre la implementación de un contrato usando
testRPCy remix? El problema está pendiente... ¿Es normal? Gracias. ethereum.stackexchange.com/questions/54413/…Badr Bellaj
Este error normalmente ocurre si el compilador detecta una posible excepción. Por ejemplo
si tiene una función con un modificador, digamos:
function f() onlyOwner {..}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
llamar a esta función con una cuenta diferente a la del propietario generará el error que tiene porque detectamos aquí una excepción potencial (requerido).
Remix IDE: transacción a ___ con error: excepción de máquina virtual al procesar la transacción: sin combustible
"Error: la tarifa base excede el límite de gasolina" al usar el patrón de retiro
¿Por qué las funciones view/pure necesitan gas?
Tarifas de gas Ethereum
Crear problema de gas de contrato
¿Es posible que el límite de gas del bloque caiga por debajo de su nivel actual?
Tx revertido en Ropsten pero límite de gas no alcanzado
Recolección de basura
¿Por qué necesito especificar un límite de gas más alto que el gas estimado?
¿Cómo simular eventos de falta de gas en una cadena de bloques privada?
Lauri Peltonen