Wird die Adresse bei der Bereitstellung als einzelne Quelldatei in der Variablen creator = TokenCreator(msg.sender) in der Funktion OwnedToken sich auf die Adresse des Vertrags TokenCreator oder die Adresse eines externen Kontos bezieht?
contract OwnedToken {
TokenCreator creator ; address owner ; bytes32 name ;
function OwnedToken ( bytes32 _name ) { owner = msg . sender ; creator = TokenCreator ( msg . sender ); name = _name ;
}
function changeName ( bytes32 newName ) {
if ( msg . sender == creator ) name = newName ;
}
function transfer ( address newOwner ) {
if ( msg . sender != owner ) return ;
if ( creator . isTokenTransferOK ( owner , newOwner )) owner = newOwner ;
} contract TokenCreator {
function createToken ( bytes32 name ) returns ( OwnedToken tokenAddress )
{
return new OwnedToken ( name );
}
function changeName ( OwnedToken tokenAddress , bytes32 name ) { tokenAddress . changeName ( name );
}
function isTokenTransferOK ( address currentOwner , address newOwner ) returns ( bool ok ) { address tokenAddress = msg . sender ;
return ( sha3 ( newOwner ) & 0xff ) == ( bytes20 ( tokenAddress ) & 0xff );
}
} In creator = TokenCreator(msg.sender);
creator hat die Adresse von msg.sender .
msg.sender ist die Adresse des Kontos, das OwnedToken erstellt. Es gibt 2 Fälle:
OwnedToken erstellt ODER
TokenCreator , der ein OwnedToken (über das new OwnedToken(...) ). Bei der Bereitstellung als einzelne Quelldatei wird nur der letzte Vertrag in der Blockchain instanziiert , einer Instanz von TokenCreator, die eine Adresse erhält. Nennen Sie sie X
Wenn eine Transaktion später an X createToken wird und createToken createToken , wird OwnedToken in der Blockchain instanziiert und der creator in diesem OwnedToken ist X
Beachten Sie, dass sich X von dem externen Konto unterscheidet, das zum Bereitstellen der einzelnen Quelldatei verwendet wird. Das externe Konto, das createToken kann mit dem Konto identisch oder verschieden sein, das zum Bereitstellen der einzelnen Quelldatei verwendet wird.
In den Solidity-Dokumenten finden Sie ein Beispiel für einen Vertrag, der einen anderen repliziert:
contract ReplicatorB { address creator ;
uint blockCreatedOn ;
function Replicator ()
{ creator = msg . sender ;
// next = new ReplicatorA(); // Replicator B can't instantiate A because it doesn't yet know about A
// At the time of this writing (Sept 2015), It's impossible to create cyclical relationships
// either with self-replicating contracts or ABAB blockCreatedOn = block . number ;
}
function getBlockCreatedOn () constant returns ( uint )
{
return blockCreatedOn ;
}
/********** Standard kill() function to recover funds **********/
function kill ()
{
if ( msg . sender == creator )
{ suicide ( creator ); // kills this contract and sends remaining funds back to creator
}
}
} contract ReplicatorA { address creator ; address baddress ;
uint blockCreatedOn ;
function Replicator ()
{ creator = msg . sender ; baddress = new ReplicatorB (); // This works just fine because A already knows about B blockCreatedOn = block . number ;
}
function getBAddress () constant returns ( address )
{
return baddress ;
}
function getBlockCreatedOn () constant returns ( uint )
{
return blockCreatedOn ;
}
/********** Standard kill() function to recover funds **********/
function kill ()
{
if ( msg . sender == creator )
{ suicide ( creator ); // kills this contract and sends remaining funds back to creator
}
}
}