gistfile1.txt

> eth.getCode(versions.address).length
5956
> eth.getStorageAt(versions.address,0)
"0x0000000000000000000000000000000000000000000000000000000000000002"
> eth.getStorageAt(versions.address,1)
"0x0000000000000000000000000000000000000000000000000000000000000000"
> eth.getStorageAt(versions.address,2)
"0x0000000000000000000000000000000000000000000000000000000000000002"
> eth.getStorageAt(versions.address,3)
"0x0000000000000000000000000000000000000000000000000000000000000000"
> versions.parties()
"0x16db48070243bc37a1c59cd5bb977ad7047618be"
> versions.deleteAcksReq()
2

=================================

contract Versions {
    struct V {
        bytes32 v;
        uint64 ts;
        address[] signers;
    }

    address[] public parties; // owners/signers
    address[] public deleteAcks; // votes to suicide contract
    uint public deleteAcksReq; // number of votes needed
    V[] public versions;

    modifier canAccess(address addr) {
        bool access = false;
        for (uint i = 0; i < parties.length; i++) {
            if (parties[i] == addr) {
                access = true;
                break;
            }
        }
        if (access == false) {
            throw;
        }
        _
    }

    // constructor: create new Version contract with given parties
    function Versions(address[] addrs) {
        if (addrs.length < 2) {
            throw;
        }
        
        // cannot initialise arrays in-line
        parties = addrs;
        deleteAcksReq = parties.length;
    }

    // either submit a new version or acknowledge an existing one
    function AckVersion(bytes32 ver)
        canAccess(msg.sender)
    {
        for (uint i = 0; i < versions.length; i++) {
            if (versions[i].v == ver) {
                for (uint j = 0; j < versions[i].signers.length; j++) {
                    if (versions[i].signers[j] == msg.sender) {
                        // already signed
                        throw;
                    }
                }
                // add sender as signer of existing version
                versions[i].signers.push(msg.sender);
                return;
            }
        }
        // version is new, add it
        address[] memory s;
        s[0] = msg.sender;
        versions.push(V({ v: ver, ts: uint64(block.timestamp), signers: s }));
    }
    
    // delete-this-contract vote, suicide if enough votes
    function AckDelete()
        canAccess(msg.sender)
    {
        for (uint i = 0; i < deleteAcks.length; i++) {
            if (deleteAcks[i] == msg.sender) {
                throw; // already acked delete
            }
        }
        deleteAcks.push(msg.sender);
        if (deleteAcks.length >= deleteAcksReq) {
            suicide(msg.sender);
        }
    }
    
    // remove sender's delete-this-contract vote, if present
    function NackDelete()
        canAccess(msg.sender)
    {
        uint len = deleteAcks.length;
        for (uint i = 0; i < len; i++) {
            if (deleteAcks[i] == msg.sender) {
                if (len > 1) {
                    deleteAcks[i] = deleteAcks[len-1];
                }
                deleteAcks.length -= 1;
            }
        }
    }
    
    // For ABI call in go-ethereum
    // accessor function  'versions' is auto-generated by solidity
}