Acceso a variables de estado en otro contrato

Traté de agregar métodos en un contrato, pero se hizo tan grande que no pude implementarlo con truffle. Ahora necesito crear otro contrato que se llamará en lugar del contrato original para procesar los datos almacenados en el contrato original como variable de estado.

La variable que voy a procesar es un mapeo.

Estoy tratando de hacer algo como esto:

contract Original {

mapping(bytes32 => Person) private Persons;

 /* many structs and methods here */
}

contract SecondContract {
   function processdata(){
     /* here i want to process the data stored in the mapping in the first contract */
   }
}

¿Cómo obtengo el vínculo entre los dos contratos y puedo procesar esos datos?

Respuestas (2)

Si entiendo correctamente, solo desea acceder a los datos almacenados en Original. Si ese es el caso, puedes hacer algo como esto:

contract Original {
  mapping(bytes32 => Person) public persons;
}

contract SecondContract {
  Original original;

  function SecondContract(address ofOriginalContract) {
    original = Original(ofOriginalContract);
  }

  function processData(bytes32 someBytes) {
    Person entry = original.persons[someBytes];
    // do something with entry
  }
}

Tenga en cuenta que hice personsun publicmapeo, por lo que podemos acceder a él desde otro contrato.

Eso es algo que ya hice, pero el problema es que no puedo agregar nada más a mi contrato, porque no se implementará en el ganache-cli (debido al tamaño). por lo tanto, agregar un segundo contrato al lado del contrato original no será diferente de agregar processDatauna función al contrato original

Amplificando la respuesta de @ Travis.

Esta línea

Original original;

agrega un tamaño considerable a SecondContractporque contiene Original .

Ese es un problema aparte que se puede resolver con una interfaz. SecondContractno requiere el código de bytes completo para Original. Eso es repetitivo e innecesario. Solo necesita la firma de la función y la dirección de la instancia para hablar.

Hay algunas preocupaciones complicadas de herencia y conversión de tipos para desenredar, de modo que SecondContractpueda heredar la representación más pequeña posible del Originalárea de superficie de 's (pero no el código de trabajo) y ambos contratos pueden estar en perfecta sincronización sobre el diseño del Person. Decidí intentarlo por ti. Puede extrapolar eso a una situación más compleja.

SecondContractserá mucho más pequeño porque el interfacesque hereda nunca crecerá mucho.

pragma solidity 0.8.1;

interface Types {
  struct Person {
    uint age;
    string name;
  }    
}

interface IOriginal is Types {
  function persons(bytes32) external view returns(uint, string memory);
}

contract Original is IOriginal {
  mapping(bytes32 => Person) public override persons;
}

contract SecondContract is Types {
  IOriginal original;

  constructor(address ofOriginalContract) {
    original = IOriginal(ofOriginalContract);
  }

  function processData(bytes32 someBytes) public {
    (uint age, string memory name) = original.persons(someBytes);
    // do something with entry
  }
}

Sería más satisfactorio si function persons()devolviera a Personen lugar de los miembros en structpero no conseguí que funcionara. Tal vez un alma amable intervenga con una solución para eso.

Espero eso ayude.

Acceso a variables de estado en otro contrato
RespuestasAquíPolítica de privacidad1y, 0v