evm_client 0.1.0

data/contracts/VendorRegistry.sol

@@ -0,0 +1,39 @@
+import "contracts/GenericRegistry.sol";
+
+contract VendorRegistry is GenericRegistry {
+
+  Directory.AddressBoolMap vendors;
+
+  struct Vendor {
+    bytes32 name;
+  }
+
+  mapping (address => Vendor) vendorNames;
+  
+  function VendorRegistry(address _conf) {
+    config = _conf;
+  }
+
+  function register(address _acct) ifadmin {
+    if (!Directory.insert(vendors, _acct))
+      throw;
+  }
+
+  function unregister(address _acct) ifadmin {
+    if (!Directory.remove(vendors, _acct))
+      throw;
+  }
+
+  function isVendor(address _acct) public returns (bool) {
+    return Directory.contains(vendors, _acct);
+  }
+
+  function setVendorName(address _vendor, bytes32 _name) ifadmin {
+    vendorNames[_vendor].name = _name;
+  }
+
+  function getVendorName(address _vendor) public returns (bytes32) {
+    return vendorNames[_vendor].name;
+  }
+
+}

data/contracts/classic/Digixbot.sol

@@ -0,0 +1,106 @@
+import "contracts/DigixbotUsers.sol";
+import "contracts/DigixbotConfiguration.sol";
+
+contract Coin {
+  function getBotContract() returns(address );
+  function getUserId(address _address) returns(bytes32 );
+  function withdrawCoin(bytes32 _user,uint256 _amount);
+  function depositCoin(bytes32 _uid,uint256 _amt);
+  function getBalance(bytes32 _uid) returns(uint256 );
+  function totalBalance() returns(uint256 );
+  function getConfig() returns(address );
+  function getUsersContract() returns(address );
+  function sendCoin(bytes32 _sender,bytes32 _recipient,uint256 _amt);
+}
+
+contract Digixbot {
+  address owner;
+  address config;
+
+  function Digixbot(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+
+  modifier ifowner { if(msg.sender == owner) _ }
+
+  function getConfig() public returns (address) {
+    return config;
+  }
+
+  function addUser(bytes32 _userid) ifowner {
+    DigixbotUsers(getUsersContract()).addUser(_userid); 
+  }
+
+  function setUserAccount(bytes32 _userid, address _account) ifowner {
+    bool _acctlock = accountLockCheck(_userid);
+    if (_acctlock == false) {
+      DigixbotUsers(getUsersContract()).setUserAccount(_userid, _account);
+    }
+  }
+
+  function getUserAccount(bytes32 _userid) public returns (address) {
+    return DigixbotUsers(getUsersContract()).getUserAccount(_userid);
+  }
+
+  function getUsersContract() public returns (address) {
+    return DigixbotConfiguration(config).getUsersContract();
+  }
+
+  function getCoinWallet(bytes4 _coin) public returns(address) {
+    return DigixbotConfiguration(config).getCoinWallet(_coin);
+  }
+
+  function userCheck(bytes32 _id) public returns(bool) {
+    return DigixbotUsers(getUsersContract()).userCheck(_id);
+  }
+
+  function sendCoin(bytes4 _coin, bytes32 _from, bytes32 _to, uint _amount) ifowner {
+    bool _tiplock = tipLockCheck(_from);
+    if (_tiplock == false) {
+      Coin(getCoinWallet(_coin)).sendCoin(_from, _to, _amount); 
+    }
+  }
+    
+  function withdrawCoin(bytes4 _coin, bytes32 _userid, uint _amount) ifowner {
+    Coin(getCoinWallet(_coin)).withdrawCoin(_userid, _amount);
+  }
+
+  function getCoinBalance(bytes4 _coin, bytes32 _userid) public returns(uint) {
+    return Coin(getCoinWallet(_coin)).getBalance(_userid);
+  }
+
+  function getTotalBalance(bytes4 _coin) public returns(uint) {
+    return Coin(getCoinWallet(_coin)).totalBalance();
+  }
+
+  function accountLockCheck(bytes32 _id) public returns (bool) {
+    return DigixbotUsers(getUsersContract()).accountLockCheck(_id);
+  }
+  
+  function tipLockCheck(bytes32 _id) public returns (bool) {
+    return DigixbotUsers(getUsersContract()).tipLockCheck(_id);
+  }
+
+  function lockAccount(bytes32 _id) ifowner {
+    DigixbotUsers(getUsersContract()).lockAccount(_id);
+  }
+
+  function lockTip(bytes32 _id) ifowner {
+    DigixbotUsers(getUsersContract()).lockTip(_id);
+  }
+
+  function unlockAccount() {
+    address _userscontract = getUsersContract();
+    bytes32 _userid = DigixbotUsers(_userscontract).getUserId(msg.sender);
+    DigixbotUsers(_userscontract).unlockAccount(_userid);
+  }
+
+  function unlockTip() {
+    address _userscontract = getUsersContract();
+    bytes32 _userid = DigixbotUsers(_userscontract).getUserId(msg.sender);
+    DigixbotUsers(_userscontract).unlockTip(_userid);
+  }
+  
+
+}

data/contracts/classic/DigixbotConfiguration.sol

@@ -0,0 +1,62 @@
+contract DigixbotConfiguration {
+
+  struct Coin {
+    bytes4 name;
+    address wallet;
+    bool locked;
+  }
+
+  address owner;
+  address botcontract;
+  address userscontract;
+  bool locked;
+
+  mapping(bytes4 => Coin) coins;
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier unlesslocked { if (locked == false) _ }
+
+  function DigixbotConfiguration() {
+    owner = msg.sender;
+    locked = false;
+  }
+
+  function getOwner() public constant returns (address) {
+    return owner;
+  }
+
+  function setBotContract(address _botcontract) ifowner unlesslocked {
+    botcontract = _botcontract;
+  }
+  
+  function getBotContract() public returns (address) {
+    return botcontract;
+  }
+
+  function setUsersContract(address _userscontract) ifowner unlesslocked {
+    userscontract = _userscontract;
+  }
+
+  function getUsersContract() public returns (address) {
+    return userscontract;
+  }
+
+  function lockConfiguration() ifowner {
+    locked = true;
+  }
+
+  function addCoin(bytes4 _name, address _wallet) ifowner {
+    Coin _cta = coins[_name];
+    if (_cta.locked == false) {
+      _cta.name = _name;
+      _cta.wallet = _wallet;
+      _cta.locked = true;
+    }
+  }
+
+  function getCoinWallet(bytes4 _coin) public constant returns (address) {
+    return coins[_coin].wallet;
+  }
+
+} 
+

data/contracts/classic/DigixbotEthereum.sol

@@ -0,0 +1,86 @@
+import "contracts/DigixbotConfiguration.sol";
+import "contracts/DigixbotUsers.sol";
+
+contract DigixbotEthereum {
+
+  address config;
+
+  mapping(bytes32 => uint) balances;
+
+  event UserIdLogger(bytes32 indexed _debug);
+
+  function DigixbotEthereum(address _config) {
+    config = _config;
+  }
+
+  function() {
+    bytes32 _userid = getUserId(msg.sender);
+    UserIdLogger(_userid);
+    balances[_userid] += msg.value;
+  }
+
+  function depositCoin(bytes32 _userid, uint _amount) ifbot {
+    balances[_userid] += _amount;
+  }
+
+  function getConfig() public returns (address) {
+    return config;
+  }
+
+  function getUsersContract() public returns (address) {
+    return DigixbotConfiguration(config).getUsersContract();
+  }
+
+  function getBotContract() public returns (address) {
+    return DigixbotConfiguration(config).getBotContract();
+  }
+
+  function getUserId(address _address) public returns (bytes32) {
+    return DigixbotUsers(getUsersContract()).getUserId(_address);
+  }
+
+  function getUserAccount(bytes32 _userid) public returns(address) {
+    return DigixbotUsers(getUsersContract()).getUserAccount(_userid);
+  }
+
+  modifier ifbot { if (msg.sender == getBotContract()) _ }
+  modifier ifusers { if (msg.sender == getUsersContract()) _ }
+
+  function sendCoin(bytes32 _sender, bytes32 _recipient, uint _amt) ifbot {
+    if (_amt >= 100000000000000000) {
+      if (balances[_sender] >= _amt) {
+        balances[_sender] -= _amt;
+        balances[_recipient] += _amt;
+      }
+    }
+  }
+
+  function withdrawCoin(bytes32 _user, uint _amount) ifbot {
+    address _requester = getUserAccount(_user);
+    if (_requester != 0x0000000000000000000000000000000000000000) {
+      if (_amount >= 1000000000000000000) {
+        if (balances[_user] >= _amount) {
+          balances[_user] -= _amount;
+          _requester.send(_amount);
+        }
+      }
+    }
+  }
+
+  function withdrawCoinExt(uint _amount) {
+    bytes32 _requester = getUserId(msg.sender);
+    if (balances[_requester] >= _amount) {
+      balances[_requester] -= _amount;
+      address(msg.sender).send(_amount);
+    }
+  }
+
+  function getBalance(bytes32 _uid) public returns (uint) {
+    return balances[_uid];
+  }
+
+  function totalBalance() public returns (uint) {
+    return this.balance;
+  }
+
+}

data/contracts/classic/DigixbotUsers.sol

@@ -0,0 +1,103 @@
+contract DigixbotUsers {
+
+  struct User {
+    bytes32 id; 
+    address account;
+    bool configured;
+    bool lockaccount;
+    bool locktip;
+  }
+
+  address owner;
+  address config;
+
+  mapping(bytes32 => User) users;
+  mapping(address => bytes32) ids;
+
+  event EventLog(uint indexed _eventType, bytes32 indexed _eventData);
+  enum EventTypes { AddUser, SetAccount }
+
+  function DigixbotUsers(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+
+  function getOwner() public returns (address) {
+    return owner;
+  }
+
+  function getConfig() public returns (address) {
+    return config;
+  }
+
+  function getBotContract() public returns (address) {
+    return DigixbotConfiguration(config).getBotContract();
+  }
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier ifbot { if (msg.sender == getBotContract()) _ }
+
+  function addUser(bytes32 _id) ifbot {
+    users[_id].id = _id;
+    users[_id].configured = true;
+    users[_id].lockaccount = false;
+    users[_id].locktip = false;
+    EventLog(uint(EventTypes.AddUser), _id);
+  }
+
+  function userCheck(bytes32 _id) public returns (bool) {
+    return users[_id].configured;
+  }
+
+  function setUserAccount(bytes32 _id, address _account) ifbot {
+    bool _acctlock = accountLockCheck(_id);
+    if (_acctlock == false) {
+      users[_id].account = _account;
+      ids[_account] = _id; 
+      EventLog(uint(EventTypes.SetAccount), _id);
+    }
+  }
+
+  function accountLockCheck(bytes32 _id) public returns (bool) {
+    return users[_id].lockaccount;
+  }
+
+  function lockAccount(bytes32 _id) ifbot {
+    if (userAddressCheck(_id) == true) {
+      users[_id].lockaccount = true;
+    }
+  }
+
+  function userAddressCheck(bytes32 _id) public returns (bool) {
+    address _user = getUserAccount(_id); 
+    return _user != 0x0000000000000000000000000000000000000000;
+  }
+
+  function unlockAccount(bytes32 _id) ifbot {
+    users[_id].lockaccount = false;
+  }
+
+  function tipLockCheck(bytes32 _id) public returns (bool) {
+    return users[_id].locktip;
+  }
+  
+  function lockTip(bytes32 _id) ifbot {
+    if (userAddressCheck(_id) == true) {
+      users[_id].locktip = true;
+    }
+  }
+
+  function unlockTip(bytes32 _id) ifbot {
+    users[_id].locktip = false;
+  }
+
+  function getUserId(address _account) public returns (bytes32) {
+    return ids[_account];
+  }
+
+  function getUserAccount(bytes32 _id) public returns (address) {
+    return users[_id].account;
+  }
+
+}
+

data/contracts/classic/Gold.sol

@@ -0,0 +1,497 @@
+contract ParticipantRegistry {
+
+  enum ParticipantTypes { Admin, Vendor, Custodian, Auditor }
+  struct ParticipantDatabase {
+    mapping (address => bool) auditors;
+    mapping (address => bool) vendors;
+    mapping (address => bool) custodians;
+    mapping (address => bool) registrars;
+  }
+
+  address owner;
+  ParticipantDatabase participantdb;
+
+  event AddParticipant(address indexed participant, uint indexed participanttype);
+  event RemoveParticipant(address indexed participant, uint indexed participanttype);
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier ifregistrar { if ((participantdb.registrars[tx.origin]) || (tx.origin == owner)) _ }
+  modifier onlyvendor { if (isVendor(tx.origin) == true) _ }
+  modifier onlycustodian { if (isCustodian(tx.origin) == true) _ }
+  modifier onlyauditor { if (isAuditor(tx.origin) == true) _ }
+
+  function ParticipantRegistry() {
+    owner = msg.sender;
+  }
+
+  function getOwner() returns (address oa) {
+    oa = owner;
+  }
+
+  function setOwner(address nown) ifowner {
+    owner = nown;
+  }
+
+  function registerAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = true;
+    AddParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function unregisterAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = false;
+    RemoveParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function registerVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = true;
+    AddParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function unregisterVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = false;
+    RemoveParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function registerCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = true;
+    AddParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function unregisterCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = false;
+    RemoveParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function registerAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = true;
+    AddParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function unregisterAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = false;
+    RemoveParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function isVendor(address vendoraddress) returns (bool) {
+    return participantdb.vendors[vendoraddress];
+  }
+
+  function isCustodian(address custodianaddress) returns (bool) {
+    return participantdb.custodians[custodianaddress];
+  }
+
+  function isAuditor(address auditoraddress) returns (bool) {
+    return participantdb.auditors[auditoraddress];
+  }
+
+  function isRegistrar(address regraddr) returns (bool) {
+    return participantdb.registrars[regraddr];
+  }
+}
+
+contract GoldRegistry  {
+
+  address owner;
+  address participantregistry;
+
+  enum GoldStatusCodes { PendingVerification, Active, RedemptionQueue, Redeemed, Minted }
+
+  struct Audit {
+    uint id;
+    uint time;
+    bool pass;
+    address auditor;
+    bytes32 extradata;
+    bytes32 documentation;
+  }
+
+  struct GoldStatus {
+    uint code;
+    bool vendorverify;
+    bool custodianverify;
+    bool minted;
+    uint auditcount;
+    bool registered;
+    uint lastauditid;
+    Audit lastaudit;
+    mapping (uint => Audit) audits;
+  }
+
+  struct GoldInfo {
+    address vendor;
+    address custodian;
+    uint weight;
+    bytes32 serial;
+    bytes32 sku;
+    bytes32 documentation;
+  }
+
+  struct GoldData {
+    bool initialized;
+    bool minted;
+    uint weight;
+    bytes32 serial;
+    bytes32 sku;
+    bytes32 documentation;
+  }
+
+  struct RegistryData {
+    bool initialized;
+    bool registered;
+    address registry;
+    address vendor;
+    address custodian;
+    address minter;
+  }
+
+  mapping (address => GoldStatus) goldstatusdb;
+  mapping (address => GoldInfo) goldinfodb;
+
+  modifier ifowner { if (msg.sender == owner) _ }
+
+  event GoldPurchase(address indexed gold, address indexed buyer, uint weight);
+  event GoldRedemption(address indexed gold);
+  event VendorVerification(address indexed gold, address indexed vendor, uint indexed time);
+  event CustodianVerification(address indexed gold, address indexed custodian, uint indexed time);
+  event CustodianTransfer(address indexed gold, address indexed oldcustodian, address indexed newcustodian);
+  event AuditEvent(address indexed gold, address indexed auditor, uint indexed lastauditid);
+
+  function GoldRegistry() {
+    owner = msg.sender;
+  }
+
+  function setConfiguration(address pr) ifowner {
+    participantregistry = pr;
+  }
+
+  function getOwner() returns (address o) {
+    o = owner;
+  }
+
+  function setOwner(address nown) ifowner {
+    owner = nown;
+  }
+
+  function getParticipantRegistry() returns (address pr) {
+    pr = participantregistry;
+  }
+
+  function checkCustodian() returns (bool ccheck) {
+    ParticipantRegistry prg = ParticipantRegistry(participantregistry);
+    ccheck = prg.isCustodian(tx.origin); 
+  }
+
+  function checkVendor() returns (bool vcheck) {
+    ParticipantRegistry prg = ParticipantRegistry(participantregistry);
+    vcheck = prg.isVendor(tx.origin);
+  }
+
+  function checkAuditor() returns (bool acheck) {
+    ParticipantRegistry prg = ParticipantRegistry(participantregistry);
+    acheck = prg.isAuditor(tx.origin);
+  }
+
+  function checkRegistrar() returns (bool rcheck) {
+    ParticipantRegistry prg = ParticipantRegistry(participantregistry);
+    rcheck = prg.isRegistrar(tx.origin);
+  }
+
+  modifier ifregistrar { if (checkRegistrar() == true) _ }
+  modifier ifvendor { if (checkVendor() == true) _ }
+  modifier ifcustodian { if (checkCustodian() == true) _ }
+  modifier ifauditor { if (checkAuditor() == true) _ }
+
+  function registerGold() ifregistrar {
+    GoldInfo gidb = goldinfodb[msg.sender];
+    GoldStatus gsdb = goldstatusdb[msg.sender];
+    Gold gld = Gold(msg.sender);
+    if (gsdb.registered == true) return;
+    gidb.vendor = gld.registryRequestVendor();
+    gidb.custodian = gld.registryRequestCustodian();
+    gidb.weight = gld.registryRequestWeight();
+    gidb.serial = gld.registryRequestSerialNumber();
+    gidb.sku = gld.registryRequestSku();
+    gidb.documentation = gld.registryRequestDocumentation();
+    gsdb.vendorverify = false;
+    gsdb.custodianverify = false;
+    gsdb.minted = false;
+    gsdb.registered = true;
+  }
+
+  function getGoldStatusCode(address gaddr) returns (uint gsc) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsc = gsdb.code;
+  }
+
+  function getGoldStatusVendorverify(address gaddr) returns (bool gsvv) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsvv = gsdb.vendorverify;
+  }
+
+  function getGoldStatusCustodianverify(address gaddr) returns (bool gscv) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gscv = gsdb.custodianverify;
+  }
+
+  function getGoldStatusMinted(address gaddr) returns (bool gsms) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsms = gsdb.minted;
+  }
+
+  function getGoldStatusAuditcount(address gaddr) returns (uint gsac) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsac = gsdb.auditcount;
+  }
+
+  function getGoldStatusRegistered(address gaddr) returns (bool gsrs) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsrs = gsdb.registered;
+  }
+
+  function getGoldStatusLastauditid(address gaddr) returns (uint gsla) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsla = gsdb.lastauditid;
+  }
+
+  function getGoldInfoVendor(address gaddr) returns (address giva) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    giva = gidb.vendor;
+  }
+
+  function getGoldInfoCustodian(address gaddr) returns (address gica) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    gica = gidb.custodian;
+  }
+
+  function getGoldInfoWeight(address gaddr) returns (uint giwt) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    giwt = gidb.weight;
+  }
+
+  function getGoldInfoSerial(address gaddr) returns (bytes32 gisn) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    gisn = gidb.serial;
+  }
+
+  function getGoldInfoSku(address gaddr) returns (bytes32 gisk) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    gisk = gidb.sku;
+  }
+
+  function getGoldInfoDocumentation(address gaddr) returns (bytes32 gidc) {
+    GoldInfo gidb = goldinfodb[gaddr];
+    gidc = gidb.documentation;
+  }
+
+  function getLastAuditId(address gaddr) returns (uint ai) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    ai = laud.id;
+  }
+
+  function getLastAuditTime(address gaddr) returns (uint at) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    at = laud.time;
+  }
+
+  function getLastAuditPass(address gaddr) returns (bool ap) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    ap = laud.pass;
+  }
+
+  function getLastAuditAuditor(address gaddr) returns (address aa) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    aa = laud.auditor;
+  }
+
+  function getLastAuditExtradata(address gaddr) returns (bytes32 ae) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    ae = laud.extradata;
+  }
+
+  function getLastAuditDocumentation(address gaddr) returns (bytes32 ad) {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    Audit laud = gsdb.lastaudit;
+    ad = laud.documentation;
+  }
+
+  function custodianVerify(address gaddr) ifcustodian {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsdb.custodianverify = true;
+    CustodianVerification(gaddr, tx.origin, block.timestamp);
+  }
+
+  function vendorVerify(address gaddr) ifvendor {
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsdb.vendorverify = true;
+    VendorVerification(gaddr, tx.origin, block.timestamp);
+  }
+
+  function custodianTransfer(address gaddr, address ncaddr) ifcustodian {
+    GoldInfo gidb = goldinfodb[gaddr];
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gidb.custodian = ncaddr;
+    gsdb.custodianverify = false;
+    CustodianTransfer(gaddr, tx.origin, ncaddr);
+  }
+
+  function auditReport(address gaddr, bool ares, bytes32 ed, bytes32 doc) ifauditor {
+    GoldInfo gidb = goldinfodb[gaddr];
+    GoldStatus gsdb = goldstatusdb[gaddr];
+    gsdb.auditcount++;
+    uint auditcount = gsdb.auditcount;
+    Audit adt = gsdb.audits[auditcount];
+    gsdb.lastaudit = Audit({id: auditcount, time: block.timestamp, pass: ares, auditor: tx.origin, extradata: ed, documentation: doc});
+    adt = gsdb.lastaudit;
+    AuditEvent(gaddr, tx.origin, auditcount);
+  }
+
+}
+
+contract Gold {
+
+  struct GoldData {
+    bool initialized;
+    bool minted;
+    uint weight;
+    bytes32 serial;
+    bytes32 sku;
+    bytes32 documentation;
+  }
+
+  struct RegistryData {
+    bool initialized;
+    bool registered;
+    address registry;
+    address vendor;
+    address custodian;
+    address minter;
+  }
+
+  address owner;
+  GoldData golddata;
+  RegistryData registrydata;
+
+  event SendGoldEvent(address indexed gold, address indexed recipient);
+
+  modifier ifowner { if (msg.sender == owner) _ }
+
+  function Gold() {
+    owner = msg.sender;
+    golddata.minted = false;
+    golddata.initialized = false;
+    registrydata.initialized = false;
+  }
+
+  function getOwner() returns (address oaddr) {
+    oaddr = owner;
+  }
+
+  function initGoldData(uint wt, bytes32 sn, bytes32 sk, bytes32 doc) ifowner {
+    if (golddata.initialized == true) return;
+    golddata = GoldData({initialized: true, minted: false, weight: wt, serial: sn, sku: sk, documentation: doc});
+  }
+
+  function initRegistryData(address raddr, address vaddr, address caddr) ifowner {
+    if (registrydata.initialized == true) return;
+    registrydata = RegistryData({initialized: true, registered: false, registry: raddr, vendor: vaddr, custodian: caddr, minter: address(this)});
+    GoldRegistry goldregistry = GoldRegistry(raddr);
+  }
+
+  function sendRegistration() {
+    if ((registrydata.initialized == true) && (golddata.initialized == true)) {
+      GoldRegistry gr = goldRegistry();
+      gr.registerGold();
+      registrydata.registered = true;
+    }
+  }
+
+  function registryRequestCustodian() public returns (address caddr) {
+    caddr = registrydata.custodian;
+  }
+
+  function registryRequestVendor() public returns (address vaddr) {
+    vaddr = registrydata.vendor;
+  }
+
+  function registryRequestWeight() public returns (uint wt) {
+    wt = golddata.weight;
+  }
+
+  function registryRequestSerialNumber() public returns (bytes32 sn) {
+    sn = golddata.serial;
+  }
+
+  function registryRequestSku() public returns (bytes32 sk) {
+    sk = golddata.sku;
+  }
+
+  function registryRequestDocumentation() public returns (bytes32 doc) {
+    doc = golddata.documentation;
+  }
+
+  function getGoldDataInitialized() returns (bool gdis) {
+    gdis = golddata.initialized;
+  }
+
+  function getGoldDataMinted() returns (bool gdms) {
+    gdms = golddata.minted;
+  }
+
+  function getGoldDataWeight() returns (uint gdwt) {
+    gdwt = golddata.weight;
+  }
+
+  function getGoldDataSerial() returns (bytes32 gdsn) {
+    gdsn = golddata.serial;
+  }
+
+  function getGoldDataSku() returns (bytes32 gdsk) {
+    gdsk = golddata.sku;
+  }
+
+  function getGoldDataDocumentation() returns (bytes32 gddc) {
+    gddc = golddata.documentation;
+  }
+
+  function getRegistryDataInitialized() returns (bool rdis) {
+  rdis = registrydata.initialized;
+  }
+  
+  function getRegistryDataRegistered() returns (bool rdrs) {
+    rdrs = registrydata.registered;
+  }
+  
+  function getRegistryDataRegistry() returns (address rdrg) {
+    rdrg = registrydata.registry;
+  }
+  
+  function getRegistryDataVendor() returns (address rdva) {
+    rdva = registrydata.vendor;
+  }
+  
+  function getRegistryDataCustodian() returns (address rdca) {
+    rdca = registrydata.custodian;
+  }
+  
+  function getRegistryDataMinter() returns (address rdma) {
+    rdma = registrydata.minter;
+  }
+
+  function sendToMinter(uint minttype) ifowner {
+    owner = registrydata.minter;
+    golddata.minted = true;
+    // Notifiy minter contract
+  }
+
+  function goldRegistry() returns (GoldRegistry gr) {
+    gr = GoldRegistry(registrydata.registry);
+  }
+
+
+}
+