diff --git a/contracts/chequebook/api.go b/contracts/chequebook/api.go index b2b2365f3..fb7080308 100644 --- a/contracts/chequebook/api.go +++ b/contracts/chequebook/api.go @@ -27,40 +27,40 @@ const Version = "1.0" var errNoChequebook = errors.New("no chequebook") -type Api struct { +type API struct { chequebookf func() *Chequebook } -func NewApi(ch func() *Chequebook) *Api { - return &Api{ch} +func NewAPI(ch func() *Chequebook) *API { + return &API{ch} } -func (self *Api) Balance() (string, error) { - ch := self.chequebookf() +func (a *API) Balance() (string, error) { + ch := a.chequebookf() if ch == nil { return "", errNoChequebook } return ch.Balance().String(), nil } -func (self *Api) Issue(beneficiary common.Address, amount *big.Int) (cheque *Cheque, err error) { - ch := self.chequebookf() +func (a *API) Issue(beneficiary common.Address, amount *big.Int) (cheque *Cheque, err error) { + ch := a.chequebookf() if ch == nil { return nil, errNoChequebook } return ch.Issue(beneficiary, amount) } -func (self *Api) Cash(cheque *Cheque) (txhash string, err error) { - ch := self.chequebookf() +func (a *API) Cash(cheque *Cheque) (txhash string, err error) { + ch := a.chequebookf() if ch == nil { return "", errNoChequebook } return ch.Cash(cheque) } -func (self *Api) Deposit(amount *big.Int) (txhash string, err error) { - ch := self.chequebookf() +func (a *API) Deposit(amount *big.Int) (txhash string, err error) { + ch := a.chequebookf() if ch == nil { return "", errNoChequebook } diff --git a/contracts/chequebook/cheque.go b/contracts/chequebook/cheque.go index 92bd896e0..32e840676 100644 --- a/contracts/chequebook/cheque.go +++ b/contracts/chequebook/cheque.go @@ -75,8 +75,8 @@ type Cheque struct { Sig []byte // signature Sign(Keccak256(contract, beneficiary, amount), prvKey) } -func (self *Cheque) String() string { - return fmt.Sprintf("contract: %s, beneficiary: %s, amount: %v, signature: %x", self.Contract.Hex(), self.Beneficiary.Hex(), self.Amount, self.Sig) +func (ch *Cheque) String() string { + return fmt.Sprintf("contract: %s, beneficiary: %s, amount: %v, signature: %x", ch.Contract.Hex(), ch.Beneficiary.Hex(), ch.Amount, ch.Sig) } type Params struct { @@ -109,12 +109,12 @@ type Chequebook struct { log log.Logger // contextual logger with the contract address embedded } -func (self *Chequebook) String() string { - return fmt.Sprintf("contract: %s, owner: %s, balance: %v, signer: %x", self.contractAddr.Hex(), self.owner.Hex(), self.balance, self.prvKey.PublicKey) +func (cb *Chequebook) String() string { + return fmt.Sprintf("contract: %s, owner: %s, balance: %v, signer: %x", cb.contractAddr.Hex(), cb.owner.Hex(), cb.balance, cb.prvKey.PublicKey) } // NewChequebook creates a new Chequebook. -func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.PrivateKey, backend Backend) (self *Chequebook, err error) { +func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.PrivateKey, backend Backend) (*Chequebook, error) { balance := new(big.Int) sent := make(map[common.Address]*big.Int) @@ -128,7 +128,7 @@ func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.Priva TransactOpts: *transactOpts, } - self = &Chequebook{ + cb := &Chequebook{ prvKey: prvKey, balance: balance, contractAddr: contractAddr, @@ -140,42 +140,39 @@ func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.Priva session: session, log: log.New("contract", contractAddr), } - if (contractAddr != common.Address{}) { - self.setBalanceFromBlockChain() - self.log.Trace("New chequebook initialised", "owner", self.owner, "balance", self.balance) + cb.setBalanceFromBlockChain() + cb.log.Trace("New chequebook initialised", "owner", cb.owner, "balance", cb.balance) } - return + return cb, nil } -func (self *Chequebook) setBalanceFromBlockChain() { - balance, err := self.backend.BalanceAt(context.TODO(), self.contractAddr, nil) +func (cb *Chequebook) setBalanceFromBlockChain() { + balance, err := cb.backend.BalanceAt(context.TODO(), cb.contractAddr, nil) if err != nil { log.Error("Failed to retrieve chequebook balance", "err", err) } else { - self.balance.Set(balance) + cb.balance.Set(balance) } } // LoadChequebook loads a chequebook from disk (file path). -func LoadChequebook(path string, prvKey *ecdsa.PrivateKey, backend Backend, checkBalance bool) (self *Chequebook, err error) { - var data []byte - data, err = ioutil.ReadFile(path) - if err != nil { - return - } - self, _ = NewChequebook(path, common.Address{}, prvKey, backend) - - err = json.Unmarshal(data, self) +func LoadChequebook(path string, prvKey *ecdsa.PrivateKey, backend Backend, checkBalance bool) (*Chequebook, error) { + data, err := ioutil.ReadFile(path) if err != nil { return nil, err } + cb, _ := NewChequebook(path, common.Address{}, prvKey, backend) + + if err = json.Unmarshal(data, cb); err != nil { + return nil, err + } if checkBalance { - self.setBalanceFromBlockChain() + cb.setBalanceFromBlockChain() } log.Trace("Loaded chequebook from disk", "path", path) - return + return cb, nil } // chequebookFile is the JSON representation of a chequebook. @@ -187,19 +184,19 @@ type chequebookFile struct { } // UnmarshalJSON deserialises a chequebook. -func (self *Chequebook) UnmarshalJSON(data []byte) error { +func (cb *Chequebook) UnmarshalJSON(data []byte) error { var file chequebookFile err := json.Unmarshal(data, &file) if err != nil { return err } - _, ok := self.balance.SetString(file.Balance, 10) + _, ok := cb.balance.SetString(file.Balance, 10) if !ok { return fmt.Errorf("cumulative amount sent: unable to convert string to big integer: %v", file.Balance) } - self.contractAddr = common.HexToAddress(file.Contract) + cb.contractAddr = common.HexToAddress(file.Contract) for addr, sent := range file.Sent { - self.sent[common.HexToAddress(addr)], ok = new(big.Int).SetString(sent, 10) + cb.sent[common.HexToAddress(addr)], ok = new(big.Int).SetString(sent, 10) if !ok { return fmt.Errorf("beneficiary %v cumulative amount sent: unable to convert string to big integer: %v", addr, sent) } @@ -208,14 +205,14 @@ func (self *Chequebook) UnmarshalJSON(data []byte) error { } // MarshalJSON serialises a chequebook. -func (self *Chequebook) MarshalJSON() ([]byte, error) { +func (cb *Chequebook) MarshalJSON() ([]byte, error) { var file = &chequebookFile{ - Balance: self.balance.String(), - Contract: self.contractAddr.Hex(), - Owner: self.owner.Hex(), + Balance: cb.balance.String(), + Contract: cb.contractAddr.Hex(), + Owner: cb.owner.Hex(), Sent: make(map[string]string), } - for addr, sent := range self.sent { + for addr, sent := range cb.sent { file.Sent[addr.Hex()] = sent.String() } return json.Marshal(file) @@ -223,76 +220,78 @@ func (self *Chequebook) MarshalJSON() ([]byte, error) { // Save persists the chequebook on disk, remembering balance, contract address and // cumulative amount of funds sent for each beneficiary. -func (self *Chequebook) Save() (err error) { - data, err := json.MarshalIndent(self, "", " ") +func (cb *Chequebook) Save() error { + data, err := json.MarshalIndent(cb, "", " ") if err != nil { return err } - self.log.Trace("Saving chequebook to disk", self.path) + cb.log.Trace("Saving chequebook to disk", cb.path) - return ioutil.WriteFile(self.path, data, os.ModePerm) + return ioutil.WriteFile(cb.path, data, os.ModePerm) } // Stop quits the autodeposit go routine to terminate -func (self *Chequebook) Stop() { - defer self.lock.Unlock() - self.lock.Lock() - if self.quit != nil { - close(self.quit) - self.quit = nil +func (cb *Chequebook) Stop() { + defer cb.lock.Unlock() + cb.lock.Lock() + if cb.quit != nil { + close(cb.quit) + cb.quit = nil } } // Issue creates a cheque signed by the chequebook owner's private key. The // signer commits to a contract (one that they own), a beneficiary and amount. -func (self *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *Cheque, err error) { - defer self.lock.Unlock() - self.lock.Lock() +func (cb *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (*Cheque, error) { + defer cb.lock.Unlock() + cb.lock.Lock() if amount.Sign() <= 0 { return nil, fmt.Errorf("amount must be greater than zero (%v)", amount) } - if self.balance.Cmp(amount) < 0 { - err = fmt.Errorf("insufficient funds to issue cheque for amount: %v. balance: %v", amount, self.balance) + var ( + ch *Cheque + err error + ) + if cb.balance.Cmp(amount) < 0 { + err = fmt.Errorf("insufficient funds to issue cheque for amount: %v. balance: %v", amount, cb.balance) } else { var sig []byte - sent, found := self.sent[beneficiary] + sent, found := cb.sent[beneficiary] if !found { sent = new(big.Int) - self.sent[beneficiary] = sent + cb.sent[beneficiary] = sent } sum := new(big.Int).Set(sent) sum.Add(sum, amount) - sig, err = crypto.Sign(sigHash(self.contractAddr, beneficiary, sum), self.prvKey) + sig, err = crypto.Sign(sigHash(cb.contractAddr, beneficiary, sum), cb.prvKey) if err == nil { ch = &Cheque{ - Contract: self.contractAddr, + Contract: cb.contractAddr, Beneficiary: beneficiary, Amount: sum, Sig: sig, } sent.Set(sum) - self.balance.Sub(self.balance, amount) // subtract amount from balance + cb.balance.Sub(cb.balance, amount) // subtract amount from balance } } - // auto deposit if threshold is set and balance is less then threshold // note this is called even if issuing cheque fails // so we reattempt depositing - if self.threshold != nil { - if self.balance.Cmp(self.threshold) < 0 { - send := new(big.Int).Sub(self.buffer, self.balance) - self.deposit(send) + if cb.threshold != nil { + if cb.balance.Cmp(cb.threshold) < 0 { + send := new(big.Int).Sub(cb.buffer, cb.balance) + cb.deposit(send) } } - - return + return ch, err } // Cash is a convenience method to cash any cheque. -func (self *Chequebook) Cash(ch *Cheque) (txhash string, err error) { - return ch.Cash(self.session) +func (cb *Chequebook) Cash(ch *Cheque) (string, error) { + return ch.Cash(cb.session) } // data to sign: contract address, beneficiary, cumulative amount of funds ever sent @@ -309,73 +308,73 @@ func sigHash(contract, beneficiary common.Address, sum *big.Int) []byte { } // Balance returns the current balance of the chequebook. -func (self *Chequebook) Balance() *big.Int { - defer self.lock.Unlock() - self.lock.Lock() - return new(big.Int).Set(self.balance) +func (cb *Chequebook) Balance() *big.Int { + defer cb.lock.Unlock() + cb.lock.Lock() + return new(big.Int).Set(cb.balance) } // Owner returns the owner account of the chequebook. -func (self *Chequebook) Owner() common.Address { - return self.owner +func (cb *Chequebook) Owner() common.Address { + return cb.owner } // Address returns the on-chain contract address of the chequebook. -func (self *Chequebook) Address() common.Address { - return self.contractAddr +func (cb *Chequebook) Address() common.Address { + return cb.contractAddr } // Deposit deposits money to the chequebook account. -func (self *Chequebook) Deposit(amount *big.Int) (string, error) { - defer self.lock.Unlock() - self.lock.Lock() - return self.deposit(amount) +func (cb *Chequebook) Deposit(amount *big.Int) (string, error) { + defer cb.lock.Unlock() + cb.lock.Lock() + return cb.deposit(amount) } // deposit deposits amount to the chequebook account. -// The caller must hold self.lock. -func (self *Chequebook) deposit(amount *big.Int) (string, error) { +// The caller must hold lock. +func (cb *Chequebook) deposit(amount *big.Int) (string, error) { // since the amount is variable here, we do not use sessions - depositTransactor := bind.NewKeyedTransactor(self.prvKey) + depositTransactor := bind.NewKeyedTransactor(cb.prvKey) depositTransactor.Value = amount - chbookRaw := &contract.ChequebookRaw{Contract: self.contract} + chbookRaw := &contract.ChequebookRaw{Contract: cb.contract} tx, err := chbookRaw.Transfer(depositTransactor) if err != nil { - self.log.Warn("Failed to fund chequebook", "amount", amount, "balance", self.balance, "target", self.buffer, "err", err) + cb.log.Warn("Failed to fund chequebook", "amount", amount, "balance", cb.balance, "target", cb.buffer, "err", err) return "", err } // assume that transaction is actually successful, we add the amount to balance right away - self.balance.Add(self.balance, amount) - self.log.Trace("Deposited funds to chequebook", "amount", amount, "balance", self.balance, "target", self.buffer) + cb.balance.Add(cb.balance, amount) + cb.log.Trace("Deposited funds to chequebook", "amount", amount, "balance", cb.balance, "target", cb.buffer) return tx.Hash().Hex(), nil } // AutoDeposit (re)sets interval time and amount which triggers sending funds to the // chequebook. Contract backend needs to be set if threshold is not less than buffer, then // deposit will be triggered on every new cheque issued. -func (self *Chequebook) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { - defer self.lock.Unlock() - self.lock.Lock() - self.threshold = threshold - self.buffer = buffer - self.autoDeposit(interval) +func (cb *Chequebook) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { + defer cb.lock.Unlock() + cb.lock.Lock() + cb.threshold = threshold + cb.buffer = buffer + cb.autoDeposit(interval) } // autoDeposit starts a goroutine that periodically sends funds to the chequebook // contract caller holds the lock the go routine terminates if Chequebook.quit is closed. -func (self *Chequebook) autoDeposit(interval time.Duration) { - if self.quit != nil { - close(self.quit) - self.quit = nil +func (cb *Chequebook) autoDeposit(interval time.Duration) { + if cb.quit != nil { + close(cb.quit) + cb.quit = nil } // if threshold >= balance autodeposit after every cheque issued - if interval == time.Duration(0) || self.threshold != nil && self.buffer != nil && self.threshold.Cmp(self.buffer) >= 0 { + if interval == time.Duration(0) || cb.threshold != nil && cb.buffer != nil && cb.threshold.Cmp(cb.buffer) >= 0 { return } ticker := time.NewTicker(interval) - self.quit = make(chan bool) - quit := self.quit + cb.quit = make(chan bool) + quit := cb.quit go func() { for { @@ -383,15 +382,15 @@ func (self *Chequebook) autoDeposit(interval time.Duration) { case <-quit: return case <-ticker.C: - self.lock.Lock() - if self.balance.Cmp(self.buffer) < 0 { - amount := new(big.Int).Sub(self.buffer, self.balance) - txhash, err := self.deposit(amount) + cb.lock.Lock() + if cb.balance.Cmp(cb.buffer) < 0 { + amount := new(big.Int).Sub(cb.buffer, cb.balance) + txhash, err := cb.deposit(amount) if err == nil { - self.txhash = txhash + cb.txhash = txhash } } - self.lock.Unlock() + cb.lock.Unlock() } } }() @@ -404,26 +403,26 @@ type Outbox struct { } // NewOutbox creates an outbox. -func NewOutbox(chbook *Chequebook, beneficiary common.Address) *Outbox { - return &Outbox{chbook, beneficiary} +func NewOutbox(cb *Chequebook, beneficiary common.Address) *Outbox { + return &Outbox{cb, beneficiary} } // Issue creates cheque. -func (self *Outbox) Issue(amount *big.Int) (swap.Promise, error) { - return self.chequeBook.Issue(self.beneficiary, amount) +func (o *Outbox) Issue(amount *big.Int) (swap.Promise, error) { + return o.chequeBook.Issue(o.beneficiary, amount) } // AutoDeposit enables auto-deposits on the underlying chequebook. -func (self *Outbox) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { - self.chequeBook.AutoDeposit(interval, threshold, buffer) +func (o *Outbox) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { + o.chequeBook.AutoDeposit(interval, threshold, buffer) } // Stop helps satisfy the swap.OutPayment interface. -func (self *Outbox) Stop() {} +func (o *Outbox) Stop() {} // String implements fmt.Stringer. -func (self *Outbox) String() string { - return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", self.chequeBook.Address().Hex(), self.beneficiary.Hex(), self.chequeBook.Balance()) +func (o *Outbox) String() string { + return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", o.chequeBook.Address().Hex(), o.beneficiary.Hex(), o.chequeBook.Balance()) } // Inbox can deposit, verify and cash cheques from a single contract to a single @@ -445,7 +444,7 @@ type Inbox struct { // NewInbox creates an Inbox. An Inboxes is not persisted, the cumulative sum is updated // from blockchain when first cheque is received. -func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address, signer *ecdsa.PublicKey, abigen bind.ContractBackend) (self *Inbox, err error) { +func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address, signer *ecdsa.PublicKey, abigen bind.ContractBackend) (*Inbox, error) { if signer == nil { return nil, fmt.Errorf("signer is null") } @@ -461,7 +460,7 @@ func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address } sender := transactOpts.From - self = &Inbox{ + inbox := &Inbox{ contract: contractAddr, beneficiary: beneficiary, sender: sender, @@ -470,59 +469,61 @@ func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address cashed: new(big.Int).Set(common.Big0), log: log.New("contract", contractAddr), } - self.log.Trace("New chequebook inbox initialized", "beneficiary", self.beneficiary, "signer", hexutil.Bytes(crypto.FromECDSAPub(signer))) - return + inbox.log.Trace("New chequebook inbox initialized", "beneficiary", inbox.beneficiary, "signer", hexutil.Bytes(crypto.FromECDSAPub(signer))) + return inbox, nil } -func (self *Inbox) String() string { - return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", self.contract.Hex(), self.beneficiary.Hex(), self.cheque.Amount) +func (i *Inbox) String() string { + return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", i.contract.Hex(), i.beneficiary.Hex(), i.cheque.Amount) } // Stop quits the autocash goroutine. -func (self *Inbox) Stop() { - defer self.lock.Unlock() - self.lock.Lock() - if self.quit != nil { - close(self.quit) - self.quit = nil +func (i *Inbox) Stop() { + defer i.lock.Unlock() + i.lock.Lock() + if i.quit != nil { + close(i.quit) + i.quit = nil } } // Cash attempts to cash the current cheque. -func (self *Inbox) Cash() (txhash string, err error) { - if self.cheque != nil { - txhash, err = self.cheque.Cash(self.session) - self.log.Trace("Cashing in chequebook cheque", "amount", self.cheque.Amount, "beneficiary", self.beneficiary) - self.cashed = self.cheque.Amount +func (i *Inbox) Cash() (string, error) { + if i.cheque == nil { + return "", nil } - return + txhash, err := i.cheque.Cash(i.session) + i.log.Trace("Cashing in chequebook cheque", "amount", i.cheque.Amount, "beneficiary", i.beneficiary) + i.cashed = i.cheque.Amount + + return txhash, err } // AutoCash (re)sets maximum time and amount which triggers cashing of the last uncashed // cheque if maxUncashed is set to 0, then autocash on receipt. -func (self *Inbox) AutoCash(cashInterval time.Duration, maxUncashed *big.Int) { - defer self.lock.Unlock() - self.lock.Lock() - self.maxUncashed = maxUncashed - self.autoCash(cashInterval) +func (i *Inbox) AutoCash(cashInterval time.Duration, maxUncashed *big.Int) { + defer i.lock.Unlock() + i.lock.Lock() + i.maxUncashed = maxUncashed + i.autoCash(cashInterval) } // autoCash starts a loop that periodically clears the last cheque // if the peer is trusted. Clearing period could be 24h or a week. -// The caller must hold self.lock. -func (self *Inbox) autoCash(cashInterval time.Duration) { - if self.quit != nil { - close(self.quit) - self.quit = nil +// The caller must hold lock. +func (i *Inbox) autoCash(cashInterval time.Duration) { + if i.quit != nil { + close(i.quit) + i.quit = nil } // if maxUncashed is set to 0, then autocash on receipt - if cashInterval == time.Duration(0) || self.maxUncashed != nil && self.maxUncashed.Sign() == 0 { + if cashInterval == time.Duration(0) || i.maxUncashed != nil && i.maxUncashed.Sign() == 0 { return } ticker := time.NewTicker(cashInterval) - self.quit = make(chan bool) - quit := self.quit + i.quit = make(chan bool) + quit := i.quit go func() { for { @@ -530,14 +531,14 @@ func (self *Inbox) autoCash(cashInterval time.Duration) { case <-quit: return case <-ticker.C: - self.lock.Lock() - if self.cheque != nil && self.cheque.Amount.Cmp(self.cashed) != 0 { - txhash, err := self.Cash() + i.lock.Lock() + if i.cheque != nil && i.cheque.Amount.Cmp(i.cashed) != 0 { + txhash, err := i.Cash() if err == nil { - self.txhash = txhash + i.txhash = txhash } } - self.lock.Unlock() + i.lock.Unlock() } } }() @@ -545,56 +546,56 @@ func (self *Inbox) autoCash(cashInterval time.Duration) { // Receive is called to deposit the latest cheque to the incoming Inbox. // The given promise must be a *Cheque. -func (self *Inbox) Receive(promise swap.Promise) (*big.Int, error) { +func (i *Inbox) Receive(promise swap.Promise) (*big.Int, error) { ch := promise.(*Cheque) - defer self.lock.Unlock() - self.lock.Lock() + defer i.lock.Unlock() + i.lock.Lock() var sum *big.Int - if self.cheque == nil { + if i.cheque == nil { // the sum is checked against the blockchain once a cheque is received - tally, err := self.session.Sent(self.beneficiary) + tally, err := i.session.Sent(i.beneficiary) if err != nil { return nil, fmt.Errorf("inbox: error calling backend to set amount: %v", err) } sum = tally } else { - sum = self.cheque.Amount + sum = i.cheque.Amount } - amount, err := ch.Verify(self.signer, self.contract, self.beneficiary, sum) + amount, err := ch.Verify(i.signer, i.contract, i.beneficiary, sum) var uncashed *big.Int if err == nil { - self.cheque = ch + i.cheque = ch - if self.maxUncashed != nil { - uncashed = new(big.Int).Sub(ch.Amount, self.cashed) - if self.maxUncashed.Cmp(uncashed) < 0 { - self.Cash() + if i.maxUncashed != nil { + uncashed = new(big.Int).Sub(ch.Amount, i.cashed) + if i.maxUncashed.Cmp(uncashed) < 0 { + i.Cash() } } - self.log.Trace("Received cheque in chequebook inbox", "amount", amount, "uncashed", uncashed) + i.log.Trace("Received cheque in chequebook inbox", "amount", amount, "uncashed", uncashed) } return amount, err } // Verify verifies cheque for signer, contract, beneficiary, amount, valid signature. -func (self *Cheque) Verify(signerKey *ecdsa.PublicKey, contract, beneficiary common.Address, sum *big.Int) (*big.Int, error) { - log.Trace("Verifying chequebook cheque", "cheque", self, "sum", sum) +func (ch *Cheque) Verify(signerKey *ecdsa.PublicKey, contract, beneficiary common.Address, sum *big.Int) (*big.Int, error) { + log.Trace("Verifying chequebook cheque", "cheque", ch, "sum", sum) if sum == nil { return nil, fmt.Errorf("invalid amount") } - if self.Beneficiary != beneficiary { - return nil, fmt.Errorf("beneficiary mismatch: %v != %v", self.Beneficiary.Hex(), beneficiary.Hex()) + if ch.Beneficiary != beneficiary { + return nil, fmt.Errorf("beneficiary mismatch: %v != %v", ch.Beneficiary.Hex(), beneficiary.Hex()) } - if self.Contract != contract { - return nil, fmt.Errorf("contract mismatch: %v != %v", self.Contract.Hex(), contract.Hex()) + if ch.Contract != contract { + return nil, fmt.Errorf("contract mismatch: %v != %v", ch.Contract.Hex(), contract.Hex()) } - amount := new(big.Int).Set(self.Amount) + amount := new(big.Int).Set(ch.Amount) if sum != nil { amount.Sub(amount, sum) if amount.Sign() <= 0 { @@ -602,7 +603,7 @@ func (self *Cheque) Verify(signerKey *ecdsa.PublicKey, contract, beneficiary com } } - pubKey, err := crypto.SigToPub(sigHash(self.Contract, beneficiary, self.Amount), self.Sig) + pubKey, err := crypto.SigToPub(sigHash(ch.Contract, beneficiary, ch.Amount), ch.Sig) if err != nil { return nil, fmt.Errorf("invalid signature: %v", err) } @@ -621,9 +622,9 @@ func sig2vrs(sig []byte) (v byte, r, s [32]byte) { } // Cash cashes the cheque by sending an Ethereum transaction. -func (self *Cheque) Cash(session *contract.ChequebookSession) (string, error) { - v, r, s := sig2vrs(self.Sig) - tx, err := session.Cash(self.Beneficiary, self.Amount, v, r, s) +func (ch *Cheque) Cash(session *contract.ChequebookSession) (string, error) { + v, r, s := sig2vrs(ch.Sig) + tx, err := session.Cash(ch.Beneficiary, ch.Amount, v, r, s) if err != nil { return "", err } @@ -632,7 +633,7 @@ func (self *Cheque) Cash(session *contract.ChequebookSession) (string, error) { // ValidateCode checks that the on-chain code at address matches the expected chequebook // contract code. This is used to detect suicided chequebooks. -func ValidateCode(ctx context.Context, b Backend, address common.Address) (ok bool, err error) { +func ValidateCode(ctx context.Context, b Backend, address common.Address) (bool, error) { code, err := b.CodeAt(ctx, address, nil) if err != nil { return false, err diff --git a/contracts/chequebook/contract/chequebook.go b/contracts/chequebook/contract/chequebook.go index e275ac9b8..3129b811c 100644 --- a/contracts/chequebook/contract/chequebook.go +++ b/contracts/chequebook/contract/chequebook.go @@ -205,22 +205,22 @@ func (_Chequebook *ChequebookCallerSession) Sent(arg0 common.Address) (*big.Int, // Cash is a paid mutator transaction binding the contract method 0xfbf788d6. // // Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns() -func (_Chequebook *ChequebookTransactor) Cash(opts *bind.TransactOpts, beneficiary common.Address, amount *big.Int, sig_v uint8, sig_r [32]byte, sig_s [32]byte) (*types.Transaction, error) { - return _Chequebook.contract.Transact(opts, "cash", beneficiary, amount, sig_v, sig_r, sig_s) +func (_Chequebook *ChequebookTransactor) Cash(opts *bind.TransactOpts, beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) { + return _Chequebook.contract.Transact(opts, "cash", beneficiary, amount, sigV, sigR, sigS) } // Cash is a paid mutator transaction binding the contract method 0xfbf788d6. // // Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns() -func (_Chequebook *ChequebookSession) Cash(beneficiary common.Address, amount *big.Int, sig_v uint8, sig_r [32]byte, sig_s [32]byte) (*types.Transaction, error) { - return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sig_v, sig_r, sig_s) +func (_Chequebook *ChequebookSession) Cash(beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) { + return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sigV, sigR, sigS) } // Cash is a paid mutator transaction binding the contract method 0xfbf788d6. // // Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns() -func (_Chequebook *ChequebookTransactorSession) Cash(beneficiary common.Address, amount *big.Int, sig_v uint8, sig_r [32]byte, sig_s [32]byte) (*types.Transaction, error) { - return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sig_v, sig_r, sig_s) +func (_Chequebook *ChequebookTransactorSession) Cash(beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) { + return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sigV, sigR, sigS) } // Kill is a paid mutator transaction binding the contract method 0x41c0e1b5. diff --git a/contracts/ens/contract/ens.go b/contracts/ens/contract/ens.go index cbf6cb05b..8827071af 100644 --- a/contracts/ens/contract/ens.go +++ b/contracts/ens/contract/ens.go @@ -227,10 +227,10 @@ func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error) { return _ENS.Contract.Resolver(&_ENS.CallOpts, node) } -// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// TTL is a free data retrieval call binding the contract method 0x16a25cbd. // // Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) { +func (_ENS *ENSCaller) TTL(opts *bind.CallOpts, node [32]byte) (uint64, error) { var ( ret0 = new(uint64) ) @@ -239,18 +239,18 @@ func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) { return *ret0, err } -// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// TTL is a free data retrieval call binding the contract method 0x16a25cbd. // // Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSSession) Ttl(node [32]byte) (uint64, error) { - return _ENS.Contract.Ttl(&_ENS.CallOpts, node) +func (_ENS *ENSSession) TTL(node [32]byte) (uint64, error) { + return _ENS.Contract.TTL(&_ENS.CallOpts, node) } -// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// TTL is a free data retrieval call binding the contract method 0x16a25cbd. // // Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSCallerSession) Ttl(node [32]byte) (uint64, error) { - return _ENS.Contract.Ttl(&_ENS.CallOpts, node) +func (_ENS *ENSCallerSession) TTL(node [32]byte) (uint64, error) { + return _ENS.Contract.TTL(&_ENS.CallOpts, node) } // SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. @@ -682,7 +682,7 @@ func (it *ENSNewTTLIterator) Close() error { // ENSNewTTL represents a NewTTL event raised by the ENS contract. type ENSNewTTL struct { Node [32]byte - Ttl uint64 + TTL uint64 Raw types.Log // Blockchain specific contextual infos } diff --git a/contracts/ens/ens.go b/contracts/ens/ens.go index b7448c471..b1841ab17 100644 --- a/contracts/ens/ens.go +++ b/contracts/ens/ens.go @@ -35,7 +35,7 @@ var ( TestNetAddress = common.HexToAddress("0x112234455c3a32fd11230c42e7bccd4a84e02010") ) -// swarm domain name registry and resolver +// ENS is the swarm domain name registry and resolver type ENS struct { *contract.ENSSession contractBackend bind.ContractBackend @@ -48,7 +48,6 @@ func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contra if err != nil { return nil, err } - return &ENS{ &contract.ENSSession{ Contract: ens, @@ -60,27 +59,24 @@ func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contra // DeployENS deploys an instance of the ENS nameservice, with a 'first-in, first-served' root registrar. func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (common.Address, *ENS, error) { - // Deploy the ENS registry. + // Deploy the ENS registry ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend) if err != nil { return ensAddr, nil, err } - ens, err := NewENS(transactOpts, ensAddr, contractBackend) if err != nil { return ensAddr, nil, err } - - // Deploy the registrar. + // Deploy the registrar regAddr, _, _, err := contract.DeployFIFSRegistrar(transactOpts, contractBackend, ensAddr, [32]byte{}) if err != nil { return ensAddr, nil, err } - // Set the registrar as owner of the ENS root. + // Set the registrar as owner of the ENS root if _, err = ens.SetOwner([32]byte{}, regAddr); err != nil { return ensAddr, nil, err } - return ensAddr, ens, nil } @@ -89,10 +85,9 @@ func ensParentNode(name string) (common.Hash, common.Hash) { label := crypto.Keccak256Hash([]byte(parts[0])) if len(parts) == 1 { return [32]byte{}, label - } else { - parentNode, parentLabel := ensParentNode(parts[1]) - return crypto.Keccak256Hash(parentNode[:], parentLabel[:]), label } + parentNode, parentLabel := ensParentNode(parts[1]) + return crypto.Keccak256Hash(parentNode[:], parentLabel[:]), label } func EnsNode(name string) common.Hash { @@ -100,111 +95,101 @@ func EnsNode(name string) common.Hash { return crypto.Keccak256Hash(parentNode[:], parentLabel[:]) } -func (self *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, error) { - resolverAddr, err := self.Resolver(node) +func (ens *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, error) { + resolverAddr, err := ens.Resolver(node) if err != nil { return nil, err } - - resolver, err := contract.NewPublicResolver(resolverAddr, self.contractBackend) + resolver, err := contract.NewPublicResolver(resolverAddr, ens.contractBackend) if err != nil { return nil, err } - return &contract.PublicResolverSession{ Contract: resolver, - TransactOpts: self.TransactOpts, + TransactOpts: ens.TransactOpts, }, nil } -func (self *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { - registrarAddr, err := self.Owner(node) +func (ens *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { + registrarAddr, err := ens.Owner(node) if err != nil { return nil, err } - - registrar, err := contract.NewFIFSRegistrar(registrarAddr, self.contractBackend) + registrar, err := contract.NewFIFSRegistrar(registrarAddr, ens.contractBackend) if err != nil { return nil, err } - return &contract.FIFSRegistrarSession{ Contract: registrar, - TransactOpts: self.TransactOpts, + TransactOpts: ens.TransactOpts, }, nil } // Resolve is a non-transactional call that returns the content hash associated with a name. -func (self *ENS) Resolve(name string) (common.Hash, error) { +func (ens *ENS) Resolve(name string) (common.Hash, error) { node := EnsNode(name) - resolver, err := self.getResolver(node) + resolver, err := ens.getResolver(node) if err != nil { return common.Hash{}, err } - ret, err := resolver.Content(node) if err != nil { return common.Hash{}, err } - return common.BytesToHash(ret[:]), nil } // Addr is a non-transactional call that returns the address associated with a name. -func (self *ENS) Addr(name string) (common.Address, error) { +func (ens *ENS) Addr(name string) (common.Address, error) { node := EnsNode(name) - resolver, err := self.getResolver(node) + resolver, err := ens.getResolver(node) if err != nil { return common.Address{}, err } - ret, err := resolver.Addr(node) if err != nil { return common.Address{}, err } - return common.BytesToAddress(ret[:]), nil } // SetAddress sets the address associated with a name. Only works if the caller // owns the name, and the associated resolver implements a `setAddress` function. -func (self *ENS) SetAddr(name string, addr common.Address) (*types.Transaction, error) { +func (ens *ENS) SetAddr(name string, addr common.Address) (*types.Transaction, error) { node := EnsNode(name) - resolver, err := self.getResolver(node) + resolver, err := ens.getResolver(node) if err != nil { return nil, err } - - opts := self.TransactOpts + opts := ens.TransactOpts opts.GasLimit = 200000 return resolver.Contract.SetAddr(&opts, node, addr) } // Register registers a new domain name for the caller, making them the owner of the new name. // Only works if the registrar for the parent domain implements the FIFS registrar protocol. -func (self *ENS) Register(name string) (*types.Transaction, error) { +func (ens *ENS) Register(name string) (*types.Transaction, error) { parentNode, label := ensParentNode(name) - registrar, err := self.getRegistrar(parentNode) + registrar, err := ens.getRegistrar(parentNode) if err != nil { return nil, err } - return registrar.Contract.Register(&self.TransactOpts, label, self.TransactOpts.From) + return registrar.Contract.Register(&ens.TransactOpts, label, ens.TransactOpts.From) } // SetContentHash sets the content hash associated with a name. Only works if the caller // owns the name, and the associated resolver implements a `setContent` function. -func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { +func (ens *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { node := EnsNode(name) - resolver, err := self.getResolver(node) + resolver, err := ens.getResolver(node) if err != nil { return nil, err } - - opts := self.TransactOpts + opts := ens.TransactOpts opts.GasLimit = 200000 return resolver.Contract.SetContent(&opts, node, hash) } diff --git a/swarm/swarm.go b/swarm/swarm.go index 9ece8bb66..8274a168d 100644 --- a/swarm/swarm.go +++ b/swarm/swarm.go @@ -491,7 +491,7 @@ func (self *Swarm) APIs() []rpc.API { { Namespace: "chequebook", Version: chequebook.Version, - Service: chequebook.NewApi(self.config.Swap.Chequebook), + Service: chequebook.NewAPI(self.config.Swap.Chequebook), Public: false, }, {