func (self *Registrar) SetHashReg(hashreg string, addr common.Address) (txhash string, err error) { if hashreg != "" { HashRegAddr = hashreg } else { if !zero.MatchString(HashRegAddr) { return } nameHex, extra := encodeName(HashRegName, 2) hashRegAbi := resolveAbi + nameHex + extra glog.V(logger.Detail).Infof("\ncall HashRegAddr %v with %v\n", GlobalRegistrarAddr, hashRegAbi) var res string res, _, err = self.backend.Call("", GlobalRegistrarAddr, "", "", "", hashRegAbi) if len(res) >= 40 { HashRegAddr = "0x" + res[len(res)-40:len(res)] } if err != nil || zero.MatchString(HashRegAddr) { if (addr == common.Address{}) { err = fmt.Errorf("HashReg address not found and sender for creation not given") return } txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "", "", HashRegCode) if err != nil { err = fmt.Errorf("HashReg address not found and sender for creation failed: %v", err) } glog.V(logger.Detail).Infof("created HashRegAddr @ txhash %v\n", txhash) } else { glog.V(logger.Detail).Infof("HashRegAddr found at @ %v\n", HashRegAddr) return } } return }
func (self *Registrar) SetUrlHint(urlhint string, addr common.Address) (txhash string, err error) { if urlhint != "" { UrlHintAddr = urlhint } else { if !zero.MatchString(UrlHintAddr) { return } nameHex, extra := encodeName(UrlHintName, 2) urlHintAbi := resolveAbi + nameHex + extra glog.V(logger.Detail).Infof("UrlHint address query data: %s to %s", urlHintAbi, GlobalRegistrarAddr) var res string res, _, err = self.backend.Call("", GlobalRegistrarAddr, "", "", "", urlHintAbi) if len(res) >= 40 { UrlHintAddr = "0x" + res[len(res)-40:len(res)] } if err != nil || zero.MatchString(UrlHintAddr) { if (addr == common.Address{}) { err = fmt.Errorf("UrlHint address not found and sender for creation not given") return } txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "210000", "", UrlHintCode) if err != nil { err = fmt.Errorf("UrlHint address not found and sender for creation failed: %v", err) } glog.V(logger.Detail).Infof("created UrlHint @ txhash %v\n", txhash) } else { glog.V(logger.Detail).Infof("UrlHint found @ %v\n", HashRegAddr) return } } return }
func opCreate(instr instruction, pc *uint64, env Environment, contract *Contract, memory *Memory, stack *stack) { var ( value = stack.pop() offset, size = stack.pop(), stack.pop() input = memory.Get(offset.Int64(), size.Int64()) gas = new(big.Int).Set(contract.Gas) addr common.Address ret []byte suberr error ) contract.UseGas(contract.Gas) ret, addr, suberr = env.Create(contract, input, gas, contract.Price, value) if suberr != nil { stack.push(new(big.Int)) } else { // gas < len(ret) * Createinstr.dataGas == NO_CODE dataGas := big.NewInt(int64(len(ret))) dataGas.Mul(dataGas, params.CreateDataGas) if contract.UseGas(dataGas) { env.Db().SetCode(addr, ret) } stack.push(addr.Big()) } }
// SetNonce sets the new canonical nonce for the managed state func (ms *ManagedState) SetNonce(addr common.Address, nonce uint64) { ms.mu.Lock() defer ms.mu.Unlock() so := ms.GetOrNewStateObject(addr) so.SetNonce(nonce) ms.accounts[addr.Str()] = newAccount(so) }
// Start Go API. Not important for this version func (c *Channels) NewChannel(key *ecdsa.PrivateKey, to common.Address, amount, price *big.Int, cb func(*Channel)) (*types.Transaction, error) { from := crypto.PubkeyToAddress(key.PublicKey) data, err := c.abi.Pack("createChannel", to, price) if err != nil { return nil, err } statedb, err := c.blockchain.State() if err != nil { return nil, err } transaction, err := types.NewTransaction(statedb.GetNonce(from), contractAddress, amount, big.NewInt(250000), big.NewInt(50000000000), data).SignECDSA(key) if err != nil { return nil, err } evId := c.abi.Events["NewChannel"].Id() filter := filters.New(c.db) filter.SetAddresses([]common.Address{contractAddress}) filter.SetTopics([][]common.Hash{ // TODO refactor, helper []common.Hash{evId}, []common.Hash{from.Hash()}, []common.Hash{to.Hash()}, }) filter.SetBeginBlock(0) filter.SetEndBlock(-1) filter.LogsCallback = func(logs vm.Logs) { // tere should really be only one log. TODO this part log := logs[0] // TODO: do to and from validation here /* from := log.Topics[1] to := log.Topics[2] */ channelId := common.BytesToHash(log.Data[0:31]) nonce := common.BytesToBig(log.Data[31:]) c.channelMu.Lock() defer c.channelMu.Unlock() channel, exist := c.channels[channelId] if !exist { channel = NewChannel(c, channelId, from, to, nonce) c.channels[channelId] = channel } cb(channel) } c.filters.Add(filter) return transaction, nil }
// called as first step in the registration process on HashReg func (self *Registrar) SetOwner(address common.Address) (txh string, err error) { if zero.MatchString(HashRegAddr) { return "", fmt.Errorf("HashReg address is not set") } return self.backend.Transact( address.Hex(), HashRegAddr, "", "", "", "", setOwnerAbi, ) }
// NewStateObject create a state object whether it exist in the trie or not func (self *StateDB) newStateObject(addr common.Address) *StateObject { if glog.V(logger.Core) { glog.Infof("(+) %x\n", addr) } stateObject := NewStateObject(addr, self.db) stateObject.SetNonce(StartingNonce) self.stateObjects[addr.Str()] = stateObject return stateObject }
// ReserveName(from, name) reserves name for the sender address in the globalRegistrar // the tx needs to be mined to take effect func (self *Registrar) ReserveName(address common.Address, name string) (txh string, err error) { if zero.MatchString(GlobalRegistrarAddr) { return "", fmt.Errorf("GlobalRegistrar address is not set") } nameHex, extra := encodeName(name, 2) abi := reserveAbi + nameHex + extra glog.V(logger.Detail).Infof("Reserve data: %s", abi) return self.backend.Transact( address.Hex(), GlobalRegistrarAddr, "", "", "", "", abi, ) }
// populate the managed state func (ms *ManagedState) getAccount(addr common.Address) *account { straddr := addr.Str() if account, ok := ms.accounts[straddr]; !ok { so := ms.GetOrNewStateObject(addr) ms.accounts[straddr] = newAccount(so) } else { // Always make sure the state account nonce isn't actually higher // than the tracked one. so := ms.StateDB.GetStateObject(addr) if so != nil && uint64(len(account.nonces))+account.nstart < so.nonce { ms.accounts[straddr] = newAccount(so) } } return ms.accounts[straddr] }
// SetAddressToName(from, name, addr) will set the Address to address for name // in the globalRegistrar using from as the sender of the transaction // the tx needs to be mined to take effect func (self *Registrar) SetAddressToName(from common.Address, name string, address common.Address) (txh string, err error) { if zero.MatchString(GlobalRegistrarAddr) { return "", fmt.Errorf("GlobalRegistrar address is not set") } nameHex, extra := encodeName(name, 6) addrHex := encodeAddress(address) abi := registerAbi + nameHex + addrHex + trueHex + extra glog.V(logger.Detail).Infof("SetAddressToName data: %s to %s ", abi, GlobalRegistrarAddr) return self.backend.Transact( from.Hex(), GlobalRegistrarAddr, "", "", "", "", abi, ) }
func (self *Registrar) SetGlobalRegistrar(namereg string, addr common.Address) (txhash string, err error) { if namereg != "" { GlobalRegistrarAddr = namereg return } if zero.MatchString(GlobalRegistrarAddr) { if (addr == common.Address{}) { err = fmt.Errorf("GlobalRegistrar address not found and sender for creation not given") return } else { txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "800000", "", GlobalRegistrarCode) if err != nil { err = fmt.Errorf("GlobalRegistrar address not found and sender for creation failed: %v", err) return } } } return }
// NameToAddr(from, name) queries the registrar for the address on name func (self *Registrar) NameToAddr(from common.Address, name string) (address common.Address, err error) { if zero.MatchString(GlobalRegistrarAddr) { return address, fmt.Errorf("GlobalRegistrar address is not set") } nameHex, extra := encodeName(name, 2) abi := resolveAbi + nameHex + extra glog.V(logger.Detail).Infof("NameToAddr data: %s", abi) res, _, err := self.backend.Call( from.Hex(), GlobalRegistrarAddr, "", "", "", abi, ) if err != nil { return } address = common.HexToAddress(res) return }
// registers some content hash to a key/code hash // e.g., the contract Info combined Json Doc's ContentHash // to CodeHash of a contract or hash of a domain func (self *Registrar) SetHashToHash(address common.Address, codehash, dochash common.Hash) (txh string, err error) { if zero.MatchString(HashRegAddr) { return "", fmt.Errorf("HashReg address is not set") } _, err = self.SetOwner(address) if err != nil { return } codehex := common.Bytes2Hex(codehash[:]) dochex := common.Bytes2Hex(dochash[:]) data := registerContentHashAbi + codehex + dochex glog.V(logger.Detail).Infof("SetHashToHash data: %s sent to %v\n", data, HashRegAddr) return self.backend.Transact( address.Hex(), HashRegAddr, "", "", "", "", data, ) }
// Retrieve a state object given my the address. Nil if not found func (self *StateDB) GetStateObject(addr common.Address) (stateObject *StateObject) { stateObject = self.stateObjects[addr.Str()] if stateObject != nil { if stateObject.deleted { stateObject = nil } return stateObject } data := self.trie.Get(addr[:]) if len(data) == 0 { return nil } stateObject, err := DecodeObject(addr, self.db, data) if err != nil { glog.Errorf("can't decode object at %x: %v", addr[:], err) return nil } self.SetStateObject(stateObject) return stateObject }
// SetUrlToHash(from, hash, url) registers a url to a content hash so that the content can be fetched // address is used as sender for the transaction and will be the owner of a new // registry entry on first time use // FIXME: silently doing nothing if sender is not the owner // note that with content addressed storage, this step is no longer necessary func (self *Registrar) SetUrlToHash(address common.Address, hash common.Hash, url string) (txh string, err error) { if zero.MatchString(UrlHintAddr) { return "", fmt.Errorf("UrlHint address is not set") } hashHex := common.Bytes2Hex(hash[:]) var urlHex string urlb := []byte(url) var cnt byte n := len(urlb) for n > 0 { if n > 32 { n = 32 } urlHex = common.Bytes2Hex(urlb[:n]) urlb = urlb[n:] n = len(urlb) bcnt := make([]byte, 32) bcnt[31] = cnt data := registerUrlAbi + hashHex + common.Bytes2Hex(bcnt) + common.Bytes2Hex(common.Hex2BytesFixed(urlHex, 32)) txh, err = self.backend.Transact( address.Hex(), UrlHintAddr, "", "", "", "", data, ) if err != nil { return } cnt++ } return }
func encodeAddress(address common.Address) string { return addressAbiPrefix + address.Hex()[2:] }
func (ms *ManagedState) hasAccount(addr common.Address) bool { _, ok := ms.accounts[addr.Str()] return ok }