revocar o invalidar token después de 30 minutos

Si Alice le paga a Bob, no tenemos forma de obligar a Bob a devolverlo.

Alice puede pagar un contrato y estipular que Bob es la única persona autorizada para gastar esos fondos. Además, podemos estipular una fecha límite después de la cual Bob ya no está autorizado a gastar los fondos y Alice SÍ está autorizada a reclamar un reembolso.

Existe una complicación adicional en el sentido de que Bob puede tener muchos depósitos de este tipo, cada uno con sus propios plazos, por lo que se vuelve bastante incómodo tratarlo como un saldo neto global. En cambio, el siguiente ejemplo rastrea cada tramo como un depósito específico con su propia fecha límite, y cada vez que Bob reenvía fondos, especifica qué tramo (llamado númeroDepósito) está gastando.

Utiliza un proceso de retiro perezoso para devolver los fondos a Alice si no se envían a otra persona antes de la fecha límite. Alice está motivada para recibir el reembolso, por lo que revisará el contrato y pagará la tarifa del gas para procesarlo.

A continuación se muestra solo un garabato concebido apresuradamente sin pruebas. Se aproxima a la idea. Espero eso ayude.

    pragma solidity ^0.4.6;

// Alice gives Bob ETH to spend before deadline, or Alice gets it back. 
// Alice = sender
// Bob = spender
// recipient is whomever Bob decides to forward to

contract ForcedForward {

    struct DepositStruct {
        address sender;
        uint amount;
        uint blockNumber;
        uint deadline;
    }

    mapping(address => DepositStruct[]) spenderDepositStructs;

    event LogReceived (address spender, uint depositNumber, uint amount, uint deadline, address sender);
    event LogForwarded(address spender, uint depositNumber, uint amount, address recipient);
    event LogWithdrawn(address spender, uint depositNumber, uint amount, address sender);

    //////////////////////////////////
    // Send funds and authorize
    // someone else to spend before
    // a certain deadline (block)

    function deposit(address spender, uint deadline)
        public
        payable
        returns(bool success)
    {
        if(deadline <= block.number) throw; // must be in the future
        if(msg.value==0) throw; // no money sent
        DepositStruct memory d;
        d.sender = msg.sender;
        d.amount = msg.value;
        d.deadline = deadline;
        spenderDepositStructs[spender].push(d);
        LogReceived(spender, spenderDepositStructs[spender].length-1, msg.value, deadline, msg.sender);
        return true;
    }

    //////////////////////////////////
    // Forward funds if authorized to
    // before the deadline is passed

    function forward(address recipient, uint depositNumber)
        public
        returns(bool success)
    {
        DepositStruct d = spenderDepositStructs[msg.sender][depositNumber];
        if(d.deadline < block.number) throw; // too late
        uint amount = d.amount;
        if(amount == 0) throw; // no money
        spenderDepositStructs[msg.sender][depositNumber].amount = 0; // zero out the balance
        if(!recipient.send(d.amount)) throw;
        LogForwarded(msg.sender, depositNumber, amount, recipient);
        return true;
    }

    //////////////////////////////////
    // Clawback funds 

    function withdraw(address spender, uint depositNumber)
        public
        returns(bool success)
    {
        DepositStruct d = spenderDepositStructs[spender][depositNumber];
        if(d.sender != msg.sender) throw; // not originator. not entitled to it. Error. 
        if(d.deadline > block.number) throw; // too soon
        uint amount = d.amount;
        spenderDepositStructs[spender][depositNumber].amount = 0; // zero out the balance. 
        if(amount==0) throw; // no money
        if(!msg.sender.send(amount)) throw; // try to send it back
        LogWithdrawn(spender, depositNumber, amount, msg.sender);
        return true;
    }

    ///////////////////////////////////////////
    // Getter functions for visibility

    function getSpenderDepositCount(address spender) 
        public
        constant
        returns(uint spenderDepositCount)
    {
        return spenderDepositStructs[spender].length;
    }

    function getSpenderDeposit(address spender, uint depositNumber)
        public
        constant
        returns(address sender, uint amount, uint deadline)
    {
        DepositStruct d;
        d = spenderDepositStructs[spender][depositNumber];
        return(d.sender, d.amount, d.deadline);
    }

}