Multisign in nur einer Transaktion

Ich codiere einen Vertrag, in dem ich möchte, dass einige Funktionen nur aufgerufen werden, wenn sie von 2 Personen (einem Händler und einem Kunden) genehmigt werden.

Jetzt weiß ich, dass ich einen Puffer programmieren könnte, der ausstehende Anfragen speichert und darauf wartet, dass jeder Teil eine Bestätigungstransaktion sendet.

Ich möchte nicht, dass der Händler ohne die Zustimmung des Kunden handelt, aber das Problem ist, dass ich nicht möchte, dass der Kunde für das Gas bezahlt.

Was ich dachte, war, irgendwie nur eine Transaktion durchzuführen, die vom Händler gesendet wurde (der somit für das Benzin bezahlt), aber dass ich in meinem Smart Contract einchecken könnte, dass die Transaktion vom Kunden unterzeichnet wurde.

Hast du einen Tipp, wie man das am besten umsetzt?

Danke für deine Antworten

Antworten (2)

Sie könnten einen ähnlichen Ansatz wie die Balance Proofs in Raidens Implementierung von Zustandskanälen verwenden . Grundsätzlich können Sie den Kunden eine Bestätigung unterschreiben lassen, die möglicherweise nur der Kunde hätte unterschreiben können, und diese Unterschrift dann in einem Solidity-Vertrag überprüfen.

In deinem speziellen Beispiel würde ich es so angehen:

  1. Der Händler speichert die Adresse des Kunden in einem Smart Contract.
  2. Der Kunde signiert die Transaktionsdaten außerhalb der Kette.
  3. Der Händler sendet die Transaktion zum Vertrag inklusive der Unterschrift des Kunden.
  4. Der Smart Contract leitet die Adresse aus der Signatur ab und gleicht diese mit der in Schritt 1 gespeicherten Kundenadresse ab.

Siehe Code für die Verwendung von Metamask zum Signieren von Daten hier .

Hier ist ein weiteres Beispiel für Single Transaction Multisig von Christian Lundkvist. Dieses Schema ist Bitcoin Multisig näher als die Stateful Multisig-Verträge.

https://medium.com/@ChrisLundkvist/exploring-simpler-ethereum-multisig-contracts-b71020c19037

Code:

pragma solidity 0.4.15;
contract SimpleMultiSig {

uint public nonce;                // (only) mutable state
uint public threshold;            // immutable state
mapping (address => bool) isOwner; // immutable state
address[] public ownersArr;        // immutable state

function SimpleMultiSig(uint threshold_, address[] owners_) {
  require(owners_.length <= 10 && threshold_ <= owners_.length && threshold_ != 0);

  address lastAdd = address(0); 
  for (uint i=0; i<owners_.length; i++) {
    require(owners_[i] > lastAdd);
    isOwner[owners_[i]] = true;
    lastAdd = owners_[i];
  }
  ownersArr = owners_;
  threshold = threshold_;
}

// Note that address recovered from signatures must be strictly increasing
function execute(uint8[] sigV, bytes32[] sigR, bytes32[] sigS, address destination, uint value, bytes data) {
  require(sigR.length == threshold);
  require(sigR.length == sigS.length && sigR.length == sigV.length);

  // Follows ERC191 signature scheme: https://github.com/ethereum/EIPs/issues/191
  bytes32 txHash = keccak256(byte(0x19), byte(0), this, destination, value, data, nonce);

  address lastAdd = address(0); // cannot have address(0) as an owner
  for (uint i = 0; i < threshold; i++) {
      address recovered = ecrecover(txHash, sigV[i], sigR[i], sigS[i]);
      require(recovered > lastAdd && isOwner[recovered]);
      lastAdd = recovered;
  }

  // If we make it here all signatures are accounted for
  nonce = nonce + 1;
  require(destination.call.value(value)(data));
}

function () payable {}

}

Multisign in nur einer Transaktion
AntwortenHierDatenschutz-Bestimmungen1y, 0v