Empujar/retirar datos del contrato de almacenamiento de datos

¿Hay alguna manera de que pueda tener un contrato inteligente que almacene el valor y el nombre y luego se pueda llamar desde otro contrato inteligente? Algo como esto.. (pero eso funciona)

Contract D {
    struct Document{
      string name;
      uint value;
    }

    function StoreDocument(bytes32 key, string name, uint value) returns (bool success) {
     var doc = Document(name, value);
     documents[key].push(doc);
     return true;
    }
}

Y luego me gustaría que otro contrato tome la clave, la dirección del contrato y el nombre y pueda devolver el valor para usar en un contrato. Cualquier ayuda sería genial.

Contract E {
    function RetrieveData(address ConDadd, bytes32 key, string name) {
    //some funciton to get the data from Contract D
    }
}

Respuestas (1)

Empecé con tu ejemplo y lo adapté hasta que funciona. Algunos consejos que noté mientras lo hacía.

structdefine un Tipo. Tienes que convertir una variable con ese tipo en valores de almacenamiento. mappinges la herramienta para organizar instancias por clave única.

Cambié el Tipo de namea bytes32porque no es posible pasar cadenas entre contratos en este momento.

E necesitará conocer el ABI de D para poder realizar llamadas. D está en el mismo archivo fuente, por lo que el compilador puede "verlo" cuando encuentra esta línea que convierte una variable como tipo "D".

D d;

E también necesitará saber la dirección de "la" instancia D con la que debería estar hablando. El constructor de E espera que se le pase una dirección cuando se implementa.

Hice público el mapeo, por lo que se llama a una función de obtención "gratuita" documentStructs()y espera solo el keypaso. Devuelve los dos valores almacenados.

pragma solidity ^0.4.6;

contract D {

  // This is a Type
  struct DocumentStruct{
    // Not possible to pass strings between contracts at this time
    bytes32 name;
    uint value;
  }

  // This is a namespace where we will store docs of Type DocumentStruct
  mapping(bytes32 => DocumentStruct) public documentStructs;

  // Set values in storage
  function StoreDocument(bytes32 key, bytes32 name, uint value) returns (bool success) {
   documentStructs[key].name  = name;
   documentStructs[key].value = value;
   return true;
  }

}

contract E {

  // "d" is of type "D" which is a contract ^
  D d;

  // Define the Type in this context
  struct DocumentStruct{
    bytes32 name;
    uint value;
  }    

  // For this to work, pass in D's address to E's constructor
  function E(address DContractAddress) {
    d = D(DContractAddress);
  }

  function RetrieveData(bytes32 key) 
    public
    constant
    returns(bytes32, uint) 
  {
    // Declare a temporary "doc" to hold a DocumentStruct
    DocumentStruct memory doc;
    // Get it from the "public" mapping's free getter.
    (doc.name, doc.value) = d.documentStructs(key);
    // return values with a fixed sized layout
    return(doc.name, doc.value);
  }
}

Hay todo tipo de consideraciones de organización de datos no obvias que pueden ser un poco difíciles en las primeras etapas. Puede ser útil observar las fortalezas y debilidades de los diferentes patrones desarrollados aquí: ¿Existen patrones de almacenamiento simples y bien resueltos para Solidity?

Aquí está lo anterior en Remix para mostrar que funciona.

Espero eso ayude.

ingrese la descripción de la imagen aquí

¡Eres genial, Rob! Esto es justo lo que necesitaba y gracias por los consejos también.
Empujar/retirar datos del contrato de almacenamiento de datos
RespuestasAquíPolítica de privacidad1y, 0v