celo-blockchain

diff --git go-ethereum/accounts/external/backend.go celo/accounts/external/backend.go index 7cdd82f8e5c0046df549dcdede91b98f90457d83..c9127cc8b52a2efddadf31840a4269f3da9557a2 100644 --- go-ethereum/accounts/external/backend.go +++ celo/accounts/external/backend.go @@ -17,10 +17,12 @@ package external   import ( + "crypto/ecdsa" "fmt" "math/big" "sync"   + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" @@ -148,12 +150,12 @@ func (api *ExternalSigner) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { return accounts.Account{}, fmt.Errorf("operation not supported on external signers") }   -func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { - log.Error("operation SelfDerive not supported on external signers") +func (api *ExternalSigner) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, fmt.Errorf("operation not supported on external signers") }   -func (api *ExternalSigner) signHash(account accounts.Account, hash []byte) ([]byte, error) { - return []byte{}, fmt.Errorf("operation not supported on external signers") +func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { + log.Error("operation SelfDerive not supported on external signers") }   // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed @@ -166,11 +168,14 @@ &signAddress, // Need to use the pointer here, because of how MarshalJSON is defined hexutil.Encode(data)); err != nil { return nil, err } - // If V is on 27/28-form, convert to 0/1 for Clique - if mimeType == accounts.MimetypeClique && (res[64] == 27 || res[64] == 28) { - res[64] -= 27 // Transform V from 27/28 to 0/1 for Clique use - } return res, nil +} + +// SignHash is not implemented for the external signer +// +// DEPRECATED, use SignData in future releases. +func (api *ExternalSigner) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + panic("SignHash not implemented for the external signer") }   func (api *ExternalSigner) SignText(account accounts.Account, text []byte) ([]byte, error) { @@ -218,7 +223,7 @@ } switch tx.Type() { case types.LegacyTxType, types.AccessListTxType: args.GasPrice = (*hexutil.Big)(tx.GasPrice()) - case types.DynamicFeeTxType: + case types.DynamicFeeTxType, types.CeloDynamicFeeTxType, types.CeloDynamicFeeTxV2Type, types.CeloDenominatedTxType: args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap()) args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap()) default: @@ -254,6 +259,26 @@ return nil, fmt.Errorf("password-operations not supported on external signers") } func (api *ExternalSigner) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { return nil, fmt.Errorf("password-operations not supported on external signers") +} + +func (api *ExternalSigner) Decrypt(account accounts.Account, c, s1, s2 []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + return blscrypto.SerializedSignature{}, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + return nil, accounts.ErrNotSupported }   func (api *ExternalSigner) listAccounts() ([]common.Address, error) {

diff --git go-ethereum/accounts/keystore/wallet.go celo/accounts/keystore/wallet.go index ef13d80d9fcd44cea222d9b7435b64b4dbcd9ecf..07fa8b434d2aed940bd49b471701435ebf7b4785 100644 --- go-ethereum/accounts/keystore/wallet.go +++ celo/accounts/keystore/wallet.go @@ -17,12 +17,17 @@ package keystore   import ( + "crypto/ecdsa" "math/big" + + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls"   "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" )   // keystoreWallet implements the accounts.Wallet interface for the original @@ -69,12 +74,32 @@ func (w *keystoreWallet) Contains(account accounts.Account) bool { return account.Address == w.account.Address && (account.URL == (accounts.URL{}) || account.URL == w.account.URL) }   +// Decrypt decrypts an ECIES ciphertext. +func (w *keystoreWallet) Decrypt(account accounts.Account, c, s1, s2 []byte) ([]byte, error) { + if account.Address != w.account.Address { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + if account.URL != (accounts.URL{}) && account.URL != w.account.URL { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.Decrypt(account, c, s1, s2) +} + // Derive implements accounts.Wallet, but is a noop for plain wallets since there // is no notion of hierarchical account derivation for plain keystore accounts. func (w *keystoreWallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { return accounts.Account{}, accounts.ErrNotSupported }   +// ConfirmAddress implements accounts.Wallet, but is a noop for plain wallets since there +// is no notion of address confirmation for plain keystore accounts. +func (w *keystoreWallet) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, accounts.ErrNotSupported +} + // SelfDerive implements accounts.Wallet, but is a noop for plain wallets since // there is no notion of hierarchical account derivation for plain keystore accounts. func (w *keystoreWallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { @@ -87,21 +112,73 @@ // able to sign via our shared keystore backend). func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign return w.keystore.SignHash(account, hash) }   +func (w *keystoreWallet) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the public key + return w.keystore.GetPublicKey(account) +} + +func (w *keystoreWallet) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return blscrypto.SerializedSignature{}, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.SignBLS(account, msg, extraData, useComposite, cip22) +} + +func (w *keystoreWallet) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.GenerateProofOfPossession(account, address) +} + +func (w *keystoreWallet) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.GenerateProofOfPossessionBLS(account, address) +} + // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed. func (w *keystoreWallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) { return w.signHash(account, crypto.Keccak256(data)) }   +// SignHash implements accounts.Wallet, attempting to sign the given hash with +// the given account. If the wallet does not wrap this particular account, an +// error is returned to avoid account leakage (even though in theory we may be +// able to sign via our shared keystore backend). +// +// DEPRECATED, use SignData in future releases. +func (w *keystoreWallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + return w.signHash(account, hash) +} + // SignDataWithPassphrase signs keccak256(data). The mimetype parameter describes the type of data being signed. func (w *keystoreWallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign @@ -132,6 +209,7 @@ // be able to sign via our shared keystore backend). func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign @@ -143,6 +221,7 @@ // transaction with the given account using passphrase as extra authentication. func (w *keystoreWallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign

diff --git go-ethereum/accounts/keystore/keystore.go celo/accounts/keystore/keystore.go index 3f4b479583ca878e337028ca196fa97657a793b5..394262fbddf4e4f1618930b966757999009ce2dd 100644 --- go-ethereum/accounts/keystore/keystore.go +++ celo/accounts/keystore/keystore.go @@ -22,8 +22,10 @@ package keystore   import ( "crypto/ecdsa" + "crypto/elliptic" crand "crypto/rand" "errors" + "fmt" "math/big" "os" "path/filepath" @@ -32,11 +34,17 @@ "runtime" "sync" "time"   + //nolint:goimports + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" + "github.com/celo-org/celo-bls-go/bls" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/ecies" "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/log" )   var ( @@ -234,6 +242,21 @@ func (ks *KeyStore) Accounts() []accounts.Account { return ks.cache.accounts() }   +// Decrypt decrypts an ECIES ciphertext. +func (ks *KeyStore) Decrypt(a accounts.Account, c, s1, s2 []byte) ([]byte, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + // Import the ECDSA key as an ECIES key and decrypt the data. + eciesKey := ecies.ImportECDSA(unlockedKey.PrivateKey) + return eciesKey.Decrypt(c, s1, s2) +} + // Delete deletes the key matched by account if the passphrase is correct. // If the account contains no filename, the address must match a unique key. func (ks *KeyStore) Delete(a accounts.Account, passphrase string) error { @@ -273,6 +296,116 @@ // Sign the hash using plain ECDSA operations return crypto.Sign(hash, unlockedKey.PrivateKey) }   +func (ks *KeyStore) SignBLS(a accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return blscrypto.SerializedSignature{}, ErrLocked + } + + privateKeyBytes, err := blscrypto.ECDSAToBLS(unlockedKey.PrivateKey) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + + privateKey, err := bls.DeserializePrivateKey(privateKeyBytes) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + defer privateKey.Destroy() + + signature, err := privateKey.SignMessage(msg, extraData, useComposite, cip22) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + defer signature.Destroy() + signatureBytes, err := signature.Serialize() + if err != nil { + return blscrypto.SerializedSignature{}, err + } + + return blscrypto.SerializedSignatureFromBytes(signatureBytes) +} + +func (ks *KeyStore) GenerateProofOfPossession(a accounts.Account, address common.Address) ([]byte, []byte, error) { + publicKey, err := ks.GetPublicKey(a) + if err != nil { + return nil, nil, err + } + publicKeyBytes := crypto.FromECDSAPub(publicKey) + + hash := crypto.Keccak256(address.Bytes()) + log.Info("msg", "msg", hexutil.Encode(hash)) + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(hash), hash) + hash = crypto.Keccak256([]byte(msg)) + log.Info("hash", "hash", hexutil.Encode(hash)) + + signature, err := ks.SignHash(a, hash) + if err != nil { + return nil, nil, err + } + return publicKeyBytes, signature, nil +} + +func (ks *KeyStore) GenerateProofOfPossessionBLS(a accounts.Account, address common.Address) ([]byte, []byte, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, nil, ErrLocked + } + + privateKeyBytes, err := blscrypto.ECDSAToBLS(unlockedKey.PrivateKey) + if err != nil { + return nil, nil, err + } + + privateKey, err := bls.DeserializePrivateKey(privateKeyBytes) + if err != nil { + return nil, nil, err + } + defer privateKey.Destroy() + + signature, err := privateKey.SignPoP(address.Bytes()) + if err != nil { + return nil, nil, err + } + defer signature.Destroy() + signatureBytes, err := signature.Serialize() + if err != nil { + return nil, nil, err + } + + publicKey, err := privateKey.ToPublic() + if err != nil { + return nil, nil, err + } + defer publicKey.Destroy() + publicKeyBytes, err := publicKey.Serialize() + if err != nil { + return nil, nil, err + } + return publicKeyBytes, signatureBytes, nil +} + +// Retrieve the ECDSA public key for a given account. +func (ks *KeyStore) GetPublicKey(a accounts.Account) (*ecdsa.PublicKey, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + return &unlockedKey.PrivateKey.PublicKey, nil +} + // SignTx signs the given transaction with the requested account. func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Look up the key to sign with and abort if it cannot be found @@ -505,3 +638,28 @@ for i := range b { b[i] = 0 } } + +// ComputeECDHSharedSecret computes an ECDH shared secret between the given account's +// private key and the public key provided. The account has to be unlocked first. +// The public key format is a 65 byte array, with byte[0] == 4, 32 bytes for X, +// and 32 bytes for Y (encoded in base256). +func (ks *KeyStore) ComputeECDHSharedSecret(a accounts.Account, public []byte) ([]byte, error) { + curve := crypto.S256() + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + + var x, y *big.Int + x, y = elliptic.Unmarshal(curve, public) + if x == nil || y == nil { + return nil, errors.New("Could not unmarshal public key from bytes") + } + + shared, _ := crypto.S256().ScalarMult(x, y, unlockedKey.PrivateKey.D.Bytes()) + return shared.Bytes(), nil +}

diff --git go-ethereum/accounts/keystore/keystore_test.go celo/accounts/keystore/keystore_test.go index e91862b9c4e1a494ce7c7d3f2cb0d931885d7afb..3f4a47b109757f7d1fd7a58ce3210acaea0b02c6 100644 --- go-ethereum/accounts/keystore/keystore_test.go +++ celo/accounts/keystore/keystore_test.go @@ -17,6 +17,7 @@ package keystore   import ( + "encoding/hex" "io/ioutil" "math/rand" "os" @@ -84,6 +85,27 @@ if err := ks.Unlock(a1, ""); err != nil { t.Fatal(err) } if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err != nil { + t.Fatal(err) + } +} + +func TestComputeECDHSharedSecret(t *testing.T) { + keyHex := "044fb0a7e965176de5bbd615c5c9d5ca0927b74d914db881f7742362f2afda8a83b4e8e2cc87a98cdb5e2cf1c87b94a62ca9905de0e80676947166d4ae3d012691" + public := make([]byte, 65) + hex.Decode(public, []byte(keyHex)) + + dir, ks := tmpKeyStore(t, true) + defer os.RemoveAll(dir) + + pass := "" // not used but required by API + a1, err := ks.NewAccount(pass) + if err != nil { + t.Fatal(err) + } + if err := ks.Unlock(a1, ""); err != nil { + t.Fatal(err) + } + if _, err := ks.ComputeECDHSharedSecret(accounts.Account{Address: a1.Address}, public); err != nil { t.Fatal(err) } }

diff --git go-ethereum/accounts/keystore/key.go celo/accounts/keystore/key.go index c728765ddfe7fa8bf3f5b00c00c4783385e5aceb..f994af3e09af0a637e7a38d3f554d68c03294ece 100644 --- go-ethereum/accounts/keystore/key.go +++ celo/accounts/keystore/key.go @@ -66,6 +66,7 @@ }   type encryptedKeyJSONV3 struct { Address string `json:"address"` + BLSPublicKey string `json:"blspublickey"` Crypto CryptoJSON `json:"crypto"` Id string `json:"id"` Version int `json:"version"`

diff --git go-ethereum/accounts/keystore/passphrase.go celo/accounts/keystore/passphrase.go index db00ecf61584d629803ae9d5c033ca227cc2a013..77b863aa87f1c211bf03ad6fd12e95d3c5e6bd2b 100644 --- go-ethereum/accounts/keystore/passphrase.go +++ celo/accounts/keystore/passphrase.go @@ -38,6 +38,8 @@ "io/ioutil" "os" "path/filepath"   + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" + "github.com/celo-org/celo-bls-go/bls" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -185,12 +187,32 @@ // EncryptKey encrypts a key using the specified scrypt parameters into a json // blob that can be decrypted later on. func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error) { keyBytes := math.PaddedBigBytes(key.PrivateKey.D, 32) + blsPrivateKeyBytes, err := blscrypto.ECDSAToBLS(key.PrivateKey) + if err != nil { + return nil, err + } + privateKey, err := bls.DeserializePrivateKey(blsPrivateKeyBytes) + if err != nil { + return nil, err + } + defer privateKey.Destroy() + publicKey, err := privateKey.ToPublic() + if err != nil { + return nil, err + } + defer publicKey.Destroy() + publicKeyBytes, err := publicKey.Serialize() + if err != nil { + return nil, err + } + cryptoStruct, err := EncryptDataV3(keyBytes, []byte(auth), scryptN, scryptP) if err != nil { return nil, err } encryptedKeyJSONV3 := encryptedKeyJSONV3{ hex.EncodeToString(key.Address[:]), + hex.EncodeToString(publicKeyBytes), cryptoStruct, key.Id.String(), version,

diff --git go-ethereum/accounts/hd.go celo/accounts/hd.go index 23abd67c8dddd391e8e82b975eae706276b112cf..a7d631fcb149cd0b88b980a4b3f538f8532f0f6b 100644 --- go-ethereum/accounts/hd.go +++ celo/accounts/hd.go @@ -26,19 +26,19 @@ "strings" )   // DefaultRootDerivationPath is the root path to which custom derivation endpoints -// are appended. As such, the first account will be at m/44'/60'/0'/0, the second -// at m/44'/60'/0'/1, etc. -var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0} +// are appended. As such, the first account will be at m/44'/52752'/0'/0, the second +// at m/44'/52752'/0'/1, etc. +var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}   // DefaultBaseDerivationPath is the base path from which custom derivation endpoints -// are incremented. As such, the first account will be at m/44'/60'/0'/0/0, the second -// at m/44'/60'/0'/0/1, etc. -var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0} +// are incremented. As such, the first account will be at m/44'/52752'/0'/0/0, the second +// at m/44'/52752'/0'/0/1, etc. +var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}   // LegacyLedgerBaseDerivationPath is the legacy base path from which custom derivation -// endpoints are incremented. As such, the first account will be at m/44'/60'/0'/0, the -// second at m/44'/60'/0'/1, etc. -var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0} +// endpoints are incremented. As such, the first account will be at m/44'/52752'/0'/0, the +// second at m/44'/52752'/0'/1, etc. +var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}   // DerivationPath represents the computer friendly version of a hierarchical // deterministic wallet account derivaion path. @@ -46,14 +46,14 @@ // // The BIP-32 spec https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki // defines derivation paths to be of the form: // -// m / purpose' / coin_type' / account' / change / address_index +// m / purpose' / coin_type' / account' / change / address_index // // The BIP-44 spec https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki // defines that the `purpose` be 44' (or 0x8000002C) for crypto currencies, and // SLIP-44 https://github.com/satoshilabs/slips/blob/master/slip-0044.md assigns -// the `coin_type` 60' (or 0x8000003C) to Ethereum. +// the `coin_type` 52752' (or 0x8000CE10) to Celo. // -// The root path for Ethereum is m/44'/60'/0'/0 according to the specification +// The root path for Celo is m/44'/52752'/0'/0 according to the specification // from https://github.com/ethereum/EIPs/issues/84, albeit it's not set in stone // yet whether accounts should increment the last component or the children of // that. We will go with the simpler approach of incrementing the last component.

diff --git go-ethereum/accounts/hd_test.go celo/accounts/hd_test.go index 48f67eefb3001bb8a8b58ff29e3aec35e68ff06e..d7928fba3333499dbc7f2ad7ca161554b60c8dcd 100644 --- go-ethereum/accounts/hd_test.go +++ celo/accounts/hd_test.go @@ -30,43 +30,43 @@ input string output DerivationPath }{ // Plain absolute derivation paths - {"m/44'/60'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/44'/60'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}}, - {"m/44'/60'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, - {"m/44'/60'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}}, - {"m/2147483692/2147483708/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/2147483692/2147483708/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/44'/52752'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/44'/52752'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 128}}, + {"m/44'/52752'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/44'/52752'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 128}}, + {"m/2147483692/2147536400/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/2147483692/2147536400/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}},   // Plain relative derivation paths - {"0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}}, - {"128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}}, - {"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, - {"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}}, - {"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}}, + {"128", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 128}}, + {"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 128}}, + {"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}},   // Hexadecimal absolute derivation paths - {"m/0x2C'/0x3c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/0x2C'/0x3c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}}, - {"m/0x2C'/0x3c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, - {"m/0x2C'/0x3c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}}, - {"m/0x8000002C/0x8000003c/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/0x8000002C/0x8000003c/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/0x2C'/0xce10'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/0x2C'/0xce10'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 128}}, + {"m/0x2C'/0xce10'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/0x2C'/0xce10'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 128}}, + {"m/0x8000002C/0x8000ce10/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/0x8000002C/0x8000ce10/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}},   // Hexadecimal relative derivation paths - {"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}}, - {"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}}, - {"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, - {"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}}, - {"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}}, + {"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 128}}, + {"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 128}}, + {"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}},   // Weird inputs just to ensure they work - {" m / 44 '\n/\n 60 \n\n\t' /\n0 ' /\t\t 0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, + {" m / 44 '\n/\n 52752 \n\n\t' /\n0 ' /\t\t 0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}},   // Invalid derivation paths {"", nil}, // Empty relative derivation path {"m", nil}, // Empty absolute derivation path {"m/", nil}, // Missing last derivation component - {"/44'/60'/0'/0", nil}, // Absolute path without m prefix, might be user error + {"/44'/52752'/0'/0", nil}, // Absolute path without m prefix, might be user error {"m/2147483648'", nil}, // Overflows 32 bit integer {"m/-1'", nil}, // Cannot contain negative number } @@ -91,28 +91,28 @@ func TestHdPathIteration(t *testing.T) { testDerive(t, DefaultIterator(DefaultBaseDerivationPath), []string{ - "m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1", - "m/44'/60'/0'/0/2", "m/44'/60'/0'/0/3", - "m/44'/60'/0'/0/4", "m/44'/60'/0'/0/5", - "m/44'/60'/0'/0/6", "m/44'/60'/0'/0/7", - "m/44'/60'/0'/0/8", "m/44'/60'/0'/0/9", + "m/44'/52752'/0'/0/0", "m/44'/52752'/0'/0/1", + "m/44'/52752'/0'/0/2", "m/44'/52752'/0'/0/3", + "m/44'/52752'/0'/0/4", "m/44'/52752'/0'/0/5", + "m/44'/52752'/0'/0/6", "m/44'/52752'/0'/0/7", + "m/44'/52752'/0'/0/8", "m/44'/52752'/0'/0/9", })   testDerive(t, DefaultIterator(LegacyLedgerBaseDerivationPath), []string{ - "m/44'/60'/0'/0", "m/44'/60'/0'/1", - "m/44'/60'/0'/2", "m/44'/60'/0'/3", - "m/44'/60'/0'/4", "m/44'/60'/0'/5", - "m/44'/60'/0'/6", "m/44'/60'/0'/7", - "m/44'/60'/0'/8", "m/44'/60'/0'/9", + "m/44'/52752'/0'/0", "m/44'/52752'/0'/1", + "m/44'/52752'/0'/2", "m/44'/52752'/0'/3", + "m/44'/52752'/0'/4", "m/44'/52752'/0'/5", + "m/44'/52752'/0'/6", "m/44'/52752'/0'/7", + "m/44'/52752'/0'/8", "m/44'/52752'/0'/9", })   testDerive(t, LedgerLiveIterator(DefaultBaseDerivationPath), []string{ - "m/44'/60'/0'/0/0", "m/44'/60'/1'/0/0", - "m/44'/60'/2'/0/0", "m/44'/60'/3'/0/0", - "m/44'/60'/4'/0/0", "m/44'/60'/5'/0/0", - "m/44'/60'/6'/0/0", "m/44'/60'/7'/0/0", - "m/44'/60'/8'/0/0", "m/44'/60'/9'/0/0", + "m/44'/52752'/0'/0/0", "m/44'/52752'/1'/0/0", + "m/44'/52752'/2'/0/0", "m/44'/52752'/3'/0/0", + "m/44'/52752'/4'/0/0", "m/44'/52752'/5'/0/0", + "m/44'/52752'/6'/0/0", "m/44'/52752'/7'/0/0", + "m/44'/52752'/8'/0/0", "m/44'/52752'/9'/0/0", }) }

diff --git go-ethereum/accounts/usbwallet/wallet.go celo/accounts/usbwallet/wallet.go index 86a9390a4694f83866d0272091977b1ec3b4b8f1..edc369eeda7231ac25e5d0e7aa56da12137ada41 100644 --- go-ethereum/accounts/usbwallet/wallet.go +++ celo/accounts/usbwallet/wallet.go @@ -19,11 +19,14 @@ package usbwallet   import ( "context" + "crypto/ecdsa" "fmt" "io" "math/big" "sync" "time" + + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls"   "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" @@ -53,6 +56,9 @@ // Open initializes access to a wallet instance. The passphrase parameter may // or may not be used by the implementation of a particular wallet instance. Open(device io.ReadWriter, passphrase string) error   + // ConfirmAddress shows the address of the given path on the wallet's display. + ConfirmAddress(path accounts.DerivationPath) (common.Address, error) + // Close releases any resources held by an open wallet instance. Close() error   @@ -67,6 +73,10 @@ // SignTx sends the transaction to the USB device and waits for the user to confirm // or deny the transaction. SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) + + // SignPersonalMessage sends the message to the USB device and waits for the user to confirm + // or deny the message. + SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error)   SignTypedMessage(path accounts.DerivationPath, messageHash []byte, domainHash []byte) ([]byte, error) } @@ -451,6 +461,10 @@ _, exists := w.paths[account.Address] return exists }   +func (w *wallet) Decrypt(a accounts.Account, c, s1, s2 []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported +} + // Derive implements accounts.Wallet, deriving a new account at the specific // derivation path. If pin is set to true, the account will be added to the list // of tracked accounts. @@ -491,6 +505,29 @@ } return account, nil }   +// ConfirmAddress implements accounts.Wallet, showing the address on the device. +func (w *wallet) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + // Try to derive the actual account and update its URL if successful + w.stateLock.RLock() // Avoid device disappearing during derivation + + if w.device == nil { + w.stateLock.RUnlock() + return common.Address{}, accounts.ErrWalletClosed + } + <-w.commsLock // Avoid concurrent hardware access + address, err := w.driver.ConfirmAddress(path) + w.commsLock <- struct{}{} + + w.stateLock.RUnlock() + + // If an error occurred or no pinning was requested, return + if err != nil { + return common.Address{}, err + } + + return address, nil +} + // SelfDerive sets a base account derivation path from which the wallet attempts // to discover non zero accounts and automatically add them to list of tracked // accounts. @@ -524,6 +561,62 @@ func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { return nil, accounts.ErrNotSupported }   +func (w *wallet) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + return nil, accounts.ErrNotSupported +} + +func (w *wallet) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + return blscrypto.SerializedSignature{}, accounts.ErrNotSupported +} + +func (w *wallet) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + hash := crypto.Keccak256(address.Bytes()) + return w.signText(account, hash) +} + +func (w *wallet) signText(account accounts.Account, text []byte) ([]byte, []byte, error) { + w.stateLock.RLock() // Comms have own mutex, this is for the state fields + defer w.stateLock.RUnlock() + + // If the wallet is closed, abort + if w.device == nil { + return nil, nil, accounts.ErrWalletClosed + } + // Make sure the requested account is contained within + path, ok := w.paths[account.Address] + if !ok { + return nil, nil, accounts.ErrUnknownAccount + } + // All infos gathered and metadata checks out, request signing + <-w.commsLock + defer func() { w.commsLock <- struct{}{} }() + + // Ensure the device isn't screwed with while user confirmation is pending + // TODO(karalabe): remove if hotplug lands on Windows + w.hub.commsLock.Lock() + w.hub.commsPend++ + w.hub.commsLock.Unlock() + + defer func() { + w.hub.commsLock.Lock() + w.hub.commsPend-- + w.hub.commsLock.Unlock() + }() + // Sign the message and verify the sender to avoid hardware fault surprises + sender, pubkey, signed, err := w.driver.SignPersonalMessage(path, text) + if err != nil { + return nil, nil, err + } + if sender != account.Address { + return nil, nil, fmt.Errorf("signer mismatch: expected %s, got %s", account.Address.Hex(), sender.Hex()) + } + return pubkey, signed, nil +} + +func (w *wallet) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {   @@ -568,6 +661,16 @@ } return signature, nil }   +// SignHash implements accounts.Wallet, attempting to sign the given hash with +// the given account. If the wallet does not wrap this particular account, an +// error is returned to avoid account leakage (even though in theory we may be +// able to sign via our shared keystore backend). +// +// DEPRECATED, use SignData in future releases. +func (w *wallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + return w.signHash(account, hash) +} + // SignDataWithPassphrase implements accounts.Wallet, attempting to sign the given // data with the given account using passphrase as extra authentication. // Since USB wallets don't rely on passphrases, these are silently ignored. @@ -576,7 +679,8 @@ return w.SignData(account, mimeType, data) }   func (w *wallet) SignText(account accounts.Account, text []byte) ([]byte, error) { - return w.signHash(account, accounts.TextHash(text)) + _, signature, err := w.signText(account, text) + return signature, err }   // SignTx implements accounts.Wallet. It sends the transaction over to the Ledger @@ -629,7 +733,7 @@ // SignHashWithPassphrase implements accounts.Wallet, however signing arbitrary // data is not supported for Ledger wallets, so this method will always return // an error. func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) { - return w.SignText(account, accounts.TextHash(text)) + return w.SignText(account, text) }   // SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given

diff --git go-ethereum/accounts/usbwallet/ledger.go celo/accounts/usbwallet/ledger.go index c2caa39ad6a13cff12e8a65f77cccdb12bc34e6b..2997c95dcbaa3a23d8b8a60e4fd9df8f85181d1c 100644 --- go-ethereum/accounts/usbwallet/ledger.go +++ celo/accounts/usbwallet/ledger.go @@ -21,6 +21,7 @@ package usbwallet   import ( + "crypto/sha256" "encoding/binary" "encoding/hex" "errors" @@ -29,6 +30,7 @@ "io" "math/big"   "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/accounts/usbwallet/ledger" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" @@ -49,16 +51,26 @@ // specific opcodes. The same parameter values may be reused between opcodes. type ledgerParam2 byte   const ( - ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Ethereum address for a given BIP 32 path - ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs an Ethereum transaction after having the user validate the parameters + ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Celo address for a given BIP 32 path + ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs a Celo transaction after having the user validate the parameters ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration - ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs an Ethereum message following the EIP 712 specification + ledgerOpSignMessage ledgerOpcode = 0x08 // Signs a Celo message after having the user validate the parameters + ledgerOpProvideERC20 ledgerOpcode = 0x0A // Provides ERC20 information for tokens + + /* TODO: add functionality to the Ledger's Celo app + ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs a Celo message following the EIP 712 specification + */   ledgerP1DirectlyFetchAddress ledgerParam1 = 0x00 // Return address directly from the wallet + ledgerP1ShowFetchAddress ledgerParam1 = 0x01 // Return address from the wallet after showing it + /* TODO: add functionality to the Ledger's Celo app ledgerP1InitTypedMessageData ledgerParam1 = 0x00 // First chunk of Typed Message data + */ ledgerP1InitTransactionData ledgerParam1 = 0x00 // First transaction data block for signing ledgerP1ContTransactionData ledgerParam1 = 0x80 // Subsequent transaction data block for signing ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address + + statusCodeOK = 0x9000 )   // errLedgerReplyInvalidHeader is the error message returned by a Ledger data exchange @@ -69,6 +81,10 @@ // errLedgerInvalidVersionReply is the error message returned by a Ledger version retrieval // when a response does arrive, but it does not contain the expected data. var errLedgerInvalidVersionReply = errors.New("ledger: invalid version reply") + +// errLedgerBadStatusCode is the error message returned by any Ledger command +// when a response arrives with a bad status code. +var errLedgerBadStatusCode = errors.New("ledger: bad status code")   // ledgerDriver implements the communication with a Ledger hardware wallet. type ledgerDriver struct { @@ -77,6 +93,7 @@ version [3]byte // Current version of the Ledger firmware (zero if app is offline) browser bool // Flag whether the Ledger is in browser mode (reply channel mismatch) failure error // Any failure that would make the device unusable log log.Logger // Contextual logger to tag the ledger with its id + tokens *ledger.Tokens // Tokens list }   // newLedgerDriver creates a new instance of a Ledger USB protocol driver. @@ -93,15 +110,15 @@ if w.failure != nil { return fmt.Sprintf("Failed: %v", w.failure), w.failure } if w.browser { - return "Ethereum app in browser mode", w.failure + return "Celo app in browser mode", w.failure } if w.offline() { - return "Ethereum app offline", w.failure + return "Celo app offline", w.failure } - return fmt.Sprintf("Ethereum app v%d.%d.%d online", w.version[0], w.version[1], w.version[2]), w.failure + return fmt.Sprintf("Celo app v%d.%d.%d online", w.version[0], w.version[1], w.version[2]), w.failure }   -// offline returns whether the wallet and the Ethereum app is offline or not. +// offline returns whether the wallet and the Celo app is offline or not. // // The method assumes that the state lock is held! func (w *ledgerDriver) offline() bool { @@ -114,21 +131,40 @@ // parameter is silently discarded. func (w *ledgerDriver) Open(device io.ReadWriter, passphrase string) error { w.device, w.failure = device, nil   - _, err := w.ledgerDerive(accounts.DefaultBaseDerivationPath) + _, err := w.ledgerDerive(accounts.DefaultBaseDerivationPath, false) if err != nil { - // Ethereum app is not running or in browser mode, nothing more to do, return + // Celo app is not running or in browser mode, nothing more to do, return if err == errLedgerReplyInvalidHeader { w.browser = true } return nil } - // Try to resolve the Ethereum app's version, will fail prior to v1.0.2 + + // Try to resolve the Celo app's version if w.version, err = w.ledgerVersion(); err != nil { - w.version = [3]byte{1, 0, 0} // Assume worst case, can't verify if v1.0.0 or v1.0.1 + w.version = [3]byte{1, 0, 0} // Assume worst case } + + /* + This is an example of how to enforce version numbers for features + + // Ensure the wallet is capable of signing the given transaction + if chainID != nil && w.version[0] <= 1 && w.version[1] == 0 && w.version[2] <= 2 { + return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2]) + } + */ + if w.tokens, err = ledger.LoadTokens(ledger.TokensBlob); err != nil { + return err + } + return nil }   +// ConfirmAddress implements usbwallet.driver, showing the address on the device. +func (w *ledgerDriver) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return w.ledgerDerive(path, true) +} + // Close implements usbwallet.driver, cleaning up and metadata maintained within // the Ledger driver. func (w *ledgerDriver) Close() error { @@ -147,47 +183,62 @@ return nil }   // Derive implements usbwallet.driver, sending a derivation request to the Ledger -// and returning the Ethereum address located on that derivation path. +// and returning the Celo address located on that derivation path. func (w *ledgerDriver) Derive(path accounts.DerivationPath) (common.Address, error) { - return w.ledgerDerive(path) + return w.ledgerDerive(path, false) }   // SignTx implements usbwallet.driver, sending the transaction to the Ledger and // waiting for the user to confirm or deny the transaction. // -// Note, if the version of the Ethereum application running on the Ledger wallet is +// Note, if the version of the Celo application running on the Ledger wallet is // too old to sign EIP-155 transactions, but such is requested nonetheless, an error // will be returned opposed to silently signing in Homestead mode. func (w *ledgerDriver) SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) { - // If the Ethereum app doesn't run, abort + // If the Celo app doesn't run, abort if w.offline() { return common.Address{}, nil, accounts.ErrWalletClosed - } - // Ensure the wallet is capable of signing the given transaction - if chainID != nil && w.version[0] <= 1 && w.version[1] <= 0 && w.version[2] <= 2 { - //lint:ignore ST1005 brand name displayed on the console - return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2]) } // All infos gathered and metadata checks out, request signing return w.ledgerSign(path, tx, chainID) }   +// SignPersonalMessage implements usbwallet.driver, sending the message to the Ledger and +// waiting for the user to confirm or deny the message. +func (w *ledgerDriver) SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error) { + // If the Celo app doesn't run, abort + if w.offline() { + return common.Address{}, nil, nil, accounts.ErrWalletClosed + } + + // All infos gathered and metadata checks out, request signing + return w.ledgerSignData(path, message) +} + +/* + TODO: add functionality to the Ledger's Celo app + // SignTypedMessage implements usbwallet.driver, sending the message to the Ledger and // waiting for the user to sign or deny the transaction. // // Note: this was introduced in the ledger 1.5.0 firmware -func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) { - // If the Ethereum app doesn't run, abort - if w.offline() { - return nil, accounts.ErrWalletClosed - } - // Ensure the wallet is capable of signing the given transaction - if w.version[0] < 1 && w.version[1] < 5 { - //lint:ignore ST1005 brand name displayed on the console - return nil, fmt.Errorf("Ledger version >= 1.5.0 required for EIP-712 signing (found version v%d.%d.%d)", w.version[0], w.version[1], w.version[2]) + + func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) { + // If the Ethereum app doesn't run, abort + if w.offline() { + return nil, accounts.ErrWalletClosed + } + // Ensure the wallet is capable of signing the given transaction + if w.version[0] < 1 && w.version[1] < 5 { + //lint:ignore ST1005 brand name displayed on the console + return nil, fmt.Errorf("Ledger version >= 1.5.0 required for EIP-712 signing (found version v%d.%d.%d)", w.version[0], w.version[1], w.version[2]) + } + // All infos gathered and metadata checks out, request signing + return w.ledgerSignTypedMessage(path, domainHash, messageHash) } - // All infos gathered and metadata checks out, request signing - return w.ledgerSignTypedMessage(path, domainHash, messageHash) +*/ +func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported }   // ledgerVersion retrieves the current version of the Ethereum wallet app running @@ -195,18 +246,18 @@ // on the Ledger wallet. // // The version retrieval protocol is defined as follows: // -// CLA | INS | P1 | P2 | Lc | Le -// ----+-----+----+----+----+--- -// E0 | 06 | 00 | 00 | 00 | 04 +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+----+--- +// E0 | 06 | 00 | 00 | 00 | 04 // // With no input data, and the output data being: // -// Description | Length -// ---------------------------------------------------+-------- -// Flags 01: arbitrary data signature enabled by user | 1 byte -// Application major version | 1 byte -// Application minor version | 1 byte -// Application patch version | 1 byte +// Description | Length +// ---------------------------------------------------+-------- +// Flags 01: arbitrary data signature enabled by user | 1 byte +// Application major version | 1 byte +// Application minor version | 1 byte +// Application patch version | 1 byte func (w *ledgerDriver) ledgerVersion() ([3]byte, error) { // Send the request and wait for the response reply, err := w.ledgerExchange(ledgerOpGetConfiguration, 0, 0, nil) @@ -222,38 +273,38 @@ copy(version[:], reply[1:]) return version, nil }   -// ledgerDerive retrieves the currently active Ethereum address from a Ledger +// ledgerDerive retrieves the currently active Celo address from a Ledger // wallet at the specified derivation path. // // The address derivation protocol is defined as follows: // -// CLA | INS | P1 | P2 | Lc | Le -// ----+-----+----+----+-----+--- -// E0 | 02 | 00 return address -// 01 display address and confirm before returning -// | 00: do not return the chain code -// | 01: return the chain code -// | var | 00 +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 02 | 00 return address +// 01 display address and confirm before returning +// | 00: do not return the chain code +// | 01: return the chain code +// | var | 00 // // Where the input data is: // -// Description | Length -// -------------------------------------------------+-------- -// Number of BIP 32 derivations to perform (max 10) | 1 byte -// First derivation index (big endian) | 4 bytes -// ... | 4 bytes -// Last derivation index (big endian) | 4 bytes +// Description | Length +// -------------------------------------------------+-------- +// Number of BIP 32 derivations to perform (max 10) | 1 byte +// First derivation index (big endian) | 4 bytes +// ... | 4 bytes +// Last derivation index (big endian) | 4 bytes // // And the output data is: // -// Description | Length -// ------------------------+------------------- -// Public Key length | 1 byte -// Uncompressed Public Key | arbitrary -// Ethereum address length | 1 byte -// Ethereum address | 40 bytes hex ascii -// Chain code if requested | 32 bytes -func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, error) { +// Description | Length +// ------------------------+------------------- +// Public Key length | 1 byte +// Uncompressed Public Key | arbitrary +// Celo address length | 1 byte +// Celo address | 40 bytes hex ascii +// Chain code if requested | 32 bytes +func (w *ledgerDriver) ledgerDerive(derivationPath []uint32, showOnWallet bool) (common.Address, error) { // Flatten the derivation path into the Ledger request path := make([]byte, 1+4*len(derivationPath)) path[0] = byte(len(derivationPath)) @@ -261,7 +312,11 @@ for i, component := range derivationPath { binary.BigEndian.PutUint32(path[1+4*i:], component) } // Send the request and wait for the response - reply, err := w.ledgerExchange(ledgerOpRetrieveAddress, ledgerP1DirectlyFetchAddress, ledgerP2DiscardAddressChainCode, path) + p1 := ledgerP1DirectlyFetchAddress + if showOnWallet { + p1 = ledgerP1ShowFetchAddress + } + reply, err := w.ledgerExchange(ledgerOpRetrieveAddress, p1, ledgerP2DiscardAddressChainCode, path) if err != nil { return common.Address{}, err } @@ -271,13 +326,13 @@ return common.Address{}, errors.New("reply lacks public key entry") } reply = reply[1+int(reply[0]):]   - // Extract the Ethereum hex address string + // Extract the Celo hex address string if len(reply) < 1 || len(reply) < 1+int(reply[0]) { return common.Address{}, errors.New("reply lacks address entry") } hexstr := reply[1 : 1+int(reply[0])]   - // Decode the hex sting into an Ethereum address and return + // Decode the hex sting into an Celo address and return var address common.Address if _, err = hex.Decode(address[:], hexstr); err != nil { return common.Address{}, err @@ -290,35 +345,35 @@ // to confirm or deny the transaction. // // The transaction signing protocol is defined as follows: // -// CLA | INS | P1 | P2 | Lc | Le -// ----+-----+----+----+-----+--- -// E0 | 04 | 00: first transaction data block -// 80: subsequent transaction data block -// | 00 | variable | variable +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 04 | 00: first transaction data block +// 80: subsequent transaction data block +// | 00 | variable | variable // // Where the input for the first transaction block (first 255 bytes) is: // -// Description | Length -// -------------------------------------------------+---------- -// Number of BIP 32 derivations to perform (max 10) | 1 byte -// First derivation index (big endian) | 4 bytes -// ... | 4 bytes -// Last derivation index (big endian) | 4 bytes -// RLP transaction chunk | arbitrary +// Description | Length +// -------------------------------------------------+---------- +// Number of BIP 32 derivations to perform (max 10) | 1 byte +// First derivation index (big endian) | 4 bytes +// ... | 4 bytes +// Last derivation index (big endian) | 4 bytes +// RLP transaction chunk | arbitrary // // And the input for subsequent transaction blocks (first 255 bytes) are: // -// Description | Length -// ----------------------+---------- -// RLP transaction chunk | arbitrary +// Description | Length +// ----------------------+---------- +// RLP transaction chunk | arbitrary // // And the output data is: // -// Description | Length -// ------------+--------- -// signature V | 1 byte -// signature R | 32 bytes -// signature S | 32 bytes +// Description | Length +// ------------+--------- +// signature V | 1 byte +// signature R | 32 bytes +// signature S | 32 bytes func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) { // Flatten the derivation path into the Ledger request path := make([]byte, 1+4*len(derivationPath)) @@ -326,17 +381,34 @@ path[0] = byte(len(derivationPath)) for i, component := range derivationPath { binary.BigEndian.PutUint32(path[1+4*i:], component) } - // Create the transaction RLP based on whether legacy or EIP155 signing was requested + var ( txrlp []byte err error ) + + if ledger.IsERC20Transfer(tx.Data()) { + err = w.ledgerProvideERC20(*tx.To(), chainID) + if err != nil && err != ledger.ErrCouldNotFindToken { + return common.Address{}, nil, err + } + + if tx.FeeCurrency() != nil { + err = w.ledgerProvideERC20(*tx.FeeCurrency(), chainID) + if err != nil && err != ledger.ErrCouldNotFindToken { + return common.Address{}, nil, err + } + } + } + + // Create the transaction RLP based on whether legacy or EIP155 signing was requested if chainID == nil { - if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil { + //if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil { + if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.FeeCurrency(), tx.GatewayFeeRecipient(), tx.GatewayFee(), tx.To(), tx.Value(), tx.Data()}); err != nil { return common.Address{}, nil, err } } else { - if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil { + if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.FeeCurrency(), tx.GatewayFeeRecipient(), tx.GatewayFee(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil { return common.Address{}, nil, err } } @@ -362,7 +434,7 @@ // Shift the payload and ensure subsequent chunks are marked as such payload = payload[chunk:] op = ledgerP1ContTransactionData } - // Extract the Ethereum signature and do a sanity validation + // Extract the Celo signature and do a sanity validation if len(reply) != crypto.SignatureLength { return common.Address{}, nil, errors.New("reply lacks signature") } @@ -387,35 +459,161 @@ } return sender, signed, nil }   +// ledgerProvideERC20 provides ERC20 information for tokens. +// +// The data protocol is defined as follows: +// +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 04 | 00: first data block +// 80: subsequent data block +// | 00 | variable | variable +// +// Where the input for the data block is: +// +// Description | Length +// -------------------------------------------------+---------- +// Ticker length | 1 byte +// Ticker | abitrary (< 10 bytes) +// Address | 20 bytes +// Decimals | 4 bytes +// ChainID | 4 bytes +// Signature | arbitrary +// +// And the output data is nothing. +func (w *ledgerDriver) ledgerProvideERC20(contractAddress common.Address, chainID *big.Int) error { + token, err := w.tokens.ByContractAddressAndChainID(contractAddress, chainID) + if err != nil { + return err + } + + _, err = w.ledgerExchange(ledgerOpProvideERC20, 0, 0, token.Data) + if err != nil { + return err + } + + return nil +} + +// ledgerSignData sends the message to the Ledger wallet, and waits for the user +// to confirm or deny the message. +// +// The message signing protocol is defined as follows: +// +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 08 | 00: first message data block +// 80: subsequent message data block +// | 00 | variable | variable +// +// Where the input for the first message block (first 255 bytes) is: +// +// Description | Length +// -------------------------------------------------+---------- +// Number of BIP 32 derivations to perform (max 10) | 1 byte +// First derivation index (big endian) | 4 bytes +// ... | 4 bytes +// Last derivation index (big endian) | 4 bytes +// data chunk | arbitrary +// +// And the input for subsequent message blocks (first 255 bytes) are: +// +// Description | Length +// ----------------------+---------- +// data chunk | arbitrary +// +// And the output data is: +// +// Description | Length +// ------------+--------- +// signature V | 1 byte +// signature R | 32 bytes +// signature S | 32 bytes +func (w *ledgerDriver) ledgerSignData(derivationPath []uint32, data []byte) (common.Address, []byte, []byte, error) { + hashMessage := sha256.Sum256(data) + w.log.Info("Signing message on Ledger with hash", "message", hex.EncodeToString(data), "hash", hex.EncodeToString(hashMessage[:])) + + // Flatten the derivation path into the Ledger request + path := make([]byte, 1+4*len(derivationPath)) + path[0] = byte(len(derivationPath)) + for i, component := range derivationPath { + binary.BigEndian.PutUint32(path[1+4*i:], component) + } + + dataLen := make([]byte, 4) + binary.BigEndian.PutUint32(dataLen, uint32(len(data))) + payload := append(path, dataLen...) + payload = append(payload, data...) + + // Send the request and wait for the response + var ( + op = ledgerP1InitTransactionData + reply []byte + err error + ) + for len(payload) > 0 { + // Calculate the size of the next data chunk + chunk := 255 + if chunk > len(payload) { + chunk = len(payload) + } + // Send the chunk over, ensuring it's processed correctly + reply, err = w.ledgerExchange(ledgerOpSignMessage, op, 0, payload[:chunk]) + if err != nil { + return common.Address{}, nil, nil, err + } + // Shift the payload and ensure subsequent chunks are marked as such + payload = payload[chunk:] + op = ledgerP1ContTransactionData + } + // Extract the Celo signature and do a sanity validation + if len(reply) != crypto.SignatureLength { + return common.Address{}, nil, nil, errors.New("reply lacks signature") + } + signature := append(reply[1:], reply[0]) + + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data) + hash := crypto.Keccak256([]byte(msg)) + hashFixedLength := common.Hash{} + copy(hashFixedLength[:], hash) + + signer := new(types.HomesteadSigner) + addr, pubkey, err := signer.SenderData(hashFixedLength, signature) + if err != nil { + return common.Address{}, nil, nil, err + } + + return addr, pubkey, signature, nil +} + +/* TODO: add functionality to the Ledger's Celo app // ledgerSignTypedMessage sends the transaction to the Ledger wallet, and waits for the user // to confirm or deny the transaction. // // The signing protocol is defined as follows: // -// CLA | INS | P1 | P2 | Lc | Le -// ----+-----+----+-----------------------------+-----+--- -// E0 | 0C | 00 | implementation version : 00 | variable | variable +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+-----------------------------+-----+--- +// E0 | 0C | 00 | implementation version : 00 | variable | variable // // Where the input is: // -// Description | Length -// -------------------------------------------------+---------- -// Number of BIP 32 derivations to perform (max 10) | 1 byte -// First derivation index (big endian) | 4 bytes -// ... | 4 bytes -// Last derivation index (big endian) | 4 bytes -// domain hash | 32 bytes -// message hash | 32 bytes -// -// +// Description | Length +// -------------------------------------------------+---------- +// Number of BIP 32 derivations to perform (max 10) | 1 byte +// First derivation index (big endian) | 4 bytes +// ... | 4 bytes +// Last derivation index (big endian) | 4 bytes +// domain hash | 32 bytes +// message hash | 32 bytes // // And the output data is: // -// Description | Length -// ------------+--------- -// signature V | 1 byte -// signature R | 32 bytes -// signature S | 32 bytes +// Description | Length +// ------------+--------- +// signature V | 1 byte +// signature R | 32 bytes +// signature S | 32 bytes func (w *ledgerDriver) ledgerSignTypedMessage(derivationPath []uint32, domainHash []byte, messageHash []byte) ([]byte, error) { // Flatten the derivation path into the Ledger request path := make([]byte, 1+4*len(derivationPath)) @@ -448,18 +646,19 @@ } signature := append(reply[1:], reply[0]) return signature, nil } +*/   // ledgerExchange performs a data exchange with the Ledger wallet, sending it a // message and retrieving the response. // // The common transport header is defined as follows: // -// Description | Length -// --------------------------------------+---------- -// Communication channel ID (big endian) | 2 bytes -// Command tag | 1 byte -// Packet sequence index (big endian) | 2 bytes -// Payload | arbitrary +// Description | Length +// --------------------------------------+---------- +// Communication channel ID (big endian) | 2 bytes +// Command tag | 1 byte +// Packet sequence index (big endian) | 2 bytes +// Payload | arbitrary // // The Communication channel ID allows commands multiplexing over the same // physical link. It is not used for the time being, and should be set to 0101 @@ -473,15 +672,15 @@ // The first fragment index is 0x00. // // APDU Command payloads are encoded as follows: // -// Description | Length -// ----------------------------------- -// APDU length (big endian) | 2 bytes -// APDU CLA | 1 byte -// APDU INS | 1 byte -// APDU P1 | 1 byte -// APDU P2 | 1 byte -// APDU length | 1 byte -// Optional APDU data | arbitrary +// Description | Length +// ----------------------------------- +// APDU length (big endian) | 2 bytes +// APDU CLA | 1 byte +// APDU INS | 1 byte +// APDU P1 | 1 byte +// APDU P2 | 1 byte +// APDU length | 1 byte +// Optional APDU data | arbitrary func (w *ledgerDriver) ledgerExchange(opcode ledgerOpcode, p1 ledgerParam1, p2 ledgerParam2, data []byte) ([]byte, error) { // Construct the message payload, possibly split into multiple chunks apdu := make([]byte, 2, 7+len(data)) @@ -543,6 +742,12 @@ } else { reply = append(reply, payload[:left]...) break } + } + + statusCodeBytes := reply[len(reply)-2:] + statusCode := int(binary.BigEndian.Uint16(statusCodeBytes)) + if statusCode != statusCodeOK { + return nil, errLedgerBadStatusCode } return reply[:len(reply)-2], nil }

diff --git go-ethereum/accounts/usbwallet/trezor.go celo/accounts/usbwallet/trezor.go index a0f971f875e5256523dc3528fee0733f5e21788a..b0f01cc0ce33617993efa3942deda67e4658bc9d 100644 --- go-ethereum/accounts/usbwallet/trezor.go +++ celo/accounts/usbwallet/trezor.go @@ -84,14 +84,14 @@ }   // Open implements usbwallet.driver, attempting to initialize the connection to // the Trezor hardware wallet. Initializing the Trezor is a two or three phase operation: -// * The first phase is to initialize the connection and read the wallet's +// - The first phase is to initialize the connection and read the wallet's // features. This phase is invoked if the provided passphrase is empty. The // device will display the pinpad as a result and will return an appropriate // error to notify the user that a second open phase is needed. -// * The second phase is to unlock access to the Trezor, which is done by the +// - The second phase is to unlock access to the Trezor, which is done by the // user actually providing a passphrase mapping a keyboard keypad to the pin // number of the user (shuffled according to the pinpad displayed). -// * If needed the device will ask for passphrase which will require calling +// - If needed the device will ask for passphrase which will require calling // open again with the actual passphrase (3rd phase) func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error { w.device, w.failure = device, nil @@ -153,6 +153,11 @@ return nil }   +// ConfirmAddress implements usbwallet.driver, showing the address on the device. +func (w *trezorDriver) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, accounts.ErrNotSupported +} + // Close implements usbwallet.driver, cleaning up and metadata maintained within // the Trezor driver. func (w *trezorDriver) Close() error { @@ -183,6 +188,12 @@ if w.device == nil { return common.Address{}, nil, accounts.ErrWalletClosed } return w.trezorSign(path, tx, chainID) +} + +// SignPersonalMessage implements usbwallet.driver, sending the message to the Trezor and +// waiting for the user to confirm or deny the message. +func (w *trezorDriver) SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error) { + return common.Address{}, nil, nil, accounts.ErrNotSupported }   func (w *trezorDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {

diff --git go-ethereum/accounts/usbwallet/trezor/messages-ethereum.pb.go celo/accounts/usbwallet/trezor/messages-ethereum.pb.go index 400701b8297f7c8b41de03c48f88c341f915695c..0aecd49eacd3788c8a38251a5fe34eb871b36e0b 100644 --- go-ethereum/accounts/usbwallet/trezor/messages-ethereum.pb.go +++ celo/accounts/usbwallet/trezor/messages-ethereum.pb.go @@ -21,7 +21,7 @@ // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package   -//* +// * // Request: Ask device for public key corresponding to address_n path // @start // @next EthereumPublicKey @@ -73,7 +73,7 @@ } return false }   -//* +// * // Response: Contains public key derived from device private seed // @end type EthereumPublicKey struct { @@ -123,7 +123,7 @@ } return "" }   -//* +// * // Request: Ask device for Ethereum address corresponding to address_n path // @start // @next EthereumAddress @@ -175,7 +175,7 @@ } return false }   -//* +// * // Response: Contains an Ethereum address derived from device private seed // @end type EthereumAddress struct { @@ -225,7 +225,7 @@ } return "" }   -//* +// * // Request: Ask device to sign transaction // All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing. // Note: the first at most 1024 bytes of data MUST be transmitted as part of this message. @@ -351,7 +351,7 @@ } return 0 }   -//* +// * // Response: Device asks for more data from transaction payload, or returns the signature. // If data_length is set, device awaits that many more bytes of payload. // Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present. @@ -420,7 +420,7 @@ } return nil }   -//* +// * // Request: Transaction payload data. // @next EthereumTxRequest type EthereumTxAck struct { @@ -462,7 +462,7 @@ } return nil }   -//* +// * // Request: Ask device to sign message // @start // @next EthereumMessageSignature @@ -514,7 +514,7 @@ } return nil }   -//* +// * // Response: Signed message // @end type EthereumMessageSignature struct { @@ -572,7 +572,7 @@ } return "" }   -//* +// * // Request: Ask device to verify message // @start // @next Success

diff --git go-ethereum/accounts/usbwallet/trezor/messages.pb.go celo/accounts/usbwallet/trezor/messages.pb.go index 7db46322b74cbd4b11b16e287960b3354933eb43..2f4033dd037d07f98ceb63418d644053d51b4a1b 100644 --- go-ethereum/accounts/usbwallet/trezor/messages.pb.go +++ celo/accounts/usbwallet/trezor/messages.pb.go @@ -22,7 +22,7 @@ // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package   -//* +// * // Mapping between TREZOR wire identifier (uint) and a protobuf message type MessageType int32

diff --git go-ethereum/accounts/usbwallet/trezor/messages-management.pb.go celo/accounts/usbwallet/trezor/messages-management.pb.go index a7f81f02bbe20f230619557e3b58646e75681619..dcb7947ea3c8181401c60380a14432aa3cd5fcc8 100644 --- go-ethereum/accounts/usbwallet/trezor/messages-management.pb.go +++ celo/accounts/usbwallet/trezor/messages-management.pb.go @@ -21,7 +21,7 @@ // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package   -//* +// * // Structure representing passphrase source type ApplySettings_PassphraseSourceType int32   @@ -66,7 +66,7 @@ func (ApplySettings_PassphraseSourceType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_0c720c20d27aa029, []int{4, 0} }   -//* +// * // Type of recovery procedure. These should be used as bitmask, e.g., // `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix` // listing every method supported by the host computer. @@ -114,7 +114,7 @@ func (RecoveryDevice_RecoveryDeviceType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_0c720c20d27aa029, []int{17, 0} }   -//* +// * // Type of Recovery Word request type WordRequest_WordRequestType int32   @@ -159,7 +159,7 @@ func (WordRequest_WordRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_0c720c20d27aa029, []int{18, 0} }   -//* +// * // Request: Reset device to default state and ask for device details // @start // @next Features @@ -210,7 +210,7 @@ } return false }   -//* +// * // Request: Ask for device details (no device reset) // @start // @next Features @@ -245,7 +245,7 @@ }   var xxx_messageInfo_GetFeatures proto.InternalMessageInfo   -//* +// * // Response: Reports various information about the device // @end type Features struct { @@ -495,7 +495,7 @@ } return false }   -//* +// * // Request: clear session (removes cached PIN, passphrase, etc). // @start // @next Success @@ -530,7 +530,7 @@ }   var xxx_messageInfo_ClearSession proto.InternalMessageInfo   -//* +// * // Request: change language and/or label of the device // @start // @next Success @@ -622,7 +622,7 @@ } return 0 }   -//* +// * // Request: set flags of the device // @start // @next Success @@ -666,7 +666,7 @@ } return 0 }   -//* +// * // Request: Starts workflow for setting/changing/removing the PIN // @start // @next Success @@ -710,7 +710,7 @@ } return false }   -//* +// * // Request: Test if the device is alive, device sends back the message in Success response // @start // @next Success @@ -777,7 +777,7 @@ } return false }   -//* +// * // Request: Abort last operation that required user interaction // @start // @next Failure @@ -812,7 +812,7 @@ }   var xxx_messageInfo_Cancel proto.InternalMessageInfo   -//* +// * // Request: Request a sample of random data generated by hardware RNG. May be used for testing. // @start // @next Entropy @@ -856,7 +856,7 @@ } return 0 }   -//* +// * // Response: Reply with random data generated by internal RNG // @end type Entropy struct { @@ -898,7 +898,7 @@ } return nil }   -//* +// * // Request: Request device to wipe all sensitive data and settings // @start // @next Success @@ -934,7 +934,7 @@ }   var xxx_messageInfo_WipeDevice proto.InternalMessageInfo   -//* +// * // Request: Load seed and related internal settings from the computer // @start // @next Success @@ -1036,7 +1036,7 @@ } return 0 }   -//* +// * // Request: Ask device to do initialization involving user interaction // @start // @next EntropyRequest @@ -1147,7 +1147,7 @@ } return false }   -//* +// * // Request: Perform backup of the device seed if not backed up using ResetDevice // @start // @next Success @@ -1182,7 +1182,7 @@ }   var xxx_messageInfo_BackupDevice proto.InternalMessageInfo   -//* +// * // Response: Ask for additional entropy from host computer // @next EntropyAck type EntropyRequest struct { @@ -1216,7 +1216,7 @@ }   var xxx_messageInfo_EntropyRequest proto.InternalMessageInfo   -//* +// * // Request: Provide additional entropy for seed generation function // @next Success type EntropyAck struct { @@ -1258,7 +1258,7 @@ } return nil }   -//* +// * // Request: Start recovery workflow asking user for specific words of mnemonic // Used to recovery device safely even on untrusted computer. // @start @@ -1369,7 +1369,7 @@ } return false }   -//* +// * // Response: Device is waiting for user to enter word of the mnemonic // Its position is shown only on device's internal display. // @next WordAck @@ -1412,7 +1412,7 @@ } return WordRequest_WordRequestType_Plain }   -//* +// * // Request: Computer replies with word from the mnemonic // @next WordRequest // @next Success @@ -1456,7 +1456,7 @@ } return "" }   -//* +// * // Request: Set U2F counter // @start // @next Success

diff --git go-ethereum/accounts/usbwallet/ledger/tokens_data.go celo/accounts/usbwallet/ledger/tokens_data.go new file mode 100644 index 0000000000000000000000000000000000000000..0d83eadb63c18d2fc6603278bed97d426d47f9a0 --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens_data.go @@ -0,0 +1,3 @@ +package ledger + +const TokensBlob = "AAAAaARDRUxPRx7ON1DaI3+TuOM5xTaYm4l4pDgAAAASAACk7DBFAiEA5rECRg94+fCoIvoG9/5qWh62zl2C6Y+aFuuZrFe4CtcCIEJbRrkL3gqwT/Jj+7L3neazgpVCCTZZ3HX9JXXg5vleAAAAaARjVVNEdl3oFoRYYedaJfyhIrtomLixKCoAAAASAACk7DBFAiEApwQFHNBKXp+V2jq8BMD2y/5AwC9bhPQ2H4hT/vMl/B4CIFalOVtBFGREUKMU/F5vDlJLeQrTn6GQeDertpB2FpMvAAAAaARjRVVS2HY8uidqNzjm3oW0s79f3tbWynMAAAASAACk7DBFAiEAh2UeP1+SI2Ed5SiAjpJF6MkMrVa94gUwjJztyBlzhWMCIHfaOrEsxdxAGx+P+hxuSNO4zcw6KRLfJkkuic1V/CrHAAAAagZiIENFTE/dyb5X9VP+dXUtYWBrlMvX4CZO+AAAABIAAPNwMEUCIQCi62KsBfuNcfX0MriiRZ7a5DKERhtIz7sZ1SqBT7ruhgIgVrfmavyWzxzDW4AQeHn++A4qPjB1pQKoHvNXo8Hf1SMAAABpBmIgY1VTRGJJKmRKWI/ZBCcL7QatUrmr/qGuAAAAEgAA83AwRAIgGDYx4oB/gkYUqLeXqvEZXx9nOxVHzTe2ajyd2wnehxgCICQBe/rBPcXiaQJj3pdoXxroct/hV6r3G2G7y79EOEAPAAAAaQZiIGNFVVL57OMBJHrSziGJSUGDCiRw9Od0ygAAABIAAPNwMEQCIEdcFWP+HxEUoF1sCGVd34QGS0hL5cVUdrWdqVm3bYTgAiBCMA+Rg3Ubc3xla/35wzZesPlbeSMEPcr4uqL+8PeydwAAAGoGYSBDRUxP8ZSv31CwPmm9fQV8GqnhDJlU5MkAAAASAACu8zBFAiEAk/o0FBus2/QCrunFGEyoneQIRaMRC+y5L6Dvar8MU/kCIByJt2ziRhDG3AAbyXBIuJfZQujSHFcSJL3xF0xIlcPdAAAAaQZhIGNVU0SHQGn6HrFtRNYi8uDKJe6hcjabwQAAABIAAK7zMEQCIClrH2xgE3WMbD+hgQ7t5SiAcVG5WiUZ655voqCszKEoAiA/cO8UVgNY891MNJ5yeDk8w47WO0E1DQecrK71LR8g8gAAAGoGYSBjRVVSEMiSpuxDpT5F0LkWtLfTg7G3jA8AAAASAACu8zBFAiEAgpktbB1ZxyAwMJwKTSbZ30n8zgRuW0twbXoZxlsUAswCIHek4l4CIbjVMG2HVr0Ml9/8kA4F9dr69JBMaoSUkdKl" // #nosec

diff --git go-ethereum/accounts/usbwallet/ledger/tokens_test.go celo/accounts/usbwallet/ledger/tokens_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c8d9eb2a9863b075faf68b470c566a8cc17c315f --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens_test.go @@ -0,0 +1,29 @@ +package ledger + +import ( + "encoding/hex" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" +) + +func TestCUSD(t *testing.T) { + tokens, _ := LoadTokens(TokensBlob) + cUSDAddress, _ := hex.DecodeString("765de816845861e75a25fca122bb6898b8b1282a") + var cUSDAddressFixedSize common.Address + copy(cUSDAddressFixedSize[:], cUSDAddress) + cUSDInfo, err := tokens.ByContractAddressAndChainID(cUSDAddressFixedSize, big.NewInt(42220)) + if err != nil { + t.Fatal("Could not find cUSD") + } + if cUSDInfo.Ticker != "cUSD" { + t.Fatalf("Ticker incorrect: %s", cUSDInfo.Ticker) + } + if cUSDInfo.Decimals != 18 { + t.Fatalf("Decimals incorrect: %d", cUSDInfo.Decimals) + } + if cUSDInfo.ChainID != 42220 { + t.Fatalf("ChainID incorrect: %d", cUSDInfo.ChainID) + } +}

diff --git go-ethereum/accounts/usbwallet/trezor/messages-common.pb.go celo/accounts/usbwallet/trezor/messages-common.pb.go index 3bff0c365df93d76b92e7d255695c3f993a3c9d3..6db70f93cb477bc5acb40de3afea4a84a9880f8b 100644 --- go-ethereum/accounts/usbwallet/trezor/messages-common.pb.go +++ celo/accounts/usbwallet/trezor/messages-common.pb.go @@ -94,7 +94,7 @@ func (Failure_FailureType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_aaf30d059fdbc38d, []int{1, 0} }   -//* +// * // Type of button request type ButtonRequest_ButtonRequestType int32   @@ -175,7 +175,7 @@ func (ButtonRequest_ButtonRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_aaf30d059fdbc38d, []int{2, 0} }   -//* +// * // Type of PIN request type PinMatrixRequest_PinMatrixRequestType int32   @@ -220,7 +220,7 @@ func (PinMatrixRequest_PinMatrixRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_aaf30d059fdbc38d, []int{4, 0} }   -//* +// * // Response: Success of the previous request // @end type Success struct { @@ -262,7 +262,7 @@ } return "" }   -//* +// * // Response: Failure of the previous request // @end type Failure struct { @@ -312,7 +312,7 @@ } return "" }   -//* +// * // Response: Device is waiting for HW button press. // @auxstart // @next ButtonAck @@ -363,7 +363,7 @@ } return "" }   -//* +// * // Request: Computer agrees to wait for HW button press // @auxend type ButtonAck struct { @@ -397,7 +397,7 @@ }   var xxx_messageInfo_ButtonAck proto.InternalMessageInfo   -//* +// * // Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme // @auxstart // @next PinMatrixAck @@ -440,7 +440,7 @@ } return PinMatrixRequest_PinMatrixRequestType_Current }   -//* +// * // Request: Computer responds with encoded PIN // @auxend type PinMatrixAck struct { @@ -482,7 +482,7 @@ } return "" }   -//* +// * // Response: Device awaits encryption passphrase // @auxstart // @next PassphraseAck @@ -525,7 +525,7 @@ } return false }   -//* +// * // Request: Send passphrase back // @next PassphraseStateRequest type PassphraseAck struct { @@ -575,7 +575,7 @@ } return nil }   -//* +// * // Response: Device awaits passphrase state // @next PassphraseStateAck type PassphraseStateRequest struct { @@ -617,7 +617,7 @@ } return nil }   -//* +// * // Request: Send passphrase state back // @auxend type PassphraseStateAck struct { @@ -651,7 +651,7 @@ }   var xxx_messageInfo_PassphraseStateAck proto.InternalMessageInfo   -//* +// * // Structure representing BIP32 (hierarchical deterministic) node // Used for imports of private key into the device and exporting public key out of device // @embed

diff --git go-ethereum/accounts/usbwallet/ledger/tokens.go celo/accounts/usbwallet/ledger/tokens.go new file mode 100644 index 0000000000000000000000000000000000000000..e62d4aedd30d1c4a665209475f5f4e9c4f419f1d --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens.go @@ -0,0 +1,101 @@ +package ledger + +import ( + "bytes" + "encoding/base64" + "encoding/binary" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +var ErrCouldNotFindToken = errors.New("could not find token") +var ErrNotAnERC20Transfer = errors.New("not an ERC20 transfer") + +type Token struct { + Ticker string + Address common.Address + Decimals uint32 + ChainID uint32 + Signature []byte + Data []byte +} + +type Tokens struct { + tokens []Token +} + +func LoadTokens(blob string) (*Tokens, error) { + buf, err := base64.StdEncoding.DecodeString(blob) + if err != nil { + return nil, err + } + + tokens := make([]Token, 0) + + i := 0 + for i < len(buf) { + length := int(binary.BigEndian.Uint32(buf[i : i+4])) + i += 4 + + item := buf[i : i+length] + offset := 0 + + tickerLength := int(item[offset]) + offset += 1 + + ticker := string(item[offset : offset+tickerLength]) + offset += tickerLength + + var address common.Address + copy(address[:], item[offset:offset+20]) + offset += 20 + + decimals := binary.BigEndian.Uint32(item[offset : offset+4]) + offset += 4 + + chainID := binary.BigEndian.Uint32(item[offset : offset+4]) + offset += 4 + + signature := item[offset:length] + + tokens = append(tokens, Token{ + Ticker: ticker, + Address: address, + Decimals: decimals, + ChainID: chainID, + Signature: signature, + Data: item, + }) + + i += length + } + + return &Tokens{ + tokens, + }, nil +} + +func (t *Tokens) ByContractAddressAndChainID(address common.Address, chainID *big.Int) (*Token, error) { + for _, token := range t.tokens { + if token.Address == address && uint64(token.ChainID) == chainID.Uint64() { + return &token, nil + } + } + + return nil, ErrCouldNotFindToken +} + +func IsERC20Transfer(data []byte) bool { + if len(data) < 4 { + return false + } + + // 0xa9059cbb is the ERC20 transfer function signature + if !bytes.Equal(data[:4], []byte{0xa9, 0x05, 0x9c, 0xbb}) { + return false + } + + return true +}

diff --git go-ethereum/accounts/abi/unpack.go celo/accounts/abi/unpack.go index 53609777d84987c48d71acd438ec1b8bbc5dbe74..86b6b10db30bd603edca1ec41c4b2ac8b0efe21d 100644 --- go-ethereum/accounts/abi/unpack.go +++ celo/accounts/abi/unpack.go @@ -188,6 +188,12 @@ } return retval.Interface(), nil }   +// ToGoType parses the output bytes and recursively assigns the value of these bytes +// into a go type with accordance with the ABI spec. +func ToGoType(index int, t Type, output []byte) (interface{}, error) { + return toGoType(index, t, output) +} + // toGoType parses the output bytes and recursively assigns the value of these bytes // into a go type with accordance with the ABI spec. func toGoType(index int, t Type, output []byte) (interface{}, error) {

diff --git go-ethereum/accounts/abi/abi.go celo/accounts/abi/abi.go index efcaf3c30c5b445b6159a36213df44d937717dff..7f65daf1ffbb84cb8c73f82779ba9117b9189f16 100644 --- go-ethereum/accounts/abi/abi.go +++ celo/accounts/abi/abi.go @@ -42,6 +42,8 @@ Fallback Method // Note it's also used to represent legacy fallback before v0.6.0 Receive Method }   +var ErrEmptyArguments = errors.New("abi: attempting to unmarshall an empty string while arguments are expected") + // JSON returns a parsed ABI interface and error if it failed. func JSON(reader io.Reader) (ABI, error) { dec := json.NewDecoder(reader)

diff --git go-ethereum/accounts/abi/abi_test.go celo/accounts/abi/abi_test.go index b700f0d4b4160bbfaae958cb2486a60161cdb88a..fb36af0c2e192bcbee9cf64d871513b7fb1c90c2 100644 --- go-ethereum/accounts/abi/abi_test.go +++ celo/accounts/abi/abi_test.go @@ -165,8 +165,9 @@ }   // TestConstructor tests a constructor function. // The test is based on the following contract: -// contract TestConstructor { -// constructor(uint256 a, uint256 b) public{} +// +// contract TestConstructor { +// constructor(uint256 a, uint256 b) public{} // } func TestConstructor(t *testing.T) { json := `[{ "inputs": [{"internalType": "uint256","name": "a","type": "uint256" },{ "internalType": "uint256","name": "b","type": "uint256"}],"stateMutability": "nonpayable","type": "constructor"}]` @@ -710,16 +711,19 @@ } }   // TestUnpackEvent is based on this contract: -// contract T { -// event received(address sender, uint amount, bytes memo); -// event receivedAddr(address sender); -// function receive(bytes memo) external payable { -// received(msg.sender, msg.value, memo); -// receivedAddr(msg.sender); -// } -// } +// +// contract T { +// event received(address sender, uint amount, bytes memo); +// event receivedAddr(address sender); +// function receive(bytes memo) external payable { +// received(msg.sender, msg.value, memo); +// receivedAddr(msg.sender); +// } +// } +// // When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt: -// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} +// +// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} func TestUnpackEvent(t *testing.T) { const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]` abi, err := JSON(strings.NewReader(abiJSON)) @@ -1066,8 +1070,9 @@ // TestDoubleDuplicateEventNames checks that if send0 already exists, there won't be a name // conflict and that the second send event will be renamed send1. // The test runs the abi of the following contract. -// contract DuplicateEvent { -// event send(uint256 a); +// +// contract DuplicateEvent { +// event send(uint256 a); // event send0(); // event send(); // } @@ -1094,7 +1099,8 @@ // TestUnnamedEventParam checks that an event with unnamed parameters is // correctly handled. // The test runs the abi of the following contract. -// contract TestEvent { +// +// contract TestEvent { // event send(uint256, uint256); // } func TestUnnamedEventParam(t *testing.T) {

diff --git go-ethereum/accounts/abi/reflect.go celo/accounts/abi/reflect.go index 54ab9a8b51d32cbb2bf895ffba9d058e41c54aef..72c6d5d91a9445dd6ae1dae4226ec63f66b6f4ac 100644 --- go-ethereum/accounts/abi/reflect.go +++ celo/accounts/abi/reflect.go @@ -25,16 +25,19 @@ "strings" )   // ConvertType converts an interface of a runtime type into a interface of the -// given type -// e.g. turn -// var fields []reflect.StructField -// fields = append(fields, reflect.StructField{ -// Name: "X", -// Type: reflect.TypeOf(new(big.Int)), -// Tag: reflect.StructTag("json:\"" + "x" + "\""), -// } -// into -// type TupleT struct { X *big.Int } +// given type, e.g. turn this code: +// +// var fields []reflect.StructField +// +// fields = append(fields, reflect.StructField{ +// Name: "X", +// Type: reflect.TypeOf(new(big.Int)), +// Tag: reflect.StructTag("json:\"" + "x" + "\""), +// } +// +// into: +// +// type TupleT struct { X *big.Int } func ConvertType(in interface{}, proto interface{}) interface{} { protoType := reflect.TypeOf(proto) if reflect.TypeOf(in).ConvertibleTo(protoType) { @@ -177,11 +180,13 @@ return nil }   // mapArgNamesToStructFields maps a slice of argument names to struct fields. -// first round: for each Exportable field that contains a `abi:""` tag -// and this field name exists in the given argument name list, pair them together. -// second round: for each argument name that has not been already linked, -// find what variable is expected to be mapped into, if it exists and has not been -// used, pair them. +// +// first round: for each Exportable field that contains a `abi:""` tag and this field name +// exists in the given argument name list, pair them together. +// +// second round: for each argument name that has not been already linked, find what +// variable is expected to be mapped into, if it exists and has not been used, pair them. +// // Note this function assumes the given value is a struct value. func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[string]string, error) { typ := value.Type()

diff --git go-ethereum/accounts/abi/event_test.go celo/accounts/abi/event_test.go index ce9c4aeff983b9534059fe8ed9ae13591c10bd72..33419012195cbec89367bc4c104f82ee18b01db1 100644 --- go-ethereum/accounts/abi/event_test.go +++ celo/accounts/abi/event_test.go @@ -169,7 +169,7 @@ type EventTransferWithTag struct { // this is valid because `value` is not exportable, // so value is only unmarshalled into `Value1`. - value *big.Int //lint:ignore U1000 unused field is part of test + value *big.Int //nolint:unused // field is part of test Value1 *big.Int `abi:"value"` }

diff --git go-ethereum/accounts/abi/argument.go celo/accounts/abi/argument.go index 1c1dd962eef3f4973d25a8a72368e45a188a8c2d..c3145b251a3f942d1bab9045b6fd953fe45505ac 100644 --- go-ethereum/accounts/abi/argument.go +++ celo/accounts/abi/argument.go @@ -79,7 +79,7 @@ // Unpack performs the operation hexdata -> Go format. func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) { if len(data) == 0 { if len(arguments) != 0 { - return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected") + return nil, ErrEmptyArguments } // Nothing to unmarshal, return default variables nonIndexedArgs := arguments.NonIndexed() @@ -100,7 +100,7 @@ return fmt.Errorf("abi: cannot unpack into a nil map") } if len(data) == 0 { if len(arguments) != 0 { - return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected") + return ErrEmptyArguments } return nil // Nothing to unmarshal, return }

diff --git go-ethereum/accounts/abi/bind/template.go celo/accounts/abi/bind/template.go index 165c3b2d0e2479758b9dcee28619b5f471aab629..e14b27690f25f713e92869a246062208a757072e 100644 --- go-ethereum/accounts/abi/bind/template.go +++ celo/accounts/abi/bind/template.go @@ -275,6 +275,15 @@ } return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil }   + // Parse{{.Type}}ABI parses the ABI + func Parse{{.Type}}ABI() (*abi.ABI, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return nil, err + } + return &parsed, nil + } + // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named @@ -378,7 +387,25 @@ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) } {{end}}   - {{if .Fallback}} + // TryParseLog attempts to parse a log. Returns the parsed log, evenName and whether it was succesfull + func (_{{$contract.Type}} *{{$contract.Type}}Filterer) TryParseLog(log types.Log) (eventName string, event interface{}, ok bool, err error) { + eventName, ok, err = _{{$contract.Type}}.contract.LogEventName(log) + if err != nil || !ok { + return "", nil, false, err + } + + switch eventName { {{range .Events}} + case "{{.Normalized.Name}}": + event, err = _{{$contract.Type}}.Parse{{.Normalized.Name}}(log){{end}} + } + if err != nil { + return "", nil, false, err + } + + return eventName, event, ok, nil + } + + {{if .Fallback}} // Fallback is a paid mutator transaction binding the contract fallback function. // // Solidity: {{.Fallback.Original.String}} @@ -392,7 +419,7 @@ // Solidity: {{.Fallback.Original.String}} func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) { return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) } - + // Fallback is a paid mutator transaction binding the contract fallback function. // // Solidity: {{.Fallback.Original.String}} @@ -401,7 +428,7 @@ return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) } {{end}}   - {{if .Receive}} + {{if .Receive}} // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: {{.Receive.Original.String}} @@ -415,7 +442,7 @@ // Solidity: {{.Receive.Original.String}} func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) { return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts) } - + // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: {{.Receive.Original.String}}

diff --git go-ethereum/accounts/abi/bind/bind_test.go celo/accounts/abi/bind/bind_test.go index c3343531e3ffa8dde035134f615501acfca56339..03e4c0760e417b76e6e04ae9401527c3a1cf0b1d 100644 --- go-ethereum/accounts/abi/bind/bind_test.go +++ celo/accounts/abi/bind/bind_test.go @@ -298,7 +298,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy an interaction tester contract and call a transaction on it @@ -353,7 +353,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tuple tester contract and execute a structured call on it @@ -399,7 +399,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tuple tester contract and execute a structured call on it @@ -457,7 +457,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a slice tester contract and execute a n array call on it @@ -505,7 +505,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a default method invoker contract and execute its default method @@ -571,7 +571,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a structs method invoker contract and execute its default method @@ -614,7 +614,7 @@ `, ` // Create a simulator and wrap a non-deployed contract   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000)) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close()   nonexistent, err := NewNonExistent(common.Address{}, sim) @@ -653,7 +653,7 @@ `, ` // Create a simulator and wrap a non-deployed contract   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000)) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{},) defer sim.Close()   nonexistent, err := NewNonExistentStruct(common.Address{}, sim) @@ -703,7 +703,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a funky gas pattern contract @@ -753,7 +753,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a sender tester contract and execute a structured call on it @@ -828,7 +828,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a underscorer tester contract and execute a structured call on it @@ -922,7 +922,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy an eventer contract @@ -1112,7 +1112,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   //deploy the test contract @@ -1247,7 +1247,7 @@ ` key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   _, _, contract, err := DeployTuple(auth, sim) @@ -1389,7 +1389,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   //deploy the test contract @@ -1454,7 +1454,7 @@ ` // Initialize test accounts key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // deploy the test contract @@ -1544,7 +1544,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   // Deploy registrar contract - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1606,7 +1606,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   // Deploy registrar contract - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1668,7 +1668,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tester contract and execute a structured call on it @@ -1728,7 +1728,7 @@ ` key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 1000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1811,13 +1811,12 @@ "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/eth/ethconfig" `, ` var ( key, _ = crypto.GenerateKey() user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) - sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil) + sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}) ) defer sim.Close()   @@ -1917,7 +1916,7 @@ if out, err := moder.CombinedOutput(); err != nil { t.Fatalf("failed to convert binding test to modules: %v\n%s", err, out) } pwd, _ := os.Getwd() - replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/ethereum/go-ethereum="+filepath.Join(pwd, "..", "..", "..")) // Repo root + replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/celo-org/celo-blockchain="+filepath.Join(pwd, "..", "..", "..")) // Repo root replacer.Dir = pkg if out, err := replacer.CombinedOutput(); err != nil { t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)

diff --git go-ethereum/accounts/abi/bind/base.go celo/accounts/abi/bind/base.go index d6fff9a695dfa54e3ac4d5331c8e88b1eaad7d7a..de7bc725231771855c6315dba25022796bc600ad 100644 --- go-ethereum/accounts/abi/bind/base.go +++ celo/accounts/abi/bind/base.go @@ -53,6 +53,9 @@ Signer SignerFn // Method to use for signing the transaction (mandatory)   Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + FeeCurrency *common.Address // Fee currency to be used for transaction (nil = default currency = Celo Gold) + GatewayFeeRecipient *common.Address // Address to which gateway fees should be paid (nil = no gateway fees are paid) + GatewayFee *big.Int // Value of gateway fees to be paid (nil = no gateway fees are paid) GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) @@ -140,6 +143,11 @@ return common.Address{}, nil, nil, err } c.address = crypto.CreateAddress(opts.From, tx.Nonce()) return c.address, tx, c, nil +} + +// ABI returns the bound contract parsed ABI +func (c *BoundContract) ABI() abi.ABI { + return c.abi }   // Call invokes the (constant) contract method with params as input values and @@ -254,40 +262,55 @@ // Figure out reasonable gas price values if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) { return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") } - head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) - if err != nil { - return nil, err + // head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) + // if err != nil { + // return nil, err + // } + // TODO: Use GPM here + // if head.BaseFee != nil && opts.GasPrice == nil { + // if opts.GasTipCap == nil { + // tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) + // if err != nil { + // return nil, err + // } + // opts.GasTipCap = tip + // } + // if opts.GasFeeCap == nil { + // gasFeeCap := new(big.Int).Add( + // opts.GasTipCap, + // new(big.Int).Mul(head.BaseFee, big.NewInt(2)), + // ) + // opts.GasFeeCap = gasFeeCap + // } + // if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { + // return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) + // } + // } else { + if opts.GasFeeCap != nil || opts.GasTipCap != nil { + return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") } - if head.BaseFee != nil && opts.GasPrice == nil { - if opts.GasTipCap == nil { - tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - opts.GasTipCap = tip - } - if opts.GasFeeCap == nil { - gasFeeCap := new(big.Int).Add( - opts.GasTipCap, - new(big.Int).Mul(head.BaseFee, big.NewInt(2)), - ) - opts.GasFeeCap = gasFeeCap - } - if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { - return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) - } - } else { - if opts.GasFeeCap != nil || opts.GasTipCap != nil { - return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") + if opts.GasPrice == nil { + price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context)) + if err != nil { + return nil, err } - if opts.GasPrice == nil { - price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - opts.GasPrice = price - } + opts.GasPrice = price } + // } + + feeCurrency := opts.FeeCurrency + // TODO(nategraf): Add SuggestFeeCurrency to Transactor to get fee currency + // Otherwise, the user might not be able to pay in non-native currency for contract + // deployment. Paying for Contract deployment in non-native currency might not work right now. + // Only paying for token transfer in non-native currency is supported. + //if feeCurrency == 0 { + // feeCurrency = c.transactor.SuggestFeeCurrency(opts.Context) + //} + + gatewayFeeRecipient := opts.GatewayFeeRecipient + gatewayFee := opts.GatewayFee + // TODO(nategraf): Add SuggestGatewayFee to Transactor. + gasLimit := opts.GasLimit if gasLimit == 0 { // Gas estimation cannot succeed without code for method invocations @@ -299,7 +322,18 @@ return nil, ErrNoCode } } // If the contract surely has code (or code is not needed), estimate the transaction - msg := ethereum.CallMsg{From: opts.From, To: contract, GasPrice: opts.GasPrice, GasTipCap: opts.GasTipCap, GasFeeCap: opts.GasFeeCap, Value: value, Data: input} + msg := ethereum.CallMsg{ + From: opts.From, + To: contract, + GasPrice: opts.GasPrice, + GasTipCap: opts.GasTipCap, + GasFeeCap: opts.GasFeeCap, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } gasLimit, err = c.transactor.EstimateGas(ensureContext(opts.Context), msg) if err != nil { return nil, fmt.Errorf("failed to estimate gas needed: %v", err) @@ -313,6 +347,9 @@ Nonce: nonce, GasPrice: opts.GasPrice, Gas: gasLimit, Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, Data: input, } if contract != nil { @@ -347,6 +384,19 @@ if err := c.transactor.SendTransaction(ensureContext(opts.Context), signedTx); err != nil { return nil, err } return signedTx, nil +} + +// LogEventName will verify the log belongs to the contract and return the eventName for it +func (c *BoundContract) LogEventName(log types.Log) (eventName string, ok bool, err error) { + if log.Address != c.address || len(log.Topics) < 1 { + return "", false, err + } + + event, err := c.abi.EventByID(log.Topics[0]) + if err != nil { + return "", false, err + } + return event.Name, true, nil }   // FilterLogs filters contract logs for past blocks, returning the necessary

diff --git go-ethereum/accounts/abi/bind/util_test.go celo/accounts/abi/bind/util_test.go index e97ad65a10642d8a02afa09cf86f23970ebc81e3..11e67f774c65ab524bb8a20948e8098d1c9356df 100644 --- go-ethereum/accounts/abi/bind/util_test.go +++ celo/accounts/abi/bind/util_test.go @@ -33,6 +33,8 @@ )   var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")   +var genericBaseFee = big.NewInt(3) // set a constant gas price to be above the GPM. + var waitDeployedTests = map[string]struct { code string gas uint64 @@ -55,16 +57,12 @@ func TestWaitDeployed(t *testing.T) { for name, test := range waitDeployedTests { backend := backends.NewSimulatedBackend( - core.GenesisAlloc{ - crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, - }, - 10000000, - ) + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) defer backend.Close()   // Create the transaction - head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -101,19 +99,16 @@ }   func TestWaitDeployedCornerCases(t *testing.T) { backend := backends.NewSimulatedBackend( - core.GenesisAlloc{ - crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, - }, - 10000000, - ) + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) defer backend.Close()   - head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   // Create a transaction to an account. code := "6060604052600a8060106000396000f360606040526008565b00" - tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) + tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, + gasPrice, common.FromHex(code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) ctx, cancel := context.WithCancel(context.Background()) defer cancel()

diff --git go-ethereum/accounts/abi/bind/backends/simulated.go celo/accounts/abi/bind/backends/simulated.go index 9af21b95741bb0d67e7576b541d6ee5b17bbfbe0..d5f688f516f7c7d0953dde566cb70e6c648a6691 100644 --- go-ethereum/accounts/abi/bind/backends/simulated.go +++ celo/accounts/abi/bind/backends/simulated.go @@ -30,7 +30,8 @@ "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/math" - "github.com/ethereum/go-ethereum/consensus/ethash" + mockEngine "github.com/ethereum/go-ethereum/consensus/consensustest" + "github.com/ethereum/go-ethereum/contracts/blockchain_parameters" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/bloombits" "github.com/ethereum/go-ethereum/core/rawdb" @@ -75,10 +76,10 @@ // NewSimulatedBackendWithDatabase creates a new binding backend based on the given database // and uses a simulated blockchain for testing purposes. // A simulated backend always uses chainID 1337. -func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend { - genesis := core.Genesis{Config: params.AllEthashProtocolChanges, GasLimit: gasLimit, Alloc: alloc} +func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc) *SimulatedBackend { + genesis := core.Genesis{Config: params.TestChainConfig, Alloc: alloc} genesis.MustCommit(database) - blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil, nil) + blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, mockEngine.NewFaker(), vm.Config{}, nil, nil)   backend := &SimulatedBackend{ database: database, @@ -93,8 +94,8 @@ // NewSimulatedBackend creates a new binding backend using a simulated blockchain // for testing purposes. // A simulated backend always uses chainID 1337. -func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend { - return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit) +func NewSimulatedBackend(alloc core.GenesisAlloc) *SimulatedBackend { + return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc) }   // Close terminates the underlying blockchain's update loop. @@ -126,7 +127,7 @@ b.rollback(b.blockchain.CurrentBlock()) }   func (b *SimulatedBackend) rollback(parent *types.Block) { - blocks, _ := core.GenerateChain(b.config, parent, ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {}) + blocks, _ := core.GenerateChain(b.config, parent, mockEngine.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})   b.pendingBlock = blocks[0] b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil) @@ -471,6 +472,18 @@ func (b *SimulatedBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) { return big.NewInt(1), nil }   +// CurrentGasPriceMinimum implements ContractTransactor.CurrentGasPriceMinimum. Since the simulated +// chain doesn't have miners, we just return a gas tip of 1 for any call. +func (b *SimulatedBackend) CurrentGasPriceMinimum(ctx context.Context, currencyAddress *common.Address) (*big.Int, error) { + return big.NewInt(1), nil +} + +// GasPriceMinimumForHeader implements ContractTransactor.GasPriceMinimumForHeader. Since the simulated +// chain doesn't have miners, we just return a gas tip of 1 for any call. +func (b *SimulatedBackend) GasPriceMinimumForHeader(ctx context.Context, currencyAddress *common.Address, header *types.Header) (*big.Int, error) { + return big.NewInt(1), nil +} + // EstimateGas executes the requested code against the currently pending block/state and // returns the used amount of gas. func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) { @@ -486,7 +499,8 @@ ) if call.Gas >= params.TxGas { hi = call.Gas } else { - hi = b.pendingBlock.GasLimit() + vmRunner := b.blockchain.NewEVMRunner(b.pendingBlock.Header(), b.pendingState) + hi = blockchain_parameters.GetBlockGasLimitOrDefault(vmRunner) } // Normalize the max fee per gas the call is willing to spend. var feeCap *big.Int @@ -605,7 +619,11 @@ } // Backfill the legacy gasPrice for EVM execution, unless we're all zeroes call.GasPrice = new(big.Int) if call.GasFeeCap.BitLen() > 0 || call.GasTipCap.BitLen() > 0 { - call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, head.BaseFee), call.GasFeeCap) + gasPriceMinimum, err := b.CurrentGasPriceMinimum(ctx, call.FeeCurrency) + if err != nil { + return nil, err + } + call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, gasPriceMinimum), call.GasFeeCap) } } } @@ -628,8 +646,20 @@ // Create a new environment which holds all relevant information // about the transaction and calling mechanisms. vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true}) gasPool := new(core.GasPool).AddGas(math.MaxUint64) - - return core.NewStateTransition(vmEnv, msg, gasPool).TransitionDb() + vmRunner := b.blockchain.NewEVMRunner(block.Header(), stateDB) + var sysCtx *core.SysContractCallCtx + if b.config.IsEspresso(block.Number()) { + parent := b.blockchain.GetBlockByNumber(block.NumberU64() - 1) + if block.NumberU64() == 0 { + parent = b.blockchain.GetBlockByNumber(0) + } + sysStateDB, err := b.blockchain.StateAt(parent.Root()) + if err != nil { + return nil, err + } + sysCtx = core.NewSysContractCallCtx(block.Header(), sysStateDB, b.blockchain) + } + return core.NewStateTransition(vmEnv, msg, gasPool, vmRunner, sysCtx).TransitionDb() }   // SendTransaction updates the pending block to include the given transaction. @@ -654,7 +684,7 @@ if tx.Nonce() != nonce { panic(fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)) } // Include tx in chain - blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, block, mockEngine.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { block.AddTxWithChain(b.blockchain, tx) } @@ -772,7 +802,7 @@ if len(b.pendingBlock.Transactions()) != 0 { return errors.New("Could not adjust time on non-empty block") }   - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), mockEngine.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { block.OffsetTime(int64(adjustment.Seconds())) }) stateDB, _ := b.blockchain.State() @@ -800,9 +830,17 @@ func (m callMsg) To() *common.Address { return m.CallMsg.To } func (m callMsg) GasPrice() *big.Int { return m.CallMsg.GasPrice } func (m callMsg) GasFeeCap() *big.Int { return m.CallMsg.GasFeeCap } func (m callMsg) GasTipCap() *big.Int { return m.CallMsg.GasTipCap } +func (m callMsg) FeeCurrency() *common.Address { return m.CallMsg.FeeCurrency } +func (m callMsg) MaxFeeInFeeCurrency() *big.Int { return m.CallMsg.MaxFeeInFeeCurrency } +func (m callMsg) GatewayFeeRecipient() *common.Address { return m.CallMsg.GatewayFeeRecipient } +func (m callMsg) GatewaySet() bool { + return m.CallMsg.GatewayFeeRecipient != nil || (m.CallMsg.GatewayFee != nil && m.CallMsg.GatewayFee.Sign() != 0) +} +func (m callMsg) GatewayFee() *big.Int { return m.CallMsg.GatewayFee } func (m callMsg) Gas() uint64 { return m.CallMsg.Gas } func (m callMsg) Value() *big.Int { return m.CallMsg.Value } func (m callMsg) Data() []byte { return m.CallMsg.Data } +func (m callMsg) EthCompatible() bool { return m.CallMsg.EthCompatible } func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }   // filterBackend implements filters.Backend to support filtering for logs without @@ -874,6 +912,18 @@ func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }   func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) { panic("not supported") +} + +func (fb *filterBackend) ChainConfig() *params.ChainConfig { + panic("not supported") +} + +func (fb *filterBackend) CurrentHeader() *types.Header { + panic("not supported") +} + +func (fb *filterBackend) RealGasPriceMinimumForHeader(ctx context.Context, currencyAddress *common.Address, header *types.Header) (*big.Int, error) { + return nil, fmt.Errorf("filterBackend does not implement RealGasPriceMinimumForHeader") }   func nullSubscription() event.Subscription {

diff --git go-ethereum/accounts/abi/bind/backends/simulated_test.go celo/accounts/abi/bind/backends/simulated_test.go index 1d17c1254db0e2698961174601813a03d98c6a72..4cd97757eb7f9cb772b11460c4ae5f34dbc4d621 100644 --- go-ethereum/accounts/abi/bind/backends/simulated_test.go +++ celo/accounts/abi/bind/backends/simulated_test.go @@ -37,14 +37,15 @@ "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" )   +var genericBaseFee = big.NewInt(2) // set a constant gas price to be above the GPM. + func TestSimulatedBackend(t *testing.T) { - var gasLimit uint64 = 8000029 key, _ := crypto.GenerateKey() // nolint: gosec auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) genAlloc := make(core.GenesisAlloc) genAlloc[auth.From] = core.GenesisAccount{Balance: big.NewInt(9223372036854775807)}   - sim := NewSimulatedBackend(genAlloc, gasLimit) + sim := NewSimulatedBackend(genAlloc) defer sim.Close()   // should return an error if the tx is not found @@ -59,8 +60,7 @@ t.Fatalf("err should be `ethereum.NotFound` but received %v", err) }   // generate a transaction and confirm you can retrieve it - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   code := `6060604052600a8060106000396000f360606040526008565b00` var gas uint64 = 3000000 @@ -94,16 +94,17 @@ var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")   // the following is based on this contract: -// contract T { -// event received(address sender, uint amount, bytes memo); -// event receivedAddr(address sender); // -// function receive(bytes calldata memo) external payable returns (string memory res) { -// emit received(msg.sender, msg.value, memo); -// emit receivedAddr(msg.sender); -// return "hello world"; -// } -// } +// contract T { +// event received(address sender, uint amount, bytes memo); +// event receivedAddr(address sender); +// +// function receive(bytes calldata memo) external payable returns (string memory res) { +// emit received(msg.sender, msg.value, memo); +// emit receivedAddr(msg.sender); +// return "hello world"; +// } +// } const abiJSON = `[ { "constant": false, "inputs": [ { "name": "memo", "type": "bytes" } ], "name": "receive", "outputs": [ { "name": "res", "type": "string" } ], "payable": true, "stateMutability": "payable", "type": "function" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "sender", "type": "address" }, { "indexed": false, "name": "amount", "type": "uint256" }, { "indexed": false, "name": "memo", "type": "bytes" } ], "name": "received", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "sender", "type": "address" } ], "name": "receivedAddr", "type": "event" } ]` const abiBin = `0x608060405234801561001057600080fd5b506102a0806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063a69b6ed014610040575b600080fd5b6100b76004803603602081101561005657600080fd5b810190808035906020019064010000000081111561007357600080fd5b82018360208201111561008557600080fd5b803590602001918460018302840111640100000000831117156100a757600080fd5b9091929391929390505050610132565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100f75780820151818401526020810190506100dc565b50505050905090810190601f1680156101245780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60607f75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed33348585604051808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001848152602001806020018281038252848482818152602001925080828437600081840152601f19601f8201169050808301925050509550505050505060405180910390a17f46923992397eac56cf13058aced2a1871933622717e27b24eabc13bf9dd329c833604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390a16040805190810160405280600b81526020017f68656c6c6f20776f726c6400000000000000000000000000000000000000000081525090509291505056fea165627a7a72305820ff0c57dad254cfeda48c9cfb47f1353a558bccb4d1bc31da1dae69315772d29e0029` const deployedCode = `60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063a69b6ed014610040575b600080fd5b6100b76004803603602081101561005657600080fd5b810190808035906020019064010000000081111561007357600080fd5b82018360208201111561008557600080fd5b803590602001918460018302840111640100000000831117156100a757600080fd5b9091929391929390505050610132565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100f75780820151818401526020810190506100dc565b50505050905090810190601f1680156101245780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60607f75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed33348585604051808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001848152602001806020018281038252848482818152602001925080828437600081840152601f19601f8201169050808301925050509550505050505060405180910390a17f46923992397eac56cf13058aced2a1871933622717e27b24eabc13bf9dd329c833604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390a16040805190810160405280600b81526020017f68656c6c6f20776f726c6400000000000000000000000000000000000000000081525090509291505056fea165627a7a72305820ff0c57dad254cfeda48c9cfb47f1353a558bccb4d1bc31da1dae69315772d29e0029` @@ -115,7 +116,7 @@ func simTestBackend(testAddr common.Address) *SimulatedBackend { return NewSimulatedBackend( core.GenesisAlloc{ testAddr: {Balance: big.NewInt(10000000000000000)}, - }, 10000000, + }, ) }   @@ -125,12 +126,12 @@ expectedBal := big.NewInt(10000000000000000) sim := simTestBackend(testAddr) defer sim.Close()   - if sim.config != params.AllEthashProtocolChanges { - t.Errorf("expected sim config to equal params.AllEthashProtocolChanges, got %v", sim.config) + if sim.config != params.TestChainConfig { + t.Errorf("expected sim config to equal params.TestChainConfig, got %v", sim.config) }   - if sim.blockchain.Config() != params.AllEthashProtocolChanges { - t.Errorf("expected sim blockchain config to equal params.AllEthashProtocolChanges, got %v", sim.config) + if sim.blockchain.Config() != params.TestChainConfig { + t.Errorf("expected sim blockchain config to equal params.TestChainConfig, got %v", sim.config) }   stateDB, _ := sim.blockchain.State() @@ -141,9 +142,7 @@ } }   func TestAdjustTime(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close()   prevTime := sim.pendingBlock.Time() @@ -162,8 +161,7 @@ testAddr := crypto.PubkeyToAddress(testKey.PublicKey) sim := simTestBackend(testAddr)   // Create tx and send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -217,9 +215,7 @@ } }   func TestBlockByHash(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background()   @@ -238,9 +234,7 @@ } }   func TestBlockByNumber(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background()   @@ -289,8 +283,8 @@ t.Errorf("received incorrect nonce. expected 0, got %v", nonce) }   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(nonce, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -333,8 +327,8 @@ defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -365,14 +359,14 @@ sim := NewSimulatedBackend( core.GenesisAlloc{ testAddr: {Balance: big.NewInt(10000000000000000)}, - }, 10000000, + }, ) defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -417,12 +411,13 @@ func TestEstimateGas(t *testing.T) { /* pragma solidity ^0.6.4; contract GasEstimation { - function PureRevert() public { revert(); } - function Revert() public { revert("revert reason");} - function OOG() public { for (uint i = 0; ; i++) {}} - function Assert() public { assert(false);} - function Valid() public {} - }*/ + function PureRevert() public { revert(); } + function Revert() public { revert("revert reason");} + function OOG() public { for (uint i = 0; ; i++) {}} + function Assert() public { assert(false);} + function Valid() public {} + } + */ const contractAbi = "[{\"inputs\":[],\"name\":\"Assert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"OOG\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PureRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Revert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Valid\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" const contractBin = "0x60806040523480156100115760006000fd5b50610017565b61016e806100266000396000f3fe60806040523480156100115760006000fd5b506004361061005c5760003560e01c806350f6fe3414610062578063aa8b1d301461006c578063b9b046f914610076578063d8b9839114610080578063e09fface1461008a5761005c565b60006000fd5b61006a610094565b005b6100746100ad565b005b61007e6100b5565b005b6100886100c2565b005b610092610135565b005b6000600090505b5b808060010191505061009b565b505b565b60006000fd5b565b600015156100bf57fe5b5b565b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600d8152602001807f72657665727420726561736f6e0000000000000000000000000000000000000081526020015060200191505060405180910390fd5b565b5b56fea2646970667358221220345bbcbb1a5ecf22b53a78eaebf95f8ee0eceff6d10d4b9643495084d2ec934a64736f6c63430006040033"   @@ -430,7 +425,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey) opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether)}}, 10000000) + sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether)}}) defer sim.Close()   parsed, _ := abi.JSON(strings.NewReader(contractAbi)) @@ -531,96 +526,6 @@ } } }   -func TestEstimateGasWithPrice(t *testing.T) { - key, _ := crypto.GenerateKey() - addr := crypto.PubkeyToAddress(key.PublicKey) - - sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether*2 + 2e17)}}, 10000000) - defer sim.Close() - - recipient := common.HexToAddress("deadbeef") - var cases = []struct { - name string - message ethereum.CallMsg - expect uint64 - expectError error - }{ - {"EstimateWithoutPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(0), - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, nil}, - - {"EstimateWithPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(100000000000), - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, nil}, - - {"EstimateWithVeryHighPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(1e14), // gascost = 2.1ether - Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether - Data: nil, - }, 21000, nil}, - - {"EstimateWithSuperhighPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(2e14), // gascost = 4.2ether - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, errors.New("gas required exceeds allowance (10999)")}, // 10999=(2.2ether-1000wei)/(2e14) - - {"EstimateEIP1559WithHighFees", ethereum.CallMsg{ - From: addr, - To: &addr, - Gas: 0, - GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether - GasTipCap: big.NewInt(1), - Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether - Data: nil, - }, params.TxGas, nil}, - - {"EstimateEIP1559WithSuperHighFees", ethereum.CallMsg{ - From: addr, - To: &addr, - Gas: 0, - GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether - GasTipCap: big.NewInt(1), - Value: big.NewInt(1e17 + 1), // the remaining balance for fee is 2.1ether - Data: nil, - }, params.TxGas, errors.New("gas required exceeds allowance (20999)")}, // 20999=(2.2ether-0.1ether-1wei)/(1e14) - } - for i, c := range cases { - got, err := sim.EstimateGas(context.Background(), c.message) - if c.expectError != nil { - if err == nil { - t.Fatalf("test %d: expect error, got nil", i) - } - if c.expectError.Error() != err.Error() { - t.Fatalf("test %d: expect error, want %v, got %v", i, c.expectError, err) - } - continue - } - if c.expectError == nil && err != nil { - t.Fatalf("test %d: didn't expect error, got %v", i, err) - } - if got != c.expect { - t.Fatalf("test %d: gas estimation mismatch, want %d, got %d", i, c.expect, got) - } - } -} - func TestHeaderByHash(t *testing.T) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey)   @@ -709,8 +614,8 @@ if count != 0 { t.Errorf("expected transaction count of %v does not match actual count of %v", 0, count) } // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -766,8 +671,8 @@ if pendingNonce != uint64(0) { t.Errorf("expected pending nonce of 0 got %v", pendingNonce) } // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -824,8 +729,8 @@ t.Errorf("expected pending nonce of 0 got %v", pendingNonce) }   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -879,8 +784,8 @@ defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + //// head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) @@ -906,10 +811,7 @@ } }   func TestSuggestGasPrice(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, - 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background() gasPrice, err := sim.SuggestGasPrice(bgCtx) @@ -995,7 +897,8 @@ } }   // When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt: -// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} +// +// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} func TestPendingAndCallContract(t *testing.T) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) sim := simTestBackend(testAddr) @@ -1058,27 +961,27 @@ // This test is based on the following contract: /* contract Reverter { - function revertString() public pure{ - require(false, "some error"); - } - function revertNoString() public pure { - require(false, ""); - } - function revertASM() public pure { - assembly { - revert(0x0, 0x0) - } - } - function noRevert() public pure { - assembly { - // Assembles something that looks like require(false, "some error") but is not reverted - mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000) - mstore(0x4, 0x0000000000000000000000000000000000000000000000000000000000000020) - mstore(0x24, 0x000000000000000000000000000000000000000000000000000000000000000a) - mstore(0x44, 0x736f6d65206572726f7200000000000000000000000000000000000000000000) - return(0x0, 0x64) - } - } + function revertString() public pure{ + require(false, "some error"); + } + function revertNoString() public pure { + require(false, ""); + } + function revertASM() public pure { + assembly { + revert(0x0, 0x0) + } + } + function noRevert() public pure { + assembly { + // Assembles something that looks like require(false, "some error") but is not reverted + mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000) + mstore(0x4, 0x0000000000000000000000000000000000000000000000000000000000000020) + mstore(0x24, 0x000000000000000000000000000000000000000000000000000000000000000a) + mstore(0x44, 0x736f6d65206572726f7200000000000000000000000000000000000000000000) + return(0x0, 0x64) + } + } }*/ func TestCallContractRevert(t *testing.T) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) @@ -1205,11 +1108,11 @@ /* Example contract to test event emission:   -pragma solidity >=0.7.0 <0.9.0; -contract Callable { - event Called(); - function Call() public { emit Called(); } -} + pragma solidity >=0.7.0 <0.9.0; + contract Callable { + event Called(); + function Call() public { emit Called(); } + } */ const callableAbi = "[{\"anonymous\":false,\"inputs\":[],\"name\":\"Called\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"Call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"   @@ -1308,8 +1211,8 @@ defer sim.Close() // 1. parent := sim.blockchain.CurrentBlock() // 2. - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   _tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) tx, _ := types.SignTx(_tx, types.HomesteadSigner{}, testKey)

diff --git go-ethereum/accounts/abi/bind_v2/base.go celo/accounts/abi/bind_v2/base.go new file mode 100644 index 0000000000000000000000000000000000000000..462fe0d90e71931517ae5afb094baad9101defd8 --- /dev/null +++ celo/accounts/abi/bind_v2/base.go @@ -0,0 +1,609 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "fmt" + "math/big" + "strings" + "sync" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/event" +) + +// SignerFn is a signer function callback when a contract requires a method to +// sign the transaction before submission. +type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error) + +// CallOpts is the collection of options to fine tune a contract call request. +type CallOpts struct { + Pending bool // Whether to operate on the pending state or the last known one + From common.Address // Optional the sender address, otherwise the first account is used + BlockNumber *big.Int // Optional the block number on which the call should be performed + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// TransactOpts is the collection of authorization data required to create a +// valid Ethereum transaction. +type TransactOpts struct { + From common.Address // Ethereum account to send the transaction from + Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state) + Signer SignerFn // Method to use for signing the transaction (mandatory) + ChainID *big.Int // Chain/network id for use for replay protection during signing (nil = no replay protection) + + Value *big.Int // Funds to transfer along along the transaction (nil = 0 = no funds) + GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + FeeCurrency *common.Address // Fee currency to be used for transaction (nil = default currency = Celo Gold) + GatewayFeeRecipient *common.Address // Address to which gateway fees should be paid (nil = no gateway fees are paid) + GatewayFee *big.Int // Value of gateway fees to be paid (nil = no gateway fees are paid) + GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// FilterOpts is the collection of options to fine tune filtering for events +// within a bound contract. +type FilterOpts struct { + Start uint64 // Start of the queried range + End *uint64 // End of the range (nil = latest) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// WatchOpts is the collection of options to fine tune subscribing for events +// within a bound contract. +type WatchOpts struct { + Start *uint64 // Start of the queried range (nil = latest) + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// MetaData collects all metadata for a bound contract. +type MetaData struct { + mu sync.Mutex + Sigs map[string]string + Bin string + ABI string + ab *abi.ABI +} + +func (m *MetaData) GetAbi() (*abi.ABI, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.ab != nil { + return m.ab, nil + } + if parsed, err := abi.JSON(strings.NewReader(m.ABI)); err != nil { + return nil, err + } else { + m.ab = &parsed + } + return m.ab, nil +} + +// BoundContract is the base wrapper object that reflects a contract on the +// Ethereum network. It contains a collection of methods that are used by the +// higher level contract bindings to operate. +type BoundContract struct { + address common.Address // Deployment address of the contract on the Ethereum blockchain + abi abi.ABI // Reflect based ABI to access the correct Ethereum methods + backend ContractBackend // Event filtering to interact with the blockchain +} + +// NewBoundContract creates a low level contract interface through which calls +// and transactions may be made through. +func NewBoundContract(address common.Address, abi abi.ABI, backend ContractBackend) *BoundContract { + return &BoundContract{ + address: address, + abi: abi, + backend: backend, + } +} + +// DeployContract deploys a contract onto the Ethereum blockchain and binds the +// deployment address with a Go wrapper. +func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) { + // Otherwise try to deploy the contract + c := NewBoundContract(common.Address{}, abi, backend) + + input, err := c.abi.Pack("", params...) + if err != nil { + return common.Address{}, nil, nil, err + } + tx, err := c.transact(opts, nil, append(bytecode, input...)) + if err != nil { + return common.Address{}, nil, nil, err + } + c.address = crypto.CreateAddress(opts.From, tx.Nonce()) + return c.address, tx, c, nil +} + +// ABI returns the bound contract parsed ABI +func (c *BoundContract) ABI() abi.ABI { + return c.abi +} + +// TxObj returns an obj that can be used to get the transaction, send it, estimate it +func (c *BoundContract) TxObj(opts *TransactOpts, method string, params ...interface{}) *TxObject { + return &TxObject{ + method: method, + params: params, + opts: opts, + c: c, + } +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error { + // Don't crash on a lazy user + if opts == nil { + opts = new(CallOpts) + } + if results == nil { + results = new([]interface{}) + } + // Pack the input, call and unpack the results + input, err := c.abi.Pack(method, params...) + if err != nil { + return err + } + var ( + msg = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input} + ctx = ensureContext(opts.Context) + code []byte + output []byte + ) + if opts.Pending { + pb, ok := c.backend.(PendingContractCaller) + if !ok { + return ErrNoPendingState + } + output, err = pb.PendingCallContract(ctx, msg) + if err == nil && len(output) == 0 { + // Make sure we have a contract to operate on, and bail out otherwise. + if code, err = pb.PendingCodeAt(ctx, c.address); err != nil { + return err + } else if len(code) == 0 { + return ErrNoCode + } + } + } else { + output, err = c.backend.CallContract(ctx, msg, opts.BlockNumber) + if err != nil { + return err + } + if len(output) == 0 { + // Make sure we have a contract to operate on, and bail out otherwise. + if code, err = c.backend.CodeAt(ctx, c.address, opts.BlockNumber); err != nil { + return err + } else if len(code) == 0 { + return ErrNoCode + } + } + } + + if len(*results) == 0 { + res, err := c.abi.Unpack(method, output) + *results = res + return err + } + res := *results + return c.abi.UnpackIntoInterface(res[0], method, output) +} + +// Transact invokes the (paid) contract method with params as input values. +func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return nil, err + } + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transact(opts, &c.address, input) +} + +// TransactionFor returns the signed transaction for the contract method with params as input values +func (c *BoundContract) TransactionFor(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return nil, err + } + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transactionFor(opts, &c.address, input) +} + +// EstimateGas obtains an estimate for calling contract method with params as input values. +func (c *BoundContract) EstimateGas(opts *TransactOpts, method string, params ...interface{}) (uint64, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return 0, err + } + + msg := ethereum.CallMsg{From: opts.From, To: &c.address, GasPrice: opts.GasPrice, Value: opts.Value, Data: input} + gasLimit, err := c.backend.EstimateGas(ensureContext(opts.Context), msg) + if err != nil { + return 0, err + } + + // Apply buffer 3/2 => 1.5 => +50% (weird way of doing it, thanks go) + gasLimit = new(big.Int).Div(new(big.Int).Mul(new(big.Int).SetUint64(gasLimit), big.NewInt(3)), big.NewInt(2)).Uint64() + + return gasLimit, nil +} + +// RawTransact initiates a transaction with the given raw calldata as the input. +// It's usually used to initiates transaction for invoking **Fallback** function. +func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) { + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transact(opts, &c.address, calldata) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error) { + // todo(rjl493456442) check the payable fallback or receive is defined + // or not, reject invalid transaction at the first place + return c.transact(opts, &c.address, nil) +} + +func (c *BoundContract) transactionFor(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { + var err error + + // Ensure a valid value field and resolve the account nonce + value := opts.Value + if value == nil { + value = new(big.Int) + } + var nonce uint64 + if opts.Nonce == nil { + nonce, err = c.backend.PendingNonceAt(ensureContext(opts.Context), opts.From) + if err != nil { + return nil, fmt.Errorf("failed to retrieve account nonce: %v", err) + } + } else { + nonce = opts.Nonce.Uint64() + } + // Figure out reasonable gas price values + if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) { + return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") + } + // head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) + // if err != nil { + // return nil, err + // } + // TODO: Use GPM here + // if head.BaseFee != nil && opts.GasPrice == nil { + // if opts.GasTipCap == nil { + // tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) + // if err != nil { + // return nil, err + // } + // opts.GasTipCap = tip + // } + // if opts.GasFeeCap == nil { + // gasFeeCap := new(big.Int).Add( + // opts.GasTipCap, + // new(big.Int).Mul(head.BaseFee, big.NewInt(2)), + // ) + // opts.GasFeeCap = gasFeeCap + // } + // if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { + // return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) + // } + // } else { + if opts.GasFeeCap != nil || opts.GasTipCap != nil { + return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") + } + if opts.GasPrice == nil { + price, err := c.backend.SuggestGasPrice(ensureContext(opts.Context)) + if err != nil { + return nil, err + } + opts.GasPrice = price + } + // } + + feeCurrency := opts.FeeCurrency + // TODO(nategraf): Add SuggestFeeCurrency to Transactor to get fee currency + // Otherwise, the user might not be able to pay in non-native currency for contract + // deployment. Paying for Contract deployment in non-native currency might not work right now. + // Only paying for token transfer in non-native currency is supported. + //if feeCurrency == 0 { + // feeCurrency = c.backend.SuggestFeeCurrency(opts.Context) + //} + + gatewayFeeRecipient := opts.GatewayFeeRecipient + gatewayFee := opts.GatewayFee + // TODO(nategraf): Add SuggestGatewayFee to Transactor. + + gasLimit := opts.GasLimit + if gasLimit == 0 { + // Gas estimation cannot succeed without code for method invocations + if contract != nil { + if code, err := c.backend.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil { + return nil, err + } else if len(code) == 0 { + return nil, ErrNoCode + } + } + // If the contract surely has code (or code is not needed), estimate the transaction + msg := ethereum.CallMsg{ + From: opts.From, + To: contract, + GasPrice: opts.GasPrice, + GasTipCap: opts.GasTipCap, + GasFeeCap: opts.GasFeeCap, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } + gasLimit, err = c.backend.EstimateGas(ensureContext(opts.Context), msg) + if err != nil { + return nil, fmt.Errorf("failed to estimate gas needed: %v", err) + } + + // Apply buffer 3/2 => 1.5 => +50% (weird way of doing it, thanks go) + gasLimit = new(big.Int).Div(new(big.Int).Mul(new(big.Int).SetUint64(gasLimit), big.NewInt(3)), big.NewInt(2)).Uint64() + } + // Create the transaction, sign it and schedule it for execution + var rawTx *types.Transaction + if opts.GasFeeCap == nil { + baseTx := &types.LegacyTx{ + Nonce: nonce, + GasPrice: opts.GasPrice, + Gas: gasLimit, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } + if contract != nil { + baseTx.To = &c.address + } + rawTx = types.NewTx(baseTx) + } else { + baseTx := &types.DynamicFeeTx{ + Nonce: nonce, + GasFeeCap: opts.GasFeeCap, + GasTipCap: opts.GasTipCap, + Gas: gasLimit, + Value: value, + Data: input, + } + if contract != nil { + baseTx.To = &c.address + } + rawTx = types.NewTx(baseTx) + } + if opts.Signer == nil { + return nil, errors.New("no signer to authorize the transaction with") + } + signedTx, err := opts.Signer(opts.From, rawTx) + if err != nil { + return nil, err + } + + return signedTx, err +} + +// transact executes an actual transaction invocation, first deriving any missing +// authorization fields, and then scheduling the transaction for execution. +func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { + var err error + + signedTx, err := c.transactionFor(opts, contract, input) + if err != nil { + return nil, err + } + + if err := c.backend.SendTransaction(ensureContext(opts.Context), signedTx); err != nil { + return nil, err + } + return signedTx, nil +} + +// LogEventName will verify the log belongs to the contract and return the eventName for it +func (c *BoundContract) LogEventName(log types.Log) (eventName string, ok bool, err error) { + if log.Address != c.address || len(log.Topics) < 1 { + return "", false, err + } + + event, err := c.abi.EventByID(log.Topics[0]) + if err != nil { + return "", false, err + } + return event.Name, true, nil +} + +// FilterLogs filters contract logs for past blocks, returning the necessary +// channels to construct a strongly typed bound iterator on top of them. +func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(FilterOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) + + topics, err := abi.MakeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + FromBlock: new(big.Int).SetUint64(opts.Start), + } + if opts.End != nil { + config.ToBlock = new(big.Int).SetUint64(*opts.End) + } + /* TODO(karalabe): Replace the rest of the method below with this when supported + sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + */ + buff, err := c.backend.FilterLogs(ensureContext(opts.Context), config) + if err != nil { + return nil, nil, err + } + sub, err := event.NewSubscription(func(quit <-chan struct{}) error { + for _, log := range buff { + select { + case logs <- log: + case <-quit: + return nil + } + } + return nil + }), nil + + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// WatchLogs filters subscribes to contract logs for future blocks, returning a +// subscription object that can be used to tear down the watcher. +func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(WatchOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) + + topics, err := abi.MakeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + } + if opts.Start != nil { + config.FromBlock = new(big.Int).SetUint64(*opts.Start) + } + sub, err := c.backend.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// UnpackLog unpacks a retrieved log into the provided output structure. +func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error { + if log.Topics[0] != c.abi.Events[event].ID { + return fmt.Errorf("event signature mismatch") + } + if len(log.Data) > 0 { + if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return err + } + } + var indexed abi.Arguments + for _, arg := range c.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + return abi.ParseTopics(out, indexed, log.Topics[1:]) +} + +// UnpackLogIntoMap unpacks a retrieved log into the provided map. +func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error { + if log.Topics[0] != c.abi.Events[event].ID { + return fmt.Errorf("event signature mismatch") + } + if len(log.Data) > 0 { + if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil { + return err + } + } + var indexed abi.Arguments + for _, arg := range c.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + return abi.ParseTopicsIntoMap(out, indexed, log.Topics[1:]) +} + +// ensureContext is a helper method to ensure a context is not nil, even if the +// user specified it as such. +func ensureContext(ctx context.Context) context.Context { + if ctx == nil { + return context.Background() + } + return ctx +} + +type TxPromise struct { + Transaction *types.Transaction + backend ContractBackend +} + +func (txp *TxPromise) WaitMined(ctx context.Context) (*types.Receipt, error) { + return WaitMined(ctx, txp.backend, txp.Transaction) +} + +type TxObject struct { + method string + params []interface{} + opts *TransactOpts + c *BoundContract +} + +func (txo *TxObject) Send() (*TxPromise, error) { + tx, err := txo.c.Transact(txo.opts, txo.method, txo.params...) + + return &TxPromise{ + Transaction: tx, + backend: txo.c.backend, + }, err +} + +func (txo *TxObject) EstimateGas() (uint64, error) { + return txo.c.EstimateGas(txo.opts, txo.method, txo.params...) +} + +func (txo *TxObject) Transaction() (*types.Transaction, error) { + return txo.c.TransactionFor(txo.opts, txo.method, txo.params...) +}

diff --git go-ethereum/accounts/abi/bind_v2/util_test.go celo/accounts/abi/bind_v2/util_test.go new file mode 100644 index 0000000000000000000000000000000000000000..cc82c63e979436d98519651e64af04fec79207c5 --- /dev/null +++ celo/accounts/abi/bind_v2/util_test.go @@ -0,0 +1,135 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "math/big" + "testing" + "time" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" +) + +var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + +var genericBaseFee = big.NewInt(2) // set a constant gas price to be above the GPM. + +var waitDeployedTests = map[string]struct { + code string + gas uint64 + wantAddress common.Address + wantErr error +}{ + "successful deploy": { + code: `6060604052600a8060106000396000f360606040526008565b00`, + gas: 3000000, + wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), + }, + "empty code": { + code: ``, + gas: 300000, + wantErr: bind.ErrNoCodeAfterDeploy, + wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), + }, +} + +func TestWaitDeployed(t *testing.T) { + for name, test := range waitDeployedTests { + backend := backends.NewSimulatedBackend( + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) + defer backend.Close() + + // Create the transaction + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1)) + + tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + + // Wait for it to get mined in the background. + var ( + err error + address common.Address + mined = make(chan struct{}) + ctx = context.Background() + ) + go func() { + address, err = bind.WaitDeployed(ctx, backend, tx) + close(mined) + }() + + // Send and mine the transaction. + backend.SendTransaction(ctx, tx) + backend.Commit() + + select { + case <-mined: + if err != test.wantErr { + t.Errorf("test %q: error mismatch: got %q, want %q", name, err, test.wantErr) + } + if address != test.wantAddress { + t.Errorf("test %q: unexpected contract address %s", name, address.Hex()) + } + case <-time.After(2 * time.Second): + t.Errorf("test %q: timeout", name) + } + } +} + +func TestWaitDeployedCornerCases(t *testing.T) { + backend := backends.NewSimulatedBackend( + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) + defer backend.Close() + + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1)) + + // Create a transaction to an account. + code := "6060604052600a8060106000396000f360606040526008565b00" + tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, + gasPrice, common.FromHex(code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + backend.SendTransaction(ctx, tx) + backend.Commit() + notContentCreation := errors.New("tx is not contract creation") + if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() { + t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err) + } + + // Create a transaction that is not mined. + tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + + go func() { + contextCanceled := errors.New("context canceled") + if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() { + t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err) + } + }() + + backend.SendTransaction(ctx, tx) + cancel() +}

diff --git go-ethereum/accounts/abi/bind_v2/backend.go celo/accounts/abi/bind_v2/backend.go new file mode 100644 index 0000000000000000000000000000000000000000..817b3c36e53061dc982c5dcbf1317ef896b2e4d5 --- /dev/null +++ celo/accounts/abi/bind_v2/backend.go @@ -0,0 +1,128 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +var ( + // ErrNoCode is returned by call and transact operations for which the requested + // recipient contract to operate on does not exist in the state db or does not + // have any code associated with it (i.e. suicided). + ErrNoCode = errors.New("no contract code at given address") + + // ErrNoPendingState is raised when attempting to perform a pending state action + // on a backend that doesn't implement PendingContractCaller. + ErrNoPendingState = errors.New("backend does not support pending state") + + // ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves + // an empty contract behind. + ErrNoCodeAfterDeploy = errors.New("no contract code after deployment") +) + +// ContractCaller defines the methods needed to allow operating with contract on a read +// only basis. +type ContractCaller interface { + // CodeAt returns the code of the given account. This is needed to differentiate + // between contract internal errors and the local chain being out of sync. + CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) + + // ContractCall executes an Ethereum contract call with the specified data as the + // input. + CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) +} + +// PendingContractCaller defines methods to perform contract calls on the pending state. +// Call will try to discover this interface when access to the pending state is requested. +// If the backend does not support the pending state, Call returns ErrNoPendingState. +type PendingContractCaller interface { + // PendingCodeAt returns the code of the given account in the pending state. + PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) + + // PendingCallContract executes an Ethereum contract call against the pending state. + PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) +} + +// ContractTransactor defines the methods needed to allow operating with contract +// on a write only basis. Beside the transacting method, the remainder are helpers +// used when the user does not provide some needed values, but rather leaves it up +// to the transactor to decide. +type ContractTransactor interface { + // HeaderByNumber returns a block header from the current canonical chain. If + // number is nil, the latest known header is returned. + HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) + + // PendingCodeAt returns the code of the given account in the pending state. + PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) + + // PendingNonceAt retrieves the current pending nonce associated with an account. + PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) + + // SuggestGasPrice retrieves the currently suggested gas price to allow a timely + // execution of a transaction. + SuggestGasPrice(ctx context.Context) (*big.Int, error) + + // SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow + // a timely execution of a transaction. + SuggestGasTipCap(ctx context.Context) (*big.Int, error) + + // EstimateGas tries to estimate the gas needed to execute a specific + // transaction based on the current pending state of the backend blockchain. + // There is no guarantee that this is the true gas limit requirement as other + // transactions may be added or removed by miners, but it should provide a basis + // for setting a reasonable default. + EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) + + // SendTransaction injects the transaction into the pending pool for execution. + SendTransaction(ctx context.Context, tx *types.Transaction) error + + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) +} + +// ContractFilterer defines the methods needed to access log events using one-off +// queries or continuous event subscriptions. +type ContractFilterer interface { + // FilterLogs executes a log filter operation, blocking during execution and + // returning all the results in one batch. + // + // TODO(karalabe): Deprecate when the subscription one can return past data too. + FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) + + // SubscribeFilterLogs creates a background log filtering operation, returning + // a subscription immediately, which can be used to stream the found events. + SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) +} + +// DeployBackend wraps the operations needed by WaitMined and WaitDeployed. +type DeployBackend interface { + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) + CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) +} + +// ContractBackend defines the methods needed to work with contracts on a read-write basis. +type ContractBackend interface { + ContractCaller + ContractTransactor + ContractFilterer +}

diff --git go-ethereum/accounts/abi/bind_v2/bind.go celo/accounts/abi/bind_v2/bind.go new file mode 100644 index 0000000000000000000000000000000000000000..40ebb0bf4f6e7c0f9c143d38541e1b997209d0aa --- /dev/null +++ celo/accounts/abi/bind_v2/bind.go @@ -0,0 +1,492 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +// Package bind generates Ethereum contract Go bindings. +// +// Detailed usage document and tutorial available on the go-ethereum Wiki page: +// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts +package bind_v2 + +import ( + "bytes" + "fmt" + "go/format" + "regexp" + "strings" + "text/template" + "unicode" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/log" +) + +// Lang is a target programming language selector to generate bindings for. +type Lang int + +const ( + LangGo Lang = iota +) + +// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant +// to be used as is in client code, but rather as an intermediate struct which +// enforces compile time type safety and naming convention opposed to having to +// manually maintain hard coded strings that break on runtime. +func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { + var ( + // contracts is the map of each individual contract requested binding + contracts = make(map[string]*tmplContract) + + // structs is the map of all reclared structs shared by passed contracts. + structs = make(map[string]*tmplStruct) + + // isLib is the map used to flag each encountered library as such + isLib = make(map[string]struct{}) + ) + for i := 0; i < len(types); i++ { + // Parse the actual ABI to generate the binding for + evmABI, err := abi.JSON(strings.NewReader(abis[i])) + if err != nil { + return "", err + } + // Strip any whitespace from the JSON ABI + strippedABI := strings.Map(func(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r + }, abis[i]) + + // Extract the call and transact methods; events, struct definitions; and sort them alphabetically + var ( + calls = make(map[string]*tmplMethod) + transacts = make(map[string]*tmplMethod) + events = make(map[string]*tmplEvent) + fallback *tmplMethod + receive *tmplMethod + + // identifiers are used to detect duplicated identifier of function + // and event. For all calls, transacts and events, abigen will generate + // corresponding bindings. However we have to ensure there is no + // identifier coliision in the bindings of these categories. + callIdentifiers = make(map[string]bool) + transactIdentifiers = make(map[string]bool) + eventIdentifiers = make(map[string]bool) + ) + for _, original := range evmABI.Methods { + // Normalize the method for capital cases and non-anonymous inputs/outputs + normalized := original + normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) + // Ensure there is no duplicated identifier + var identifiers = callIdentifiers + if !original.IsConstant() { + identifiers = transactIdentifiers + } + if identifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + identifiers[normalizedName] = true + normalized.Name = normalizedName + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + bindStructType[lang](input.Type, structs) + } + } + normalized.Outputs = make([]abi.Argument, len(original.Outputs)) + copy(normalized.Outputs, original.Outputs) + for j, output := range normalized.Outputs { + if output.Name != "" { + normalized.Outputs[j].Name = capitalise(output.Name) + } + if hasStruct(output.Type) { + bindStructType[lang](output.Type, structs) + } + } + // Append the methods to the call or transact lists + if original.IsConstant() { + calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } else { + transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } + } + for _, original := range evmABI.Events { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + continue + } + // Normalize the event for capital cases and non-anonymous outputs + normalized := original + + // Ensure there is no duplicated identifier + normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) + if eventIdentifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + eventIdentifiers[normalizedName] = true + normalized.Name = normalizedName + + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + bindStructType[lang](input.Type, structs) + } + } + // Append the event to the accumulator list + events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + } + // Add two special fallback functions if they exist + if evmABI.HasFallback() { + fallback = &tmplMethod{Original: evmABI.Fallback} + } + if evmABI.HasReceive() { + receive = &tmplMethod{Original: evmABI.Receive} + } + + contracts[types[i]] = &tmplContract{ + Type: capitalise(types[i]), + InputABI: strings.Replace(strippedABI, "\"", "\\\"", -1), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, + Fallback: fallback, + Receive: receive, + Events: events, + Libraries: make(map[string]string), + } + // Function 4-byte signatures are stored in the same sequence + // as types, if available. + if len(fsigs) > i { + contracts[types[i]].FuncSigs = fsigs[i] + } + // Parse library references. + for pattern, name := range libs { + matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin)) + if err != nil { + log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err) + } + if matched { + contracts[types[i]].Libraries[pattern] = name + // keep track that this type is a library + if _, ok := isLib[name]; !ok { + isLib[name] = struct{}{} + } + } + } + } + // Check if that type has already been identified as a library + for i := 0; i < len(types); i++ { + _, ok := isLib[types[i]] + contracts[types[i]].Library = ok + } + // Generate the contract template data content and render it + data := &tmplData{ + Package: pkg, + Contracts: contracts, + Libraries: libs, + Structs: structs, + } + buffer := new(bytes.Buffer) + + funcs := map[string]interface{}{ + "bindtype": bindType[lang], + "bindtopictype": bindTopicType[lang], + "namedtype": namedType[lang], + "formatmethod": formatMethod, + "formatevent": formatEvent, + "capitalise": capitalise, + "decapitalise": decapitalise, + } + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err + } + // For Go bindings pass the code through gofmt to clean it up + if lang == LangGo { + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) + } + return string(code), nil + } + // For all others just return as is for now + return buffer.String(), nil +} + +// bindType is a set of type binders that convert Solidity types to some supported +// programming language types. +var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindTypeGo, +} + +// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go one. +func bindBasicTypeGo(kind abi.Type) string { + switch kind.T { + case abi.AddressTy: + return "common.Address" + case abi.IntTy, abi.UintTy: + parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String()) + switch parts[2] { + case "8", "16", "32", "64": + return fmt.Sprintf("%sint%s", parts[1], parts[2]) + } + return "*big.Int" + case abi.FixedBytesTy: + return fmt.Sprintf("[%d]byte", kind.Size) + case abi.BytesTy: + return "[]byte" + case abi.FunctionTy: + return "[24]byte" + default: + // string, bool types + return kind.String() + } +} + +// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping +// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly +// mapped will use an upscaled type (e.g. BigDecimal). +func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + switch kind.T { + case abi.TupleTy: + return structs[kind.TupleRawName+kind.String()].Name + case abi.ArrayTy: + return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs) + case abi.SliceTy: + return "[]" + bindTypeGo(*kind.Elem, structs) + default: + return bindBasicTypeGo(kind) + } +} + +// bindTopicType is a set of type binders that convert Solidity types to some +// supported programming language topic types. +var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindTopicTypeGo, +} + +// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same +// funcionality as for simple types, but dynamic types get converted to hashes. +func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + bound := bindTypeGo(kind, structs) + + // todo(rjl493456442) according solidity documentation, indexed event + // parameters that are not value types i.e. arrays and structs are not + // stored directly but instead a keccak256-hash of an encoding is stored. + // + // We only convert stringS and bytes to hash, still need to deal with + // array(both fixed-size and dynamic-size) and struct. + if bound == "string" || bound == "[]byte" { + bound = "common.Hash" + } + return bound +} + +// bindStructType is a set of type binders that convert Solidity tuple types to some supported +// programming language struct definition. +var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindStructTypeGo, +} + +// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping +// in the given map. +// Notably, this function will resolve and record nested struct recursively. +func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + switch kind.T { + case abi.TupleTy: + // We compose raw struct name and canonical parameter expression + // together here. The reason is before solidity v0.5.11, kind.TupleRawName + // is empty, so we use canonical parameter expression to distinguish + // different struct definition. From the consideration of backward + // compatibility, we concat these two together so that if kind.TupleRawName + // is not empty, it can have unique id. + id := kind.TupleRawName + kind.String() + if s, exist := structs[id]; exist { + return s.Name + } + var fields []*tmplField + for i, elem := range kind.TupleElems { + field := bindStructTypeGo(*elem, structs) + fields = append(fields, &tmplField{Type: field, Name: capitalise(kind.TupleRawNames[i]), SolKind: *elem}) + } + name := kind.TupleRawName + if name == "" { + name = fmt.Sprintf("Struct%d", len(structs)) + } + structs[id] = &tmplStruct{ + Name: name, + Fields: fields, + } + return name + case abi.ArrayTy: + return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs) + case abi.SliceTy: + return "[]" + bindStructTypeGo(*kind.Elem, structs) + default: + return bindBasicTypeGo(kind) + } +} + +// namedType is a set of functions that transform language specific types to +// named versions that my be used inside method names. +var namedType = map[Lang]func(string, abi.Type) string{ + LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") }, +} + +// alias returns an alias of the given string based on the aliasing rules +// or returns itself if no rule is matched. +func alias(aliases map[string]string, n string) string { + if alias, exist := aliases[n]; exist { + return alias + } + return n +} + +// methodNormalizer is a name transformer that modifies Solidity method names to +// conform to target language naming concentions. +var methodNormalizer = map[Lang]func(string) string{ + LangGo: abi.ToCamelCase, +} + +// capitalise makes a camel-case string which starts with an upper case character. +var capitalise = abi.ToCamelCase + +// decapitalise makes a camel-case string which starts with a lower case character. +func decapitalise(input string) string { + if len(input) == 0 { + return input + } + + goForm := abi.ToCamelCase(input) + return strings.ToLower(goForm[:1]) + goForm[1:] +} + +// structured checks whether a list of ABI data types has enough information to +// operate through a proper Go struct or if flat returns are needed. +func structured(args abi.Arguments) bool { + if len(args) < 2 { + return false + } + exists := make(map[string]bool) + for _, out := range args { + // If the name is anonymous, we can't organize into a struct + if out.Name == "" { + return false + } + // If the field name is empty when normalized or collides (var, Var, _var, _Var), + // we can't organize into a struct + field := capitalise(out.Name) + if field == "" || exists[field] { + return false + } + exists[field] = true + } + return true +} + +// hasStruct returns an indicator whether the given type is struct, struct slice +// or struct array. +func hasStruct(t abi.Type) bool { + switch t.T { + case abi.SliceTy: + return hasStruct(*t.Elem) + case abi.ArrayTy: + return hasStruct(*t.Elem) + case abi.TupleTy: + return true + default: + return false + } +} + +// resolveArgName converts a raw argument representation into a user friendly format. +func resolveArgName(arg abi.Argument, structs map[string]*tmplStruct) string { + var ( + prefix string + embedded string + typ = &arg.Type + ) +loop: + for { + switch typ.T { + case abi.SliceTy: + prefix += "[]" + case abi.ArrayTy: + prefix += fmt.Sprintf("[%d]", typ.Size) + default: + embedded = typ.TupleRawName + typ.String() + break loop + } + typ = typ.Elem + } + if s, exist := structs[embedded]; exist { + return prefix + s.Name + } else { + return arg.Type.String() + } +} + +// formatMethod transforms raw method representation into a user friendly one. +func formatMethod(method abi.Method, structs map[string]*tmplStruct) string { + inputs := make([]string, len(method.Inputs)) + for i, input := range method.Inputs { + inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name) + } + outputs := make([]string, len(method.Outputs)) + for i, output := range method.Outputs { + outputs[i] = resolveArgName(output, structs) + if len(output.Name) > 0 { + outputs[i] += fmt.Sprintf(" %v", output.Name) + } + } + // Extract meaningful state mutability of solidity method. + // If it's default value, never print it. + state := method.StateMutability + if state == "nonpayable" { + state = "" + } + if state != "" { + state = state + " " + } + identity := fmt.Sprintf("function %v", method.RawName) + if method.Type == abi.Fallback { + identity = "fallback" + } else if method.Type == abi.Receive { + identity = "receive" + } + return fmt.Sprintf("%s(%v) %sreturns(%v)", identity, strings.Join(inputs, ", "), state, strings.Join(outputs, ", ")) +} + +// formatEvent transforms raw event representation into a user friendly one. +func formatEvent(event abi.Event, structs map[string]*tmplStruct) string { + inputs := make([]string, len(event.Inputs)) + for i, input := range event.Inputs { + if input.Indexed { + inputs[i] = fmt.Sprintf("%v indexed %v", resolveArgName(input, structs), input.Name) + } else { + inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name) + } + } + return fmt.Sprintf("event %v(%v)", event.RawName, strings.Join(inputs, ", ")) +}

diff --git go-ethereum/accounts/abi/bind_v2/base_test.go celo/accounts/abi/bind_v2/base_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5960c702a07e7b00b3890be12530a0484e5e0d88 --- /dev/null +++ celo/accounts/abi/bind_v2/base_test.go @@ -0,0 +1,258 @@ +// Copyright 2019 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "math/big" + "reflect" + "strings" + "testing" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" +) + +type mockCaller struct { + codeAtBlockNumber *big.Int + callContractBlockNumber *big.Int + pendingCodeAtCalled bool + pendingCallContractCalled bool +} + +func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) { + mc.codeAtBlockNumber = blockNumber + return []byte{1, 2, 3}, nil +} + +func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) { + mc.callContractBlockNumber = blockNumber + return nil, nil +} + +func (mc *mockCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) { + mc.pendingCodeAtCalled = true + return nil, nil +} + +func (mc *mockCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) { + mc.pendingCallContractCalled = true + return nil, nil +} +func TestPassingBlockNumber(t *testing.T) { + + mc := &mockCaller{} + + bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{ + Methods: map[string]abi.Method{ + "something": { + Name: "something", + Outputs: abi.Arguments{}, + }, + }, + }, mc, nil, nil) + var ret []interface{} + + blockNumber := big.NewInt(42) + + bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something") + + if mc.callContractBlockNumber != blockNumber { + t.Fatalf("CallContract() was not passed the block number") + } + + if mc.codeAtBlockNumber != blockNumber { + t.Fatalf("CodeAt() was not passed the block number") + } + + bc.Call(&bind.CallOpts{}, &ret, "something") + + if mc.callContractBlockNumber != nil { + t.Fatalf("CallContract() was passed a block number when it should not have been") + } + + if mc.codeAtBlockNumber != nil { + t.Fatalf("CodeAt() was passed a block number when it should not have been") + } + + bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, &ret, "something") + + if !mc.pendingCallContractCalled { + t.Fatalf("CallContract() was not passed the block number") + } + + if !mc.pendingCodeAtCalled { + t.Fatalf("CodeAt() was not passed the block number") + } +} + +const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158" + +func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) { + hash := crypto.Keccak256Hash([]byte("testName")) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(string,address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"name","type":"string"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "name": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) { + sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"}) + if err != nil { + t.Fatal(err) + } + hash := crypto.Keccak256Hash(sliceBytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(string[],address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"names","type":"string[]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "names": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) { + arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")}) + if err != nil { + t.Fatal(err) + } + hash := crypto.Keccak256Hash(arrBytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(address[2],address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"addresses","type":"address[2]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "addresses": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) { + mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2") + addrBytes := mockAddress.Bytes() + hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)")) + functionSelector := hash[:4] + functionTyBytes := append(addrBytes, functionSelector...) + var functionTy [24]byte + copy(functionTy[:], functionTyBytes[0:24]) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(function,address,uint256,bytes)")), + common.BytesToHash(functionTyBytes), + } + mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42")) + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"function","type":"function"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "function": functionTy, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) { + bytes := []byte{1, 2, 3, 4, 5} + hash := crypto.Keccak256Hash(bytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(bytes,address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"content","type":"bytes"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "content": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func unpackAndCheck(t *testing.T, bc *bind.BoundContract, expected map[string]interface{}, mockLog types.Log) { + received := make(map[string]interface{}) + if err := bc.UnpackLogIntoMap(received, "received", mockLog); err != nil { + t.Error(err) + } + + if len(received) != len(expected) { + t.Fatalf("unpacked map length %v not equal expected length of %v", len(received), len(expected)) + } + for name, elem := range expected { + if !reflect.DeepEqual(elem, received[name]) { + t.Errorf("field %v does not match expected, want %v, got %v", name, elem, received[name]) + } + } +} + +func newMockLog(topics []common.Hash, txHash common.Hash) types.Log { + return types.Log{ + Address: common.HexToAddress("0x0"), + Topics: topics, + Data: hexutil.MustDecode(hexData), + BlockNumber: uint64(26), + TxHash: txHash, + TxIndex: 111, + BlockHash: common.BytesToHash([]byte{1, 2, 3, 4, 5}), + Index: 7, + Removed: false, + } +}

diff --git go-ethereum/accounts/abi/bind_v2/util.go celo/accounts/abi/bind_v2/util.go new file mode 100644 index 0000000000000000000000000000000000000000..c9d60fc101fa6d491c4f84bbbd38fba1cb76d214 --- /dev/null +++ celo/accounts/abi/bind_v2/util.go @@ -0,0 +1,76 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "fmt" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" +) + +// WaitMined waits for tx to be mined on the blockchain. +// It stops waiting when the context is canceled. +func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) { + queryTicker := time.NewTicker(time.Second) + defer queryTicker.Stop() + + logger := log.New("hash", tx.Hash()) + for { + receipt, err := b.TransactionReceipt(ctx, tx.Hash()) + if receipt != nil { + return receipt, nil + } + if err != nil { + logger.Trace("Receipt retrieval failed", "err", err) + } else { + logger.Trace("Transaction not yet mined") + } + // Wait for the next round. + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-queryTicker.C: + } + } +} + +// WaitDeployed waits for a contract deployment transaction and returns the on-chain +// contract address when it is mined. It stops waiting when ctx is canceled. +func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) { + if tx.To() != nil { + return common.Address{}, fmt.Errorf("tx is not contract creation") + } + receipt, err := WaitMined(ctx, b, tx) + if err != nil { + return common.Address{}, err + } + if receipt.ContractAddress == (common.Address{}) { + return common.Address{}, fmt.Errorf("zero address") + } + // Check that code has indeed been deployed at the address. + // This matters on pre-Homestead chains: OOG in the constructor + // could leave an empty account behind. + code, err := b.CodeAt(ctx, receipt.ContractAddress, nil) + if err == nil && len(code) == 0 { + err = ErrNoCodeAfterDeploy + } + return receipt.ContractAddress, err +}

diff --git go-ethereum/accounts/abi/bind_v2/template.go celo/accounts/abi/bind_v2/template.go new file mode 100644 index 0000000000000000000000000000000000000000..93a4651d751f9543dfdd9382a71273e574f99ccd --- /dev/null +++ celo/accounts/abi/bind_v2/template.go @@ -0,0 +1,497 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import "github.com/ethereum/go-ethereum/accounts/abi" + +// tmplData is the data structure required to fill the binding template. +type tmplData struct { + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContract // List of contracts to generate into this file + Libraries map[string]string // Map the bytecode's link pattern to the library name + Structs map[string]*tmplStruct // Contract struct type definitions +} + +// tmplContract contains the data needed to generate an individual contract binding. +type tmplContract struct { + Type string // Type name of the main contract binding + InputABI string // JSON ABI used as the input to generate the binding from + InputBin string // Optional EVM bytecode used to denetare deploy code from + FuncSigs map[string]string // Optional map: string signature -> 4-byte signature + Constructor abi.Method // Contract constructor for deploy parametrization + Calls map[string]*tmplMethod // Contract calls that only read state data + Transacts map[string]*tmplMethod // Contract calls that write state data + Fallback *tmplMethod // Additional special fallback function + Receive *tmplMethod // Additional special receive function + Events map[string]*tmplEvent // Contract events accessors + Libraries map[string]string // Same as tmplData, but filtered to only keep what the contract needs + Library bool // Indicator whether the contract is a library +} + +// tmplMethod is a wrapper around an abi.Method that contains a few preprocessed +// and cached data fields. +type tmplMethod struct { + Original abi.Method // Original method as parsed by the abi package + Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns) + Structured bool // Whether the returns should be accumulated into a struct +} + +// tmplEvent is a wrapper around an abi.Event that contains a few preprocessed +// and cached data fields. +type tmplEvent struct { + Original abi.Event // Original event as parsed by the abi package + Normalized abi.Event // Normalized version of the parsed fields +} + +// tmplField is a wrapper around a struct field with binding language +// struct type definition and relative filed name. +type tmplField struct { + Type string // Field type representation depends on target binding language + Name string // Field name converted from the raw user-defined field name + SolKind abi.Type // Raw abi type information +} + +// tmplStruct is a wrapper around an abi.tuple contains a auto-generated +// struct name. +type tmplStruct struct { + Name string // Auto-generated struct name(before solidity v0.5.11) or raw name. + Fields []*tmplField // Struct fields definition depends on the binding language. +} + +// tmplSource is language to template mapping containing all the supported +// programming languages the package can generate to. +var tmplSource = map[Lang]string{ + LangGo: tmplSourceGo, +} + +// tmplSourceGo is the Go source template use to generate the contract binding +// based on. +const tmplSourceGo = ` +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package {{.Package}} + +import ( + "math/big" + "strings" + "errors" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + bind "github.com/ethereum/go-ethereum/accounts/abi/bind_v2" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +{{$structs := .Structs}} +{{range $structs}} + // {{.Name}} is an auto generated low-level Go binding around an user-defined struct. + type {{.Name}} struct { + {{range $field := .Fields}} + {{$field.Name}} {{$field.Type}}{{end}} + } +{{end}} + +{{range $contract := .Contracts}} + // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. + var {{.Type}}MetaData = &bind.MetaData{ + ABI: "{{.InputABI}}", + {{if $contract.FuncSigs -}} + Sigs: map[string]string{ + {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}", + {{end}} + }, + {{end -}} + {{if .InputBin -}} + Bin: "0x{{.InputBin}}", + {{end}} + } + // {{.Type}}ABI is the input ABI used to generate the binding from. + // Deprecated: Use {{.Type}}MetaData.ABI instead. + var {{.Type}}ABI = {{.Type}}MetaData.ABI + + {{if $contract.FuncSigs}} + // Deprecated: Use {{.Type}}MetaData.Sigs instead. + // {{.Type}}FuncSigs maps the 4-byte function signature to its string representation. + var {{.Type}}FuncSigs = {{.Type}}MetaData.Sigs + {{end}} + + {{if .InputBin}} + // {{.Type}}Bin is the compiled bytecode used for deploying new contracts. + // Deprecated: Use {{.Type}}MetaData.Bin instead. + var {{.Type}}Bin = {{.Type}}MetaData.Bin + + // Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it. + func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) { + parsed, err := {{.Type}}MetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + {{range $pattern, $name := .Libraries}} + {{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend) + {{$contract.Type}}Bin = strings.Replace({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:], -1) + {{end}} + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}}) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &{{.Type}}{ contract: contract }, nil + } + {{end}} + + // {{.Type}} is an auto generated Go binding around an Ethereum contract. + type {{.Type}} struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls + } + + // {{.Type}}Session is an auto generated Go binding around an Ethereum contract, + // with pre-set call and transact options. + type {{.Type}}Session struct { + Contract *{{.Type}} // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session + } + + + // {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract. + type {{.Type}}Raw struct { + Contract *{{.Type}} // Generic contract binding to access the raw methods on + } + + // New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract. + func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) { + contract, err := bind{{.Type}}(address, backend) + if err != nil { + return nil, err + } + return &{{.Type}}{ contract: contract }, nil + } + + // bind{{.Type}} binds a generic wrapper to an already deployed contract. + func bind{{.Type}}(address common.Address, contract bind.ContractBackend) (*bind.BoundContract, error) { + parsed, err := Parse{{.Type}}ABI() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, contract), nil + } + + // Parse{{.Type}}ABI parses the ABI + func Parse{{.Type}}ABI() (*abi.ABI, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return nil, err + } + return &parsed, nil + } + + // Call invokes the (constant) contract method with params as input values and + // sets the output to result. The result type might be a single field for simple + // returns, a slice of interfaces for anonymous returns and a struct for named + // returns. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...) + } + + // Transfer initiates a plain transaction to move funds to the contract, calling + // its default method if one is available. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.contract.Transfer(opts) + } + + // Transact invokes the (paid) contract method with params as input values. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...) + } + + // TxObj returns an obj that can be used to get the transaction, send it, estimate it. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) TxObj(opts *bind.TransactOpts, method string, params ...interface{}) *bind.TxObject { + return _{{$contract.Type}}.Contract.contract.TxObj(opts, method, params...) + } + + // EstimateGas obtains an estimate for calling contract method with params as input values. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) EstimateGas(opts *bind.TransactOpts, method string, params ...interface{}) (uint64, error) { + return _{{$contract.Type}}.Contract.contract.EstimateGas(opts, method, params...) + } + + {{range .Calls}} + // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { + var out []interface{} + err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + {{if .Structured}} + outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) + if err != nil { + return *outstruct, err + } + {{range $i, $t := .Normalized.Outputs}} + outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return *outstruct, err + {{else}} + if err != nil { + return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err + } + {{range $i, $t := .Normalized.Outputs}} + out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err + {{end}} + } + + // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) { + return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + {{end}} + + {{range .Transacts}} + // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) *bind.TxObject { + return _{{$contract.Type}}.contract.TxObj(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) *bind.TxObject { + return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + {{end}} + + // TryParseLog attempts to parse a log. Returns the parsed log, evenName and whether it was succesfull + func (_{{$contract.Type}} *{{$contract.Type}}) TryParseLog(log types.Log) (eventName string, event interface{}, ok bool, err error) { + eventName, ok, err = _{{$contract.Type}}.contract.LogEventName(log) + if err != nil || !ok { + return "", nil, false, err + } + + switch eventName { {{range .Events}} + case "{{.Normalized.Name}}": + event, err = _{{$contract.Type}}.Parse{{.Normalized.Name}}(log){{end}} + } + if err != nil { + return "", nil, false, err + } + + return eventName, event, ok, nil + } + + {{if .Fallback}} + // Fallback is a paid mutator transaction binding the contract fallback function. + // + // Solidity: {{.Fallback.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) { + return _{{$contract.Type}}.contract.RawTransact(opts, calldata) + } + + // Fallback is a paid mutator transaction binding the contract fallback function. + // + // Solidity: {{.Fallback.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) + } + + {{end}} + + {{if .Receive}} + // Receive is a paid mutator transaction binding the contract receive function. + // + // Solidity: {{.Receive.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function + } + + // Receive is a paid mutator transaction binding the contract receive function. + // + // Solidity: {{.Receive.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts) + } + + {{end}} + + {{range .Events}} + // {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}}Iterator struct { + Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration + } + // Next advances the iterator to the subsequent event, returning whether there + // are any more events found. In case of a retrieval or parsing error, false is + // returned and Error() can be queried for the exact failure. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool { + // If the iterator failed, stop iterating + if (it.fail != nil) { + return false + } + // If the iterator completed, deliver directly whatever's available + if (it.done) { + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } + } + // Error returns any retrieval or parsing error occurred during filtering. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error { + return it.fail + } + // Close terminates the iteration process, releasing any pending underlying + // resources. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error { + it.sub.Unsubscribe() + return nil + } + + // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} + {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}} + Raw types.Log // Blockchain specific contextual infos + } + + // Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil + } + + // Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil + } + + // Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { + event := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil + } + + {{end}} +{{end}} +`

diff --git go-ethereum/accounts/abi/bind_v2/auth.go celo/accounts/abi/bind_v2/auth.go new file mode 100644 index 0000000000000000000000000000000000000000..ec4876d87fc80bed7f0f662aa46b4af327fb0e69 --- /dev/null +++ celo/accounts/abi/bind_v2/auth.go @@ -0,0 +1,182 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "crypto/ecdsa" + "errors" + "io" + "io/ioutil" + "math/big" + + "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/accounts/external" + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" +) + +// ErrNoChainID is returned whenever the user failed to specify a chain id. +var ErrNoChainID = errors.New("no chain id specified") + +// ErrNotAuthorized is returned when an account is not properly unlocked. +var ErrNotAuthorized = errors.New("not authorized to sign this account") + +// NewTransactor is a utility method to easily create a transaction signer from +// an encrypted json key stream and the associated passphrase. +// +// Deprecated: Use NewTransactorWithChainID instead. +func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) { + log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID") + json, err := ioutil.ReadAll(keyin) + if err != nil { + return nil, err + } + key, err := keystore.DecryptKey(json, passphrase) + if err != nil { + return nil, err + } + return NewKeyedTransactor(key.PrivateKey), nil +} + +// NewKeyStoreTransactor is a utility method to easily create a transaction signer from +// an decrypted key from a keystore +// +// Deprecated: Use NewKeyStoreTransactorWithChainID instead. +func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) { + log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID") + signer := types.LatestSignerForChainID(nil) + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, ErrNotAuthorized + } + signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes()) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewKeyedTransactor is a utility method to easily create a transaction signer +// from a single private key. +// +// Deprecated: Use NewKeyedTransactorWithChainID instead. +func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts { + log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID") + keyAddr := crypto.PubkeyToAddress(key.PublicKey) + signer := types.LatestSignerForChainID(nil) + return &TransactOpts{ + From: keyAddr, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != keyAddr { + return nil, ErrNotAuthorized + } + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + } +} + +// NewTransactorWithChainID is a utility method to easily create a transaction signer from +// an encrypted json key stream and the associated passphrase. +func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) { + json, err := ioutil.ReadAll(keyin) + if err != nil { + return nil, err + } + key, err := keystore.DecryptKey(json, passphrase) + if err != nil { + return nil, err + } + return NewKeyedTransactorWithChainID(key.PrivateKey, chainID) +} + +// NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from +// an decrypted key from a keystore. +// +// Deprecated: Use NewKeyedTransactorWithChainID instead. +func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) { + if chainID == nil { + return nil, ErrNoChainID + } + signer := types.LatestSignerForChainID(chainID) + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, ErrNotAuthorized + } + signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes()) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer +// from a single private key. +func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) { + keyAddr := crypto.PubkeyToAddress(key.PublicKey) + if chainID == nil { + return nil, ErrNoChainID + } + signer := types.LatestSignerForChainID(chainID) + return &TransactOpts{ + From: keyAddr, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != keyAddr { + return nil, ErrNotAuthorized + } + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewClefTransactor is a utility method to easily create a transaction signer +// with a clef backend. +func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts { + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, errors.New("not authorized to sign this account") + } + return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id + }, + Context: context.Background(), + } +}

diff --git go-ethereum/accounts/scwallet/apdu.go celo/accounts/scwallet/apdu.go deleted file mode 100644 index 32b63edeb1fce2d29926739bf3926de440ea8e81..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/apdu.go +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "encoding/binary" - "fmt" -) - -// commandAPDU represents an application data unit sent to a smartcard. -type commandAPDU struct { - Cla, Ins, P1, P2 uint8 // Class, Instruction, Parameter 1, Parameter 2 - Data []byte // Command data - Le uint8 // Command data length -} - -// serialize serializes a command APDU. -func (ca commandAPDU) serialize() ([]byte, error) { - buf := new(bytes.Buffer) - - if err := binary.Write(buf, binary.BigEndian, ca.Cla); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.Ins); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.P1); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.P2); err != nil { - return nil, err - } - if len(ca.Data) > 0 { - if err := binary.Write(buf, binary.BigEndian, uint8(len(ca.Data))); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.Data); err != nil { - return nil, err - } - } - if err := binary.Write(buf, binary.BigEndian, ca.Le); err != nil { - return nil, err - } - return buf.Bytes(), nil -} - -// responseAPDU represents an application data unit received from a smart card. -type responseAPDU struct { - Data []byte // response data - Sw1, Sw2 uint8 // status words 1 and 2 -} - -// deserialize deserializes a response APDU. -func (ra *responseAPDU) deserialize(data []byte) error { - if len(data) < 2 { - return fmt.Errorf("can not deserialize data: payload too short (%d < 2)", len(data)) - } - - ra.Data = make([]byte, len(data)-2) - - buf := bytes.NewReader(data) - if err := binary.Read(buf, binary.BigEndian, &ra.Data); err != nil { - return err - } - if err := binary.Read(buf, binary.BigEndian, &ra.Sw1); err != nil { - return err - } - if err := binary.Read(buf, binary.BigEndian, &ra.Sw2); err != nil { - return err - } - return nil -}

diff --git go-ethereum/accounts/scwallet/wallet.go celo/accounts/scwallet/wallet.go deleted file mode 100644 index 0caceabdcb01f1f7ba8264e89b00ffe4397d7a9e..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/wallet.go +++ /dev/null @@ -1,1085 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "context" - "crypto/hmac" - "crypto/sha256" - "crypto/sha512" - "encoding/asn1" - "encoding/binary" - "errors" - "fmt" - "math/big" - "regexp" - "sort" - "strings" - "sync" - "time" - - "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/log" - pcsc "github.com/gballet/go-libpcsclite" - "github.com/status-im/keycard-go/derivationpath" -) - -// ErrPairingPasswordNeeded is returned if opening the smart card requires pairing with a pairing -// password. In this case, the calling application should request user input to enter -// the pairing password and send it back. -var ErrPairingPasswordNeeded = errors.New("smartcard: pairing password needed") - -// ErrPINNeeded is returned if opening the smart card requires a PIN code. In -// this case, the calling application should request user input to enter the PIN -// and send it back. -var ErrPINNeeded = errors.New("smartcard: pin needed") - -// ErrPINUnblockNeeded is returned if opening the smart card requires a PIN code, -// but all PIN attempts have already been exhausted. In this case the calling -// application should request user input for the PUK and a new PIN code to set -// fo the card. -var ErrPINUnblockNeeded = errors.New("smartcard: pin unblock needed") - -// ErrAlreadyOpen is returned if the smart card is attempted to be opened, but -// there is already a paired and unlocked session. -var ErrAlreadyOpen = errors.New("smartcard: already open") - -// ErrPubkeyMismatch is returned if the public key recovered from a signature -// does not match the one expected by the user. -var ErrPubkeyMismatch = errors.New("smartcard: recovered public key mismatch") - -var ( - appletAID = []byte{0xA0, 0x00, 0x00, 0x08, 0x04, 0x00, 0x01, 0x01, 0x01} - // DerivationSignatureHash is used to derive the public key from the signature of this hash - DerivationSignatureHash = sha256.Sum256(common.Hash{}.Bytes()) -) - -// List of APDU command-related constants -const ( - claISO7816 = 0 - claSCWallet = 0x80 - - insSelect = 0xA4 - insGetResponse = 0xC0 - sw1GetResponse = 0x61 - sw1Ok = 0x90 - - insVerifyPin = 0x20 - insUnblockPin = 0x22 - insExportKey = 0xC2 - insSign = 0xC0 - insLoadKey = 0xD0 - insDeriveKey = 0xD1 - insStatus = 0xF2 -) - -// List of ADPU command parameters -const ( - P1DeriveKeyFromMaster = uint8(0x00) - P1DeriveKeyFromParent = uint8(0x01) - P1DeriveKeyFromCurrent = uint8(0x10) - statusP1WalletStatus = uint8(0x00) - statusP1Path = uint8(0x01) - signP1PrecomputedHash = uint8(0x01) - signP2OnlyBlock = uint8(0x81) - exportP1Any = uint8(0x00) - exportP2Pubkey = uint8(0x01) -) - -// Minimum time to wait between self derivation attempts, even it the user is -// requesting accounts like crazy. -const selfDeriveThrottling = time.Second - -// Wallet represents a smartcard wallet instance. -type Wallet struct { - Hub *Hub // A handle to the Hub that instantiated this wallet. - PublicKey []byte // The wallet's public key (used for communication and identification, not signing!) - - lock sync.Mutex // Lock that gates access to struct fields and communication with the card - card *pcsc.Card // A handle to the smartcard interface for the wallet. - session *Session // The secure communication session with the card - log log.Logger // Contextual logger to tag the base with its id - - deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported) - deriveNextAddrs []common.Address // Next derived account addresses for auto-discovery (multiple bases supported) - deriveChain ethereum.ChainStateReader // Blockchain state reader to discover used account with - deriveReq chan chan struct{} // Channel to request a self-derivation on - deriveQuit chan chan error // Channel to terminate the self-deriver with -} - -// NewWallet constructs and returns a new Wallet instance. -func NewWallet(hub *Hub, card *pcsc.Card) *Wallet { - wallet := &Wallet{ - Hub: hub, - card: card, - } - return wallet -} - -// transmit sends an APDU to the smartcard and receives and decodes the response. -// It automatically handles requests by the card to fetch the return data separately, -// and returns an error if the response status code is not success. -func transmit(card *pcsc.Card, command *commandAPDU) (*responseAPDU, error) { - data, err := command.serialize() - if err != nil { - return nil, err - } - - responseData, _, err := card.Transmit(data) - if err != nil { - return nil, err - } - - response := new(responseAPDU) - if err = response.deserialize(responseData); err != nil { - return nil, err - } - - // Are we being asked to fetch the response separately? - if response.Sw1 == sw1GetResponse && (command.Cla != claISO7816 || command.Ins != insGetResponse) { - return transmit(card, &commandAPDU{ - Cla: claISO7816, - Ins: insGetResponse, - P1: 0, - P2: 0, - Data: nil, - Le: response.Sw2, - }) - } - - if response.Sw1 != sw1Ok { - return nil, fmt.Errorf("unexpected insecure response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", command.Cla, command.Ins, response.Sw1, response.Sw2) - } - - return response, nil -} - -// applicationInfo encodes information about the smartcard application - its -// instance UID and public key. -type applicationInfo struct { - InstanceUID []byte `asn1:"tag:15"` - PublicKey []byte `asn1:"tag:0"` -} - -// connect connects to the wallet application and establishes a secure channel with it. -// must be called before any other interaction with the wallet. -func (w *Wallet) connect() error { - w.lock.Lock() - defer w.lock.Unlock() - - appinfo, err := w.doselect() - if err != nil { - return err - } - - channel, err := NewSecureChannelSession(w.card, appinfo.PublicKey) - if err != nil { - return err - } - - w.PublicKey = appinfo.PublicKey - w.log = log.New("url", w.URL()) - w.session = &Session{ - Wallet: w, - Channel: channel, - } - return nil -} - -// doselect is an internal (unlocked) function to send a SELECT APDU to the card. -func (w *Wallet) doselect() (*applicationInfo, error) { - response, err := transmit(w.card, &commandAPDU{ - Cla: claISO7816, - Ins: insSelect, - P1: 4, - P2: 0, - Data: appletAID, - }) - if err != nil { - return nil, err - } - - appinfo := new(applicationInfo) - if _, err := asn1.UnmarshalWithParams(response.Data, appinfo, "tag:4"); err != nil { - return nil, err - } - return appinfo, nil -} - -// ping checks the card's status and returns an error if unsuccessful. -func (w *Wallet) ping() error { - w.lock.Lock() - defer w.lock.Unlock() - - // We can't ping if not paired - if !w.session.paired() { - return nil - } - if _, err := w.session.walletStatus(); err != nil { - return err - } - return nil -} - -// release releases any resources held by an open wallet instance. -func (w *Wallet) release() error { - if w.session != nil { - return w.session.release() - } - return nil -} - -// pair is an internal (unlocked) function for establishing a new pairing -// with the wallet. -func (w *Wallet) pair(puk []byte) error { - if w.session.paired() { - return fmt.Errorf("wallet already paired") - } - pairing, err := w.session.pair(puk) - if err != nil { - return err - } - if err = w.Hub.setPairing(w, &pairing); err != nil { - return err - } - return w.session.authenticate(pairing) -} - -// Unpair deletes an existing wallet pairing. -func (w *Wallet) Unpair(pin []byte) error { - w.lock.Lock() - defer w.lock.Unlock() - - if !w.session.paired() { - return fmt.Errorf("wallet %x not paired", w.PublicKey) - } - if err := w.session.verifyPin(pin); err != nil { - return fmt.Errorf("failed to verify pin: %s", err) - } - if err := w.session.unpair(); err != nil { - return fmt.Errorf("failed to unpair: %s", err) - } - if err := w.Hub.setPairing(w, nil); err != nil { - return err - } - return nil -} - -// URL retrieves the canonical path under which this wallet is reachable. It is -// user by upper layers to define a sorting order over all wallets from multiple -// backends. -func (w *Wallet) URL() accounts.URL { - return accounts.URL{ - Scheme: w.Hub.scheme, - Path: fmt.Sprintf("%x", w.PublicKey[1:5]), // Byte #0 isn't unique; 1:5 covers << 64K cards, bump to 1:9 for << 4M - } -} - -// Status returns a textual status to aid the user in the current state of the -// wallet. It also returns an error indicating any failure the wallet might have -// encountered. -func (w *Wallet) Status() (string, error) { - w.lock.Lock() - defer w.lock.Unlock() - - // If the card is not paired, we can only wait - if !w.session.paired() { - return "Unpaired, waiting for pairing password", nil - } - // Yay, we have an encrypted session, retrieve the actual status - status, err := w.session.walletStatus() - if err != nil { - return fmt.Sprintf("Failed: %v", err), err - } - switch { - case !w.session.verified && status.PinRetryCount == 0 && status.PukRetryCount == 0: - return "Bricked, waiting for full wipe", nil - case !w.session.verified && status.PinRetryCount == 0: - return fmt.Sprintf("Blocked, waiting for PUK (%d attempts left) and new PIN", status.PukRetryCount), nil - case !w.session.verified: - return fmt.Sprintf("Locked, waiting for PIN (%d attempts left)", status.PinRetryCount), nil - case !status.Initialized: - return "Empty, waiting for initialization", nil - default: - return "Online", nil - } -} - -// Open initializes access to a wallet instance. It is not meant to unlock or -// decrypt account keys, rather simply to establish a connection to hardware -// wallets and/or to access derivation seeds. -// -// The passphrase parameter may or may not be used by the implementation of a -// particular wallet instance. The reason there is no passwordless open method -// is to strive towards a uniform wallet handling, oblivious to the different -// backend providers. -// -// Please note, if you open a wallet, you must close it to release any allocated -// resources (especially important when working with hardware wallets). -func (w *Wallet) Open(passphrase string) error { - w.lock.Lock() - defer w.lock.Unlock() - - // If the session is already open, bail out - if w.session.verified { - return ErrAlreadyOpen - } - // If the smart card is not yet paired, attempt to do so either from a previous - // pairing key or form the supplied PUK code. - if !w.session.paired() { - // If a previous pairing exists, only ever try to use that - if pairing := w.Hub.pairing(w); pairing != nil { - if err := w.session.authenticate(*pairing); err != nil { - return fmt.Errorf("failed to authenticate card %x: %s", w.PublicKey[:4], err) - } - // Pairing still ok, fall through to PIN checks - } else { - // If no passphrase was supplied, request the PUK from the user - if passphrase == "" { - return ErrPairingPasswordNeeded - } - // Attempt to pair the smart card with the user supplied PUK - if err := w.pair([]byte(passphrase)); err != nil { - return err - } - // Pairing succeeded, fall through to PIN checks. This will of course fail, - // but we can't return ErrPINNeeded directly here because we don't know whether - // a PIN check or a PIN reset is needed. - passphrase = "" - } - } - // The smart card was successfully paired, retrieve its status to check whether - // PIN verification or unblocking is needed. - status, err := w.session.walletStatus() - if err != nil { - return err - } - // Request the appropriate next authentication data, or use the one supplied - switch { - case passphrase == "" && status.PinRetryCount > 0: - return ErrPINNeeded - case passphrase == "": - return ErrPINUnblockNeeded - case status.PinRetryCount > 0: - if !regexp.MustCompile(`^[0-9]{6,}$`).MatchString(passphrase) { - w.log.Error("PIN needs to be at least 6 digits") - return ErrPINNeeded - } - if err := w.session.verifyPin([]byte(passphrase)); err != nil { - return err - } - default: - if !regexp.MustCompile(`^[0-9]{12,}$`).MatchString(passphrase) { - w.log.Error("PUK needs to be at least 12 digits") - return ErrPINUnblockNeeded - } - if err := w.session.unblockPin([]byte(passphrase)); err != nil { - return err - } - } - // Smart card paired and unlocked, initialize and register - w.deriveReq = make(chan chan struct{}) - w.deriveQuit = make(chan chan error) - - go w.selfDerive() - - // Notify anyone listening for wallet events that a new device is accessible - go w.Hub.updateFeed.Send(accounts.WalletEvent{Wallet: w, Kind: accounts.WalletOpened}) - - return nil -} - -// Close stops and closes the wallet, freeing any resources. -func (w *Wallet) Close() error { - // Ensure the wallet was opened - w.lock.Lock() - dQuit := w.deriveQuit - w.lock.Unlock() - - // Terminate the self-derivations - var derr error - if dQuit != nil { - errc := make(chan error) - dQuit <- errc - derr = <-errc // Save for later, we *must* close the USB - } - // Terminate the device connection - w.lock.Lock() - defer w.lock.Unlock() - - w.deriveQuit = nil - w.deriveReq = nil - - if err := w.release(); err != nil { - return err - } - return derr -} - -// selfDerive is an account derivation loop that upon request attempts to find -// new non-zero accounts. -func (w *Wallet) selfDerive() { - w.log.Debug("Smart card wallet self-derivation started") - defer w.log.Debug("Smart card wallet self-derivation stopped") - - // Execute self-derivations until termination or error - var ( - reqc chan struct{} - errc chan error - err error - ) - for errc == nil && err == nil { - // Wait until either derivation or termination is requested - select { - case errc = <-w.deriveQuit: - // Termination requested - continue - case reqc = <-w.deriveReq: - // Account discovery requested - } - // Derivation needs a chain and device access, skip if either unavailable - w.lock.Lock() - if w.session == nil || w.deriveChain == nil { - w.lock.Unlock() - reqc <- struct{}{} - continue - } - pairing := w.Hub.pairing(w) - - // Device lock obtained, derive the next batch of accounts - var ( - paths []accounts.DerivationPath - nextAcc accounts.Account - - nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...) - nextAddrs = append([]common.Address{}, w.deriveNextAddrs...) - - context = context.Background() - ) - for i := 0; i < len(nextAddrs); i++ { - for empty := false; !empty; { - // Retrieve the next derived Ethereum account - if nextAddrs[i] == (common.Address{}) { - if nextAcc, err = w.session.derive(nextPaths[i]); err != nil { - w.log.Warn("Smartcard wallet account derivation failed", "err", err) - break - } - nextAddrs[i] = nextAcc.Address - } - // Check the account's status against the current chain state - var ( - balance *big.Int - nonce uint64 - ) - balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil) - if err != nil { - w.log.Warn("Smartcard wallet balance retrieval failed", "err", err) - break - } - nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil) - if err != nil { - w.log.Warn("Smartcard wallet nonce retrieval failed", "err", err) - break - } - // If the next account is empty, stop self-derivation, but add for the last base path - if balance.Sign() == 0 && nonce == 0 { - empty = true - if i < len(nextAddrs)-1 { - break - } - } - // We've just self-derived a new account, start tracking it locally - path := make(accounts.DerivationPath, len(nextPaths[i])) - copy(path[:], nextPaths[i][:]) - paths = append(paths, path) - - // Display a log message to the user for new (or previously empty accounts) - if _, known := pairing.Accounts[nextAddrs[i]]; !known || !empty || nextAddrs[i] != w.deriveNextAddrs[i] { - w.log.Info("Smartcard wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce) - } - pairing.Accounts[nextAddrs[i]] = path - - // Fetch the next potential account - if !empty { - nextAddrs[i] = common.Address{} - nextPaths[i][len(nextPaths[i])-1]++ - } - } - } - // If there are new accounts, write them out - if len(paths) > 0 { - err = w.Hub.setPairing(w, pairing) - } - // Shift the self-derivation forward - w.deriveNextAddrs = nextAddrs - w.deriveNextPaths = nextPaths - - // Self derivation complete, release device lock - w.lock.Unlock() - - // Notify the user of termination and loop after a bit of time (to avoid trashing) - reqc <- struct{}{} - if err == nil { - select { - case errc = <-w.deriveQuit: - // Termination requested, abort - case <-time.After(selfDeriveThrottling): - // Waited enough, willing to self-derive again - } - } - } - // In case of error, wait for termination - if err != nil { - w.log.Debug("Smartcard wallet self-derivation failed", "err", err) - errc = <-w.deriveQuit - } - errc <- err -} - -// Accounts retrieves the list of signing accounts the wallet is currently aware -// of. For hierarchical deterministic wallets, the list will not be exhaustive, -// rather only contain the accounts explicitly pinned during account derivation. -func (w *Wallet) Accounts() []accounts.Account { - // Attempt self-derivation if it's running - reqc := make(chan struct{}, 1) - select { - case w.deriveReq <- reqc: - // Self-derivation request accepted, wait for it - <-reqc - default: - // Self-derivation offline, throttled or busy, skip - } - - w.lock.Lock() - defer w.lock.Unlock() - - if pairing := w.Hub.pairing(w); pairing != nil { - ret := make([]accounts.Account, 0, len(pairing.Accounts)) - for address, path := range pairing.Accounts { - ret = append(ret, w.makeAccount(address, path)) - } - sort.Sort(accounts.AccountsByURL(ret)) - return ret - } - return nil -} - -func (w *Wallet) makeAccount(address common.Address, path accounts.DerivationPath) accounts.Account { - return accounts.Account{ - Address: address, - URL: accounts.URL{ - Scheme: w.Hub.scheme, - Path: fmt.Sprintf("%x/%s", w.PublicKey[1:3], path.String()), - }, - } -} - -// Contains returns whether an account is part of this particular wallet or not. -func (w *Wallet) Contains(account accounts.Account) bool { - if pairing := w.Hub.pairing(w); pairing != nil { - _, ok := pairing.Accounts[account.Address] - return ok - } - return false -} - -// Initialize installs a keypair generated from the provided key into the wallet. -func (w *Wallet) Initialize(seed []byte) error { - go w.selfDerive() - // DO NOT lock at this stage, as the initialize - // function relies on Status() - return w.session.initialize(seed) -} - -// Derive attempts to explicitly derive a hierarchical deterministic account at -// the specified derivation path. If requested, the derived account will be added -// to the wallet's tracked account list. -func (w *Wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { - w.lock.Lock() - defer w.lock.Unlock() - - account, err := w.session.derive(path) - if err != nil { - return accounts.Account{}, err - } - - if pin { - pairing := w.Hub.pairing(w) - pairing.Accounts[account.Address] = path - if err := w.Hub.setPairing(w, pairing); err != nil { - return accounts.Account{}, err - } - } - - return account, nil -} - -// SelfDerive sets a base account derivation path from which the wallet attempts -// to discover non zero accounts and automatically add them to list of tracked -// accounts. -// -// Note, self derivation will increment the last component of the specified path -// opposed to decending into a child path to allow discovering accounts starting -// from non zero components. -// -// Some hardware wallets switched derivation paths through their evolution, so -// this method supports providing multiple bases to discover old user accounts -// too. Only the last base will be used to derive the next empty account. -// -// You can disable automatic account discovery by calling SelfDerive with a nil -// chain state reader. -func (w *Wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { - w.lock.Lock() - defer w.lock.Unlock() - - w.deriveNextPaths = make([]accounts.DerivationPath, len(bases)) - for i, base := range bases { - w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base)) - copy(w.deriveNextPaths[i][:], base[:]) - } - w.deriveNextAddrs = make([]common.Address, len(bases)) - w.deriveChain = chain -} - -// SignData requests the wallet to sign the hash of the given data. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignDataWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) { - return w.signHash(account, crypto.Keccak256(data)) -} - -func (w *Wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { - w.lock.Lock() - defer w.lock.Unlock() - - path, err := w.findAccountPath(account) - if err != nil { - return nil, err - } - - return w.session.sign(path, hash) -} - -// SignTx requests the wallet to sign the given transaction. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignTxWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { - signer := types.LatestSignerForChainID(chainID) - hash := signer.Hash(tx) - sig, err := w.signHash(account, hash[:]) - if err != nil { - return nil, err - } - return tx.WithSignature(signer, sig) -} - -// SignDataWithPassphrase requests the wallet to sign the given hash with the -// given passphrase as extra authentication information. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -func (w *Wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { - return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(data)) -} - -func (w *Wallet) signHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) { - if !w.session.verified { - if err := w.Open(passphrase); err != nil { - return nil, err - } - } - - return w.signHash(account, hash) -} - -// SignText requests the wallet to sign the hash of a given piece of data, prefixed -// by the Ethereum prefix scheme -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignHashWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignText(account accounts.Account, text []byte) ([]byte, error) { - return w.signHash(account, accounts.TextHash(text)) -} - -// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the -// given hash with the given account using passphrase as extra authentication -func (w *Wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) { - return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(accounts.TextHash(text))) -} - -// SignTxWithPassphrase requests the wallet to sign the given transaction, with the -// given passphrase as extra authentication information. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -func (w *Wallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { - if !w.session.verified { - if err := w.Open(passphrase); err != nil { - return nil, err - } - } - return w.SignTx(account, tx, chainID) -} - -// findAccountPath returns the derivation path for the provided account. -// It first checks for the address in the list of pinned accounts, and if it is -// not found, attempts to parse the derivation path from the account's URL. -func (w *Wallet) findAccountPath(account accounts.Account) (accounts.DerivationPath, error) { - pairing := w.Hub.pairing(w) - if path, ok := pairing.Accounts[account.Address]; ok { - return path, nil - } - - // Look for the path in the URL - if account.URL.Scheme != w.Hub.scheme { - return nil, fmt.Errorf("scheme %s does not match wallet scheme %s", account.URL.Scheme, w.Hub.scheme) - } - - parts := strings.SplitN(account.URL.Path, "/", 2) - if len(parts) != 2 { - return nil, fmt.Errorf("invalid URL format: %s", account.URL) - } - - if parts[0] != fmt.Sprintf("%x", w.PublicKey[1:3]) { - return nil, fmt.Errorf("URL %s is not for this wallet", account.URL) - } - - return accounts.ParseDerivationPath(parts[1]) -} - -// Session represents a secured communication session with the wallet. -type Session struct { - Wallet *Wallet // A handle to the wallet that opened the session - Channel *SecureChannelSession // A secure channel for encrypted messages - verified bool // Whether the pin has been verified in this session. -} - -// pair establishes a new pairing over this channel, using the provided secret. -func (s *Session) pair(secret []byte) (smartcardPairing, error) { - err := s.Channel.Pair(secret) - if err != nil { - return smartcardPairing{}, err - } - - return smartcardPairing{ - PublicKey: s.Wallet.PublicKey, - PairingIndex: s.Channel.PairingIndex, - PairingKey: s.Channel.PairingKey, - Accounts: make(map[common.Address]accounts.DerivationPath), - }, nil -} - -// unpair deletes an existing pairing. -func (s *Session) unpair() error { - if !s.verified { - return fmt.Errorf("unpair requires that the PIN be verified") - } - return s.Channel.Unpair() -} - -// verifyPin unlocks a wallet with the provided pin. -func (s *Session) verifyPin(pin []byte) error { - if _, err := s.Channel.transmitEncrypted(claSCWallet, insVerifyPin, 0, 0, pin); err != nil { - return err - } - s.verified = true - return nil -} - -// unblockPin unblocks a wallet with the provided puk and resets the pin to the -// new one specified. -func (s *Session) unblockPin(pukpin []byte) error { - if _, err := s.Channel.transmitEncrypted(claSCWallet, insUnblockPin, 0, 0, pukpin); err != nil { - return err - } - s.verified = true - return nil -} - -// release releases resources associated with the channel. -func (s *Session) release() error { - return s.Wallet.card.Disconnect(pcsc.LeaveCard) -} - -// paired returns true if a valid pairing exists. -func (s *Session) paired() bool { - return s.Channel.PairingKey != nil -} - -// authenticate uses an existing pairing to establish a secure channel. -func (s *Session) authenticate(pairing smartcardPairing) error { - if !bytes.Equal(s.Wallet.PublicKey, pairing.PublicKey) { - return fmt.Errorf("cannot pair using another wallet's pairing; %x != %x", s.Wallet.PublicKey, pairing.PublicKey) - } - s.Channel.PairingKey = pairing.PairingKey - s.Channel.PairingIndex = pairing.PairingIndex - return s.Channel.Open() -} - -// walletStatus describes a smartcard wallet's status information. -type walletStatus struct { - PinRetryCount int // Number of remaining PIN retries - PukRetryCount int // Number of remaining PUK retries - Initialized bool // Whether the card has been initialized with a private key -} - -// walletStatus fetches the wallet's status from the card. -func (s *Session) walletStatus() (*walletStatus, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1WalletStatus, 0, nil) - if err != nil { - return nil, err - } - - status := new(walletStatus) - if _, err := asn1.UnmarshalWithParams(response.Data, status, "tag:3"); err != nil { - return nil, err - } - return status, nil -} - -// derivationPath fetches the wallet's current derivation path from the card. -//lint:ignore U1000 needs to be added to the console interface -func (s *Session) derivationPath() (accounts.DerivationPath, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1Path, 0, nil) - if err != nil { - return nil, err - } - buf := bytes.NewReader(response.Data) - path := make(accounts.DerivationPath, len(response.Data)/4) - return path, binary.Read(buf, binary.BigEndian, &path) -} - -// initializeData contains data needed to initialize the smartcard wallet. -type initializeData struct { - PublicKey []byte `asn1:"tag:0"` - PrivateKey []byte `asn1:"tag:1"` - ChainCode []byte `asn1:"tag:2"` -} - -// initialize initializes the card with new key data. -func (s *Session) initialize(seed []byte) error { - // Check that the wallet isn't currently initialized, - // otherwise the key would be overwritten. - status, err := s.Wallet.Status() - if err != nil { - return err - } - if status == "Online" { - return fmt.Errorf("card is already initialized, cowardly refusing to proceed") - } - - s.Wallet.lock.Lock() - defer s.Wallet.lock.Unlock() - - // HMAC the seed to produce the private key and chain code - mac := hmac.New(sha512.New, []byte("Bitcoin seed")) - mac.Write(seed) - seed = mac.Sum(nil) - - key, err := crypto.ToECDSA(seed[:32]) - if err != nil { - return err - } - - id := initializeData{} - id.PublicKey = crypto.FromECDSAPub(&key.PublicKey) - id.PrivateKey = seed[:32] - id.ChainCode = seed[32:] - data, err := asn1.Marshal(id) - if err != nil { - return err - } - - // Nasty hack to force the top-level struct tag to be context-specific - data[0] = 0xA1 - - _, err = s.Channel.transmitEncrypted(claSCWallet, insLoadKey, 0x02, 0, data) - return err -} - -// derive derives a new HD key path on the card. -func (s *Session) derive(path accounts.DerivationPath) (accounts.Account, error) { - startingPoint, path, err := derivationpath.Decode(path.String()) - if err != nil { - return accounts.Account{}, err - } - - var p1 uint8 - switch startingPoint { - case derivationpath.StartingPointMaster: - p1 = P1DeriveKeyFromMaster - case derivationpath.StartingPointParent: - p1 = P1DeriveKeyFromParent - case derivationpath.StartingPointCurrent: - p1 = P1DeriveKeyFromCurrent - default: - return accounts.Account{}, fmt.Errorf("invalid startingPoint %d", startingPoint) - } - - data := new(bytes.Buffer) - for _, segment := range path { - if err := binary.Write(data, binary.BigEndian, segment); err != nil { - return accounts.Account{}, err - } - } - - _, err = s.Channel.transmitEncrypted(claSCWallet, insDeriveKey, p1, 0, data.Bytes()) - if err != nil { - return accounts.Account{}, err - } - - response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, 0, 0, DerivationSignatureHash[:]) - if err != nil { - return accounts.Account{}, err - } - - sigdata := new(signatureData) - if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil { - return accounts.Account{}, err - } - rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes() - sig := make([]byte, 65) - copy(sig[32-len(rbytes):32], rbytes) - copy(sig[64-len(sbytes):64], sbytes) - - if err := confirmPublicKey(sig, sigdata.PublicKey); err != nil { - return accounts.Account{}, err - } - pub, err := crypto.UnmarshalPubkey(sigdata.PublicKey) - if err != nil { - return accounts.Account{}, err - } - return s.Wallet.makeAccount(crypto.PubkeyToAddress(*pub), path), nil -} - -// keyExport contains information on an exported keypair. -//lint:ignore U1000 needs to be added to the console interface -type keyExport struct { - PublicKey []byte `asn1:"tag:0"` - PrivateKey []byte `asn1:"tag:1,optional"` -} - -// publicKey returns the public key for the current derivation path. -//lint:ignore U1000 needs to be added to the console interface -func (s *Session) publicKey() ([]byte, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insExportKey, exportP1Any, exportP2Pubkey, nil) - if err != nil { - return nil, err - } - keys := new(keyExport) - if _, err := asn1.UnmarshalWithParams(response.Data, keys, "tag:1"); err != nil { - return nil, err - } - return keys.PublicKey, nil -} - -// signatureData contains information on a signature - the signature itself and -// the corresponding public key. -type signatureData struct { - PublicKey []byte `asn1:"tag:0"` - Signature struct { - R *big.Int - S *big.Int - } -} - -// sign asks the card to sign a message, and returns a valid signature after -// recovering the v value. -func (s *Session) sign(path accounts.DerivationPath, hash []byte) ([]byte, error) { - startTime := time.Now() - _, err := s.derive(path) - if err != nil { - return nil, err - } - deriveTime := time.Now() - - response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, signP1PrecomputedHash, signP2OnlyBlock, hash) - if err != nil { - return nil, err - } - sigdata := new(signatureData) - if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil { - return nil, err - } - // Serialize the signature - rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes() - sig := make([]byte, 65) - copy(sig[32-len(rbytes):32], rbytes) - copy(sig[64-len(sbytes):64], sbytes) - - // Recover the V value. - sig, err = makeRecoverableSignature(hash, sig, sigdata.PublicKey) - if err != nil { - return nil, err - } - log.Debug("Signed using smartcard", "deriveTime", deriveTime.Sub(startTime), "signingTime", time.Since(deriveTime)) - - return sig, nil -} - -// confirmPublicKey confirms that the given signature belongs to the specified key. -func confirmPublicKey(sig, pubkey []byte) error { - _, err := makeRecoverableSignature(DerivationSignatureHash[:], sig, pubkey) - return err -} - -// makeRecoverableSignature uses a signature and an expected public key to -// recover the v value and produce a recoverable signature. -func makeRecoverableSignature(hash, sig, expectedPubkey []byte) ([]byte, error) { - var libraryError error - for v := 0; v < 2; v++ { - sig[64] = byte(v) - if pubkey, err := crypto.Ecrecover(hash, sig); err == nil { - if bytes.Equal(pubkey, expectedPubkey) { - return sig, nil - } - } else { - libraryError = err - } - } - if libraryError != nil { - return nil, libraryError - } - return nil, ErrPubkeyMismatch -}

diff --git go-ethereum/accounts/scwallet/securechannel.go celo/accounts/scwallet/securechannel.go deleted file mode 100644 index b3ae6a73d472950bebfd4d6aa2ae89b84ec33c73..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/securechannel.go +++ /dev/null @@ -1,339 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "crypto/aes" - "crypto/cipher" - "crypto/elliptic" - "crypto/rand" - "crypto/sha256" - "crypto/sha512" - "fmt" - - "github.com/ethereum/go-ethereum/crypto" - pcsc "github.com/gballet/go-libpcsclite" - "golang.org/x/crypto/pbkdf2" - "golang.org/x/text/unicode/norm" -) - -const ( - maxPayloadSize = 223 - pairP1FirstStep = 0 - pairP1LastStep = 1 - - scSecretLength = 32 - scBlockSize = 16 - - insOpenSecureChannel = 0x10 - insMutuallyAuthenticate = 0x11 - insPair = 0x12 - insUnpair = 0x13 - - pairingSalt = "Keycard Pairing Password Salt" -) - -// SecureChannelSession enables secure communication with a hardware wallet. -type SecureChannelSession struct { - card *pcsc.Card // A handle to the smartcard for communication - secret []byte // A shared secret generated from our ECDSA keys - publicKey []byte // Our own ephemeral public key - PairingKey []byte // A permanent shared secret for a pairing, if present - sessionEncKey []byte // The current session encryption key - sessionMacKey []byte // The current session MAC key - iv []byte // The current IV - PairingIndex uint8 // The pairing index -} - -// NewSecureChannelSession creates a new secure channel for the given card and public key. -func NewSecureChannelSession(card *pcsc.Card, keyData []byte) (*SecureChannelSession, error) { - // Generate an ECDSA keypair for ourselves - key, err := crypto.GenerateKey() - if err != nil { - return nil, err - } - cardPublic, err := crypto.UnmarshalPubkey(keyData) - if err != nil { - return nil, fmt.Errorf("could not unmarshal public key from card: %v", err) - } - secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes()) - return &SecureChannelSession{ - card: card, - secret: secret.Bytes(), - publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y), - }, nil -} - -// Pair establishes a new pairing with the smartcard. -func (s *SecureChannelSession) Pair(pairingPassword []byte) error { - secretHash := pbkdf2.Key(norm.NFKD.Bytes(pairingPassword), norm.NFKD.Bytes([]byte(pairingSalt)), 50000, 32, sha256.New) - - challenge := make([]byte, 32) - if _, err := rand.Read(challenge); err != nil { - return err - } - - response, err := s.pair(pairP1FirstStep, challenge) - if err != nil { - return err - } - - md := sha256.New() - md.Write(secretHash[:]) - md.Write(challenge) - - expectedCryptogram := md.Sum(nil) - cardCryptogram := response.Data[:32] - cardChallenge := response.Data[32:64] - - if !bytes.Equal(expectedCryptogram, cardCryptogram) { - return fmt.Errorf("invalid card cryptogram %v != %v", expectedCryptogram, cardCryptogram) - } - - md.Reset() - md.Write(secretHash[:]) - md.Write(cardChallenge) - response, err = s.pair(pairP1LastStep, md.Sum(nil)) - if err != nil { - return err - } - - md.Reset() - md.Write(secretHash[:]) - md.Write(response.Data[1:]) - s.PairingKey = md.Sum(nil) - s.PairingIndex = response.Data[0] - - return nil -} - -// Unpair disestablishes an existing pairing. -func (s *SecureChannelSession) Unpair() error { - if s.PairingKey == nil { - return fmt.Errorf("cannot unpair: not paired") - } - - _, err := s.transmitEncrypted(claSCWallet, insUnpair, s.PairingIndex, 0, []byte{}) - if err != nil { - return err - } - s.PairingKey = nil - // Close channel - s.iv = nil - return nil -} - -// Open initializes the secure channel. -func (s *SecureChannelSession) Open() error { - if s.iv != nil { - return fmt.Errorf("session already opened") - } - - response, err := s.open() - if err != nil { - return err - } - - // Generate the encryption/mac key by hashing our shared secret, - // pairing key, and the first bytes returned from the Open APDU. - md := sha512.New() - md.Write(s.secret) - md.Write(s.PairingKey) - md.Write(response.Data[:scSecretLength]) - keyData := md.Sum(nil) - s.sessionEncKey = keyData[:scSecretLength] - s.sessionMacKey = keyData[scSecretLength : scSecretLength*2] - - // The IV is the last bytes returned from the Open APDU. - s.iv = response.Data[scSecretLength:] - - return s.mutuallyAuthenticate() -} - -// mutuallyAuthenticate is an internal method to authenticate both ends of the -// connection. -func (s *SecureChannelSession) mutuallyAuthenticate() error { - data := make([]byte, scSecretLength) - if _, err := rand.Read(data); err != nil { - return err - } - - response, err := s.transmitEncrypted(claSCWallet, insMutuallyAuthenticate, 0, 0, data) - if err != nil { - return err - } - if response.Sw1 != 0x90 || response.Sw2 != 0x00 { - return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: 0x%x%x", response.Sw1, response.Sw2) - } - - if len(response.Data) != scSecretLength { - return fmt.Errorf("response from MUTUALLY_AUTHENTICATE was %d bytes, expected %d", len(response.Data), scSecretLength) - } - - return nil -} - -// open is an internal method that sends an open APDU. -func (s *SecureChannelSession) open() (*responseAPDU, error) { - return transmit(s.card, &commandAPDU{ - Cla: claSCWallet, - Ins: insOpenSecureChannel, - P1: s.PairingIndex, - P2: 0, - Data: s.publicKey, - Le: 0, - }) -} - -// pair is an internal method that sends a pair APDU. -func (s *SecureChannelSession) pair(p1 uint8, data []byte) (*responseAPDU, error) { - return transmit(s.card, &commandAPDU{ - Cla: claSCWallet, - Ins: insPair, - P1: p1, - P2: 0, - Data: data, - Le: 0, - }) -} - -// transmitEncrypted sends an encrypted message, and decrypts and returns the response. -func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []byte) (*responseAPDU, error) { - if s.iv == nil { - return nil, fmt.Errorf("channel not open") - } - - data, err := s.encryptAPDU(data) - if err != nil { - return nil, err - } - meta := [16]byte{cla, ins, p1, p2, byte(len(data) + scBlockSize)} - if err = s.updateIV(meta[:], data); err != nil { - return nil, err - } - - fulldata := make([]byte, len(s.iv)+len(data)) - copy(fulldata, s.iv) - copy(fulldata[len(s.iv):], data) - - response, err := transmit(s.card, &commandAPDU{ - Cla: cla, - Ins: ins, - P1: p1, - P2: p2, - Data: fulldata, - }) - if err != nil { - return nil, err - } - - rmeta := [16]byte{byte(len(response.Data))} - rmac := response.Data[:len(s.iv)] - rdata := response.Data[len(s.iv):] - plainData, err := s.decryptAPDU(rdata) - if err != nil { - return nil, err - } - - if err = s.updateIV(rmeta[:], rdata); err != nil { - return nil, err - } - if !bytes.Equal(s.iv, rmac) { - return nil, fmt.Errorf("invalid MAC in response") - } - - rapdu := &responseAPDU{} - rapdu.deserialize(plainData) - - if rapdu.Sw1 != sw1Ok { - return nil, fmt.Errorf("unexpected response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", cla, ins, rapdu.Sw1, rapdu.Sw2) - } - - return rapdu, nil -} - -// encryptAPDU is an internal method that serializes and encrypts an APDU. -func (s *SecureChannelSession) encryptAPDU(data []byte) ([]byte, error) { - if len(data) > maxPayloadSize { - return nil, fmt.Errorf("payload of %d bytes exceeds maximum of %d", len(data), maxPayloadSize) - } - data = pad(data, 0x80) - - ret := make([]byte, len(data)) - - a, err := aes.NewCipher(s.sessionEncKey) - if err != nil { - return nil, err - } - crypter := cipher.NewCBCEncrypter(a, s.iv) - crypter.CryptBlocks(ret, data) - return ret, nil -} - -// pad applies message padding to a 16 byte boundary. -func pad(data []byte, terminator byte) []byte { - padded := make([]byte, (len(data)/16+1)*16) - copy(padded, data) - padded[len(data)] = terminator - return padded -} - -// decryptAPDU is an internal method that decrypts and deserializes an APDU. -func (s *SecureChannelSession) decryptAPDU(data []byte) ([]byte, error) { - a, err := aes.NewCipher(s.sessionEncKey) - if err != nil { - return nil, err - } - - ret := make([]byte, len(data)) - - crypter := cipher.NewCBCDecrypter(a, s.iv) - crypter.CryptBlocks(ret, data) - return unpad(ret, 0x80) -} - -// unpad strips padding from a message. -func unpad(data []byte, terminator byte) ([]byte, error) { - for i := 1; i <= 16; i++ { - switch data[len(data)-i] { - case 0: - continue - case terminator: - return data[:len(data)-i], nil - default: - return nil, fmt.Errorf("expected end of padding, got %d", data[len(data)-i]) - } - } - return nil, fmt.Errorf("expected end of padding, got 0") -} - -// updateIV is an internal method that updates the initialization vector after -// each message exchanged. -func (s *SecureChannelSession) updateIV(meta, data []byte) error { - data = pad(data, 0) - a, err := aes.NewCipher(s.sessionMacKey) - if err != nil { - return err - } - crypter := cipher.NewCBCEncrypter(a, make([]byte, 16)) - crypter.CryptBlocks(meta, meta) - crypter.CryptBlocks(data, data) - // The first 16 bytes of the last block is the MAC - s.iv = data[len(data)-32 : len(data)-16] - return nil -}

diff --git go-ethereum/accounts/scwallet/README.md celo/accounts/scwallet/README.md deleted file mode 100644 index 4313d9c6b2f8ecacf53657409572f53e482bbbe4..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/README.md +++ /dev/null @@ -1,106 +0,0 @@ -# Using the smartcard wallet - -## Requirements - - * A USB smartcard reader - * A keycard that supports the status app - * PCSCD version 4.3 running on your system **Only version 4.3 is currently supported** - -## Preparing the smartcard - - **WARNING: FOILLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS** - - You can use status' [keycard-cli](https://github.com/status-im/keycard-cli) and you should get _at least_ version 2.1.1 of their [smartcard application](https://github.com/status-im/status-keycard/releases/download/2.2.1/keycard_v2.2.1.cap) - - You also need to make sure that the PCSC daemon is running on your system. - - Then, you can install the application to the card by typing: - - ``` - keycard install -a keycard_v2.2.1.cap && keycard init - ``` - - At the end of this process, you will be provided with a PIN, a PUK and a pairing password. Write them down, you'll need them shortly. - - Start `geth` with the `console` command. You will notice the following warning: - - ``` - WARN [04-09|16:58:38.898] Failed to open wallet url=keycard://044def09 err="smartcard: pairing password needed" - ``` - - Write down the URL (`keycard://044def09` in this example). Then ask `geth` to open the wallet: - - ``` - > personal.openWallet("keycard://044def09", "pairing password") - ``` - - The pairing password has been generated during the card initialization process. - - The process needs to be repeated once more with the PIN: - - ``` - > personal.openWallet("keycard://044def09", "PIN number") - ``` - - If everything goes well, you should see your new account when typing `personal` on the console: - - ``` - > personal - WARN [04-09|17:02:07.330] Smartcard wallet account derivation failed url=keycard://044def09 err="Unexpected response status Cla=0x80, Ins=0xd1, Sw=0x6985" - { - listAccounts: [], - listWallets: [{ - status: "Empty, waiting for initialization", - url: "keycard://044def09" - }], - ... - } - ``` - - So the communication with the card is working, but there is no key associated with this wallet. Let's create it: - - ``` - > personal.initializeWallet("keycard://044def09") - "tilt ... impact" - ``` - - You should get a list of words, this is your seed so write them down. Your wallet should now be initialized: - - ``` - > personal.listWallets - [{ - accounts: [{ - address: "0x678b7cd55c61917defb23546a41803c5bfefbc7a", - url: "keycard://044d/m/44'/60'/0'/0/0" - }], - status: "Online", - url: "keycard://044def09" - }] - ``` - - You're all set! - -## Usage - - 1. Start `geth` with the `console` command - 2. Check the card's URL by checking `personal.listWallets`: - -``` - listWallets: [{ - status: "Online, can derive public keys", - url: "keycard://a4d73015" - }] -``` - - 3. Open the wallet, you will be prompted for your pairing password, then PIN: - -``` -personal.openWallet("keycard://a4d73015") -``` - - 4. Check that creation was successful by typing e.g. `personal`. Then use it like a regular wallet. - -## Known issues - - * Starting geth with a valid card seems to make firefox crash. - * PCSC version 4.4 should work, but is currently untested

diff --git go-ethereum/accounts/scwallet/hub.go celo/accounts/scwallet/hub.go deleted file mode 100644 index fc4f3c5eb7c065a04e414ba150e362214b0a37bf..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/hub.go +++ /dev/null @@ -1,302 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -// This package implements support for smartcard-based hardware wallets such as -// the one written by Status: https://github.com/status-im/hardware-wallet -// -// This implementation of smartcard wallets have a different interaction process -// to other types of hardware wallet. The process works like this: -// -// 1. (First use with a given client) Establish a pairing between hardware -// wallet and client. This requires a secret value called a 'pairing password'. -// You can pair with an unpaired wallet with `personal.openWallet(URI, pairing password)`. -// 2. (First use only) Initialize the wallet, which generates a keypair, stores -// it on the wallet, and returns it so the user can back it up. You can -// initialize a wallet with `personal.initializeWallet(URI)`. -// 3. Connect to the wallet using the pairing information established in step 1. -// You can connect to a paired wallet with `personal.openWallet(URI, PIN)`. -// 4. Interact with the wallet as normal. - -package scwallet - -import ( - "encoding/json" - "io/ioutil" - "os" - "path/filepath" - "sort" - "sync" - "time" - - "github.com/ethereum/go-ethereum/accounts" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/log" - pcsc "github.com/gballet/go-libpcsclite" -) - -// Scheme is the URI prefix for smartcard wallets. -const Scheme = "keycard" - -// refreshCycle is the maximum time between wallet refreshes (if USB hotplug -// notifications don't work). -const refreshCycle = time.Second - -// refreshThrottling is the minimum time between wallet refreshes to avoid thrashing. -const refreshThrottling = 500 * time.Millisecond - -// smartcardPairing contains information about a smart card we have paired with -// or might pair with the hub. -type smartcardPairing struct { - PublicKey []byte `json:"publicKey"` - PairingIndex uint8 `json:"pairingIndex"` - PairingKey []byte `json:"pairingKey"` - Accounts map[common.Address]accounts.DerivationPath `json:"accounts"` -} - -// Hub is a accounts.Backend that can find and handle generic PC/SC hardware wallets. -type Hub struct { - scheme string // Protocol scheme prefixing account and wallet URLs. - - context *pcsc.Client - datadir string - pairings map[string]smartcardPairing - - refreshed time.Time // Time instance when the list of wallets was last refreshed - wallets map[string]*Wallet // Mapping from reader names to wallet instances - updateFeed event.Feed // Event feed to notify wallet additions/removals - updateScope event.SubscriptionScope // Subscription scope tracking current live listeners - updating bool // Whether the event notification loop is running - - quit chan chan error - - stateLock sync.RWMutex // Protects the internals of the hub from racey access -} - -func (hub *Hub) readPairings() error { - hub.pairings = make(map[string]smartcardPairing) - pairingFile, err := os.Open(filepath.Join(hub.datadir, "smartcards.json")) - if err != nil { - if os.IsNotExist(err) { - return nil - } - return err - } - - pairingData, err := ioutil.ReadAll(pairingFile) - if err != nil { - return err - } - var pairings []smartcardPairing - if err := json.Unmarshal(pairingData, &pairings); err != nil { - return err - } - - for _, pairing := range pairings { - hub.pairings[string(pairing.PublicKey)] = pairing - } - return nil -} - -func (hub *Hub) writePairings() error { - pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE, 0755) - if err != nil { - return err - } - defer pairingFile.Close() - - pairings := make([]smartcardPairing, 0, len(hub.pairings)) - for _, pairing := range hub.pairings { - pairings = append(pairings, pairing) - } - - pairingData, err := json.Marshal(pairings) - if err != nil { - return err - } - - if _, err := pairingFile.Write(pairingData); err != nil { - return err - } - - return nil -} - -func (hub *Hub) pairing(wallet *Wallet) *smartcardPairing { - if pairing, ok := hub.pairings[string(wallet.PublicKey)]; ok { - return &pairing - } - return nil -} - -func (hub *Hub) setPairing(wallet *Wallet, pairing *smartcardPairing) error { - if pairing == nil { - delete(hub.pairings, string(wallet.PublicKey)) - } else { - hub.pairings[string(wallet.PublicKey)] = *pairing - } - return hub.writePairings() -} - -// NewHub creates a new hardware wallet manager for smartcards. -func NewHub(daemonPath string, scheme string, datadir string) (*Hub, error) { - context, err := pcsc.EstablishContext(daemonPath, pcsc.ScopeSystem) - if err != nil { - return nil, err - } - hub := &Hub{ - scheme: scheme, - context: context, - datadir: datadir, - wallets: make(map[string]*Wallet), - quit: make(chan chan error), - } - if err := hub.readPairings(); err != nil { - return nil, err - } - hub.refreshWallets() - return hub, nil -} - -// Wallets implements accounts.Backend, returning all the currently tracked smart -// cards that appear to be hardware wallets. -func (hub *Hub) Wallets() []accounts.Wallet { - // Make sure the list of wallets is up to date - hub.refreshWallets() - - hub.stateLock.RLock() - defer hub.stateLock.RUnlock() - - cpy := make([]accounts.Wallet, 0, len(hub.wallets)) - for _, wallet := range hub.wallets { - cpy = append(cpy, wallet) - } - sort.Sort(accounts.WalletsByURL(cpy)) - return cpy -} - -// refreshWallets scans the devices attached to the machine and updates the -// list of wallets based on the found devices. -func (hub *Hub) refreshWallets() { - // Don't scan the USB like crazy it the user fetches wallets in a loop - hub.stateLock.RLock() - elapsed := time.Since(hub.refreshed) - hub.stateLock.RUnlock() - - if elapsed < refreshThrottling { - return - } - // Retrieve all the smart card reader to check for cards - readers, err := hub.context.ListReaders() - if err != nil { - // This is a perverted hack, the scard library returns an error if no card - // readers are present instead of simply returning an empty list. We don't - // want to fill the user's log with errors, so filter those out. - if err.Error() != "scard: Cannot find a smart card reader." { - log.Error("Failed to enumerate smart card readers", "err", err) - return - } - } - // Transform the current list of wallets into the new one - hub.stateLock.Lock() - - events := []accounts.WalletEvent{} - seen := make(map[string]struct{}) - - for _, reader := range readers { - // Mark the reader as present - seen[reader] = struct{}{} - - // If we already know about this card, skip to the next reader, otherwise clean up - if wallet, ok := hub.wallets[reader]; ok { - if err := wallet.ping(); err == nil { - continue - } - wallet.Close() - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped}) - delete(hub.wallets, reader) - } - // New card detected, try to connect to it - card, err := hub.context.Connect(reader, pcsc.ShareShared, pcsc.ProtocolAny) - if err != nil { - log.Debug("Failed to open smart card", "reader", reader, "err", err) - continue - } - wallet := NewWallet(hub, card) - if err = wallet.connect(); err != nil { - log.Debug("Failed to connect to smart card", "reader", reader, "err", err) - card.Disconnect(pcsc.LeaveCard) - continue - } - // Card connected, start tracking in amongs the wallets - hub.wallets[reader] = wallet - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived}) - } - // Remove any wallets no longer present - for reader, wallet := range hub.wallets { - if _, ok := seen[reader]; !ok { - wallet.Close() - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped}) - delete(hub.wallets, reader) - } - } - hub.refreshed = time.Now() - hub.stateLock.Unlock() - - for _, event := range events { - hub.updateFeed.Send(event) - } -} - -// Subscribe implements accounts.Backend, creating an async subscription to -// receive notifications on the addition or removal of smart card wallets. -func (hub *Hub) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription { - // We need the mutex to reliably start/stop the update loop - hub.stateLock.Lock() - defer hub.stateLock.Unlock() - - // Subscribe the caller and track the subscriber count - sub := hub.updateScope.Track(hub.updateFeed.Subscribe(sink)) - - // Subscribers require an active notification loop, start it - if !hub.updating { - hub.updating = true - go hub.updater() - } - return sub -} - -// updater is responsible for maintaining an up-to-date list of wallets managed -// by the smart card hub, and for firing wallet addition/removal events. -func (hub *Hub) updater() { - for { - // TODO: Wait for a USB hotplug event (not supported yet) or a refresh timeout - // <-hub.changes - time.Sleep(refreshCycle) - - // Run the wallet refresher - hub.refreshWallets() - - // If all our subscribers left, stop the updater - hub.stateLock.Lock() - if hub.updateScope.Count() == 0 { - hub.updating = false - hub.stateLock.Unlock() - return - } - hub.stateLock.Unlock() - } -}

diff --git go-ethereum/cmd/geth/version_check.go celo/cmd/geth/version_check.go index 5c1f724d6f75f121a44243550331001011e11bee..4a4c56f04b67b749eeb80926ca756a9c13a1d6cf 100644 --- go-ethereum/cmd/geth/version_check.go +++ celo/cmd/geth/version_check.go @@ -114,6 +114,8 @@ func fetch(url string) ([]byte, error) { if filep := strings.TrimPrefix(url, "file://"); filep != url { return ioutil.ReadFile(filep) } + // gosec/G107. This function is called with a node/validator flag, no need to run gosec. + //nolint:gosec res, err := http.Get(url) if err != nil { return nil, err

diff --git go-ethereum/cmd/geth/usage.go celo/cmd/geth/usage.go index 49036581591fc6277d905a77a0cd77f250512e46..67fc84edf2c1287fc0251e55b4a027056475c025 100644 --- go-ethereum/cmd/geth/usage.go +++ celo/cmd/geth/usage.go @@ -39,20 +39,19 @@ utils.AncientFlag, utils.MinFreeDiskSpaceFlag, utils.KeyStoreDirFlag, utils.USBFlag, - utils.SmartCardDaemonPathFlag, utils.NetworkIdFlag, utils.MainnetFlag, - utils.GoerliFlag, - utils.RinkebyFlag, - utils.RopstenFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, utils.SyncModeFlag, utils.ExitWhenSyncedFlag, utils.GCModeFlag, utils.TxLookupLimitFlag, - utils.EthStatsURLFlag, + utils.CeloStatsURLFlag, utils.IdentityFlag, utils.LightKDFFlag, utils.WhitelistFlag, + utils.TxFeeRecipientFlag, }, }, { @@ -74,19 +73,6 @@ Name: "DEVELOPER CHAIN", Flags: []cli.Flag{ utils.DeveloperFlag, utils.DeveloperPeriodFlag, - }, - }, - { - Name: "ETHASH", - Flags: []cli.Flag{ - utils.EthashCacheDirFlag, - utils.EthashCachesInMemoryFlag, - utils.EthashCachesOnDiskFlag, - utils.EthashCachesLockMmapFlag, - utils.EthashDatasetDirFlag, - utils.EthashDatasetsInMemoryFlag, - utils.EthashDatasetsOnDiskFlag, - utils.EthashDatasetsLockMmapFlag, }, }, { @@ -140,6 +126,9 @@ utils.HTTPApiFlag, utils.HTTPPathPrefixFlag, utils.HTTPCORSDomainFlag, utils.HTTPVirtualHostsFlag, + utils.HTTPRequestReadTimeout, + utils.HTTPRequestWriteTimeout, + utils.HTTPRequestIdleTimeout, utils.WSEnabledFlag, utils.WSListenAddrFlag, utils.WSPortFlag, @@ -149,9 +138,10 @@ utils.WSAllowedOriginsFlag, utils.GraphQLEnabledFlag, utils.GraphQLCORSDomainFlag, utils.GraphQLVirtualHostsFlag, + utils.RPCGlobalGasInflationRateFlag, + utils.RPCGlobalGasPriceMultiplierFlag, utils.RPCGlobalGasCapFlag, utils.RPCGlobalTxFeeCapFlag, - utils.AllowUnprotectedTxs, utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag, @@ -171,30 +161,18 @@ utils.DiscoveryV5Flag, utils.NetrestrictFlag, utils.NodeKeyFileFlag, utils.NodeKeyHexFlag, + utils.PingIPFromPacketFlag, + utils.UseInMemoryDiscoverTableFlag, }, }, { Name: "MINER", Flags: []cli.Flag{ utils.MiningEnabledFlag, - utils.MinerThreadsFlag, - utils.MinerNotifyFlag, - utils.MinerNotifyFullFlag, - utils.MinerGasPriceFlag, - utils.MinerGasLimitFlag, - utils.MinerEtherbaseFlag, + utils.MinerValidatorFlag, utils.MinerExtraDataFlag, - utils.MinerRecommitIntervalFlag, - utils.MinerNoVerifyFlag, - }, - }, - { - Name: "GAS PRICE ORACLE", - Flags: []cli.Flag{ - utils.GpoBlocksFlag, - utils.GpoPercentileFlag, - utils.GpoMaxGasPriceFlag, - utils.GpoIgnoreGasPriceFlag, + utils.CeloFeeCurrencyDefault, + utils.CeloFeeCurrencyLimits, }, }, { @@ -206,7 +184,6 @@ }, { Name: "LOGGING AND DEBUGGING", Flags: append([]cli.Flag{ - utils.FakePoWFlag, utils.NoCompactionFlag, }, debug.Flags...), }, @@ -215,9 +192,49 @@ Name: "METRICS AND STATS", Flags: metricsFlags, }, { + Name: "ISTANBUL", + Flags: []cli.Flag{ + utils.IstanbulReplicaFlag, + }, + }, + { + Name: "ANNOUNCE", + Flags: []cli.Flag{ + utils.AnnounceQueryEnodeGossipPeriodFlag, + utils.AnnounceAggressiveQueryEnodeGossipOnEnablementFlag, + }, + }, + { + Name: "PROXY", + Flags: []cli.Flag{ + utils.ProxyFlag, + utils.ProxyInternalFacingEndpointFlag, + utils.ProxiedValidatorAddressFlag, + utils.ProxiedFlag, + utils.ProxyEnodeURLPairsFlag, + utils.ProxyAllowPrivateIPFlag, + }, + }, + { Name: "ALIASED (deprecated)", Flags: []cli.Flag{ + utils.EtherbaseFlag, + utils.LegacyMinerGasPriceFlag, + utils.LegacyProxyEnodeURLPairsFlag, + utils.LegacyIstanbulRequestTimeoutFlag, + utils.LegacyIstanbulBlockPeriodFlag, + utils.LegacyIstanbulProposerPolicyFlag, + utils.LegacyIstanbulLookbackWindowFlag, + utils.LegacyEthStatsURLFlag, utils.NoUSBFlag, + utils.LegacyWSListenAddrFlag, + utils.LegacyWSPortFlag, + utils.LegacyWSAllowedOriginsFlag, + utils.LegacyWSApiFlag, + utils.LegacyGraphQLListenAddrFlag, + utils.LegacyGraphQLPortFlag, + utils.LightGatewayFeeFlag, + utils.DisableRPCETHCompatibility, }, }, { @@ -226,7 +243,6 @@ Flags: []cli.Flag{ utils.SnapshotFlag, utils.BloomFilterSizeFlag, cli.HelpFlag, - utils.CatalystFlag, }, }, }

diff --git go-ethereum/cmd/geth/main.go celo/cmd/geth/main.go index af3e7722a6559eb62854aa2291c02edeb886d6d8..0719ac9ea15c80323e931955ddee2549707694d0 100644 --- go-ethereum/cmd/geth/main.go +++ celo/cmd/geth/main.go @@ -30,20 +30,27 @@ "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/console/prompt" + "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/internal/debug" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/flags" + lesDownloader "github.com/ethereum/go-ethereum/les/downloader" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/node" + + // Force-load the tracer engines to trigger registration + _ "github.com/ethereum/go-ethereum/eth/tracers/js" + _ "github.com/ethereum/go-ethereum/eth/tracers/native" + "gopkg.in/urfave/cli.v1" )   const ( - clientIdentifier = "geth" // Client identifier to advertise over the network + clientIdentifier = "celo" // Client identifier to advertise over the network )   var ( @@ -65,16 +72,8 @@ utils.KeyStoreDirFlag, utils.ExternalSignerFlag, utils.NoUSBFlag, utils.USBFlag, - utils.SmartCardDaemonPathFlag, - utils.OverrideLondonFlag, - utils.EthashCacheDirFlag, - utils.EthashCachesInMemoryFlag, - utils.EthashCachesOnDiskFlag, - utils.EthashCachesLockMmapFlag, - utils.EthashDatasetDirFlag, - utils.EthashDatasetsInMemoryFlag, - utils.EthashDatasetsOnDiskFlag, - utils.EthashDatasetsLockMmapFlag, + // utils.SmartCardDaemonPathFlag, + utils.OverrideHForkFlag, utils.TxPoolLocalsFlag, utils.TxPoolNoLocalsFlag, utils.TxPoolJournalFlag, @@ -97,11 +96,15 @@ utils.LightEgressFlag, utils.LightMaxPeersFlag, utils.LightNoPruneFlag, utils.LightKDFFlag, + utils.LightGatewayFeeFlag, utils.UltraLightServersFlag, utils.UltraLightFractionFlag, utils.UltraLightOnlyAnnounceFlag, utils.LightNoSyncServeFlag, utils.WhitelistFlag, + utils.EtherbaseFlag, + utils.TxFeeRecipientFlag, + utils.BLSbaseFlag, utils.BloomFilterSizeFlag, utils.CacheFlag, utils.CacheDatabaseFlag, @@ -116,15 +119,10 @@ utils.ListenPortFlag, utils.MaxPeersFlag, utils.MaxPendingPeersFlag, utils.MiningEnabledFlag, - utils.MinerThreadsFlag, - utils.MinerNotifyFlag, - utils.LegacyMinerGasTargetFlag, - utils.MinerGasLimitFlag, - utils.MinerGasPriceFlag, - utils.MinerEtherbaseFlag, + utils.MinerValidatorFlag, + utils.LegacyMinerGasPriceFlag, // switched to gas price flag? utils.MinerExtraDataFlag, - utils.MinerRecommitIntervalFlag, - utils.MinerNoVerifyFlag, + utils.LegacyMinerExtraDataFlag, utils.NATFlag, utils.NoDiscoverFlag, utils.DiscoveryV5Flag, @@ -135,24 +133,40 @@ utils.DNSDiscoveryFlag, utils.MainnetFlag, utils.DeveloperFlag, utils.DeveloperPeriodFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, utils.VMEnableDebugFlag, utils.NetworkIdFlag, - utils.EthStatsURLFlag, - utils.FakePoWFlag, + utils.CeloStatsURLFlag, + utils.LegacyEthStatsURLFlag, utils.NoCompactionFlag, - utils.GpoBlocksFlag, - utils.GpoPercentileFlag, - utils.GpoMaxGasPriceFlag, - utils.GpoIgnoreGasPriceFlag, - utils.MinerNotifyFullFlag, + // utils.GpoBlocksFlag, + // utils.GpoPercentileFlag, + // utils.GpoMaxGasPriceFlag, + // utils.GpoIgnoreGasPriceFlag, configFileFlag, - utils.CatalystFlag, + utils.LegacyIstanbulRequestTimeoutFlag, + utils.LegacyIstanbulBlockPeriodFlag, + utils.LegacyIstanbulProposerPolicyFlag, + utils.LegacyIstanbulLookbackWindowFlag, + utils.IstanbulReplicaFlag, + utils.AnnounceQueryEnodeGossipPeriodFlag, + utils.AnnounceAggressiveQueryEnodeGossipOnEnablementFlag, + utils.PingIPFromPacketFlag, + utils.UseInMemoryDiscoverTableFlag, + utils.ProxyFlag, + utils.ProxyInternalFacingEndpointFlag, + utils.ProxiedValidatorAddressFlag, + utils.ProxiedFlag, + utils.ProxyEnodeURLPairsFlag, + utils.LegacyProxyEnodeURLPairsFlag, + utils.ProxyAllowPrivateIPFlag, + utils.CeloFeeCurrencyDefault, + utils.CeloFeeCurrencyLimits, }   rpcFlags = []cli.Flag{ + utils.DisableRPCETHCompatibility, utils.HTTPEnabledFlag, utils.HTTPListenAddrFlag, utils.HTTPPortFlag, @@ -163,18 +177,26 @@ utils.GraphQLCORSDomainFlag, utils.GraphQLVirtualHostsFlag, utils.HTTPApiFlag, utils.HTTPPathPrefixFlag, + utils.HTTPRequestReadTimeout, + utils.HTTPRequestWriteTimeout, + utils.HTTPRequestIdleTimeout, utils.WSEnabledFlag, utils.WSListenAddrFlag, + utils.LegacyWSListenAddrFlag, utils.WSPortFlag, + utils.LegacyWSPortFlag, utils.WSApiFlag, + utils.LegacyWSApiFlag, utils.WSAllowedOriginsFlag, + utils.LegacyWSAllowedOriginsFlag, utils.WSPathPrefixFlag, utils.IPCDisabledFlag, utils.IPCPathFlag, utils.InsecureUnlockAllowedFlag, + utils.RPCGlobalGasInflationRateFlag, + utils.RPCGlobalGasPriceMultiplierFlag, utils.RPCGlobalGasCapFlag, utils.RPCGlobalTxFeeCapFlag, - utils.AllowUnprotectedTxs, }   metricsFlags = []cli.Flag{ @@ -192,6 +214,7 @@ utils.MetricsEnableInfluxDBV2Flag, utils.MetricsInfluxDBTokenFlag, utils.MetricsInfluxDBBucketFlag, utils.MetricsInfluxDBOrganizationFlag, + utils.MetricsLoadTestCSVFlag, } )   @@ -218,8 +241,6 @@ consoleCommand, attachCommand, javascriptCommand, // See misccmd.go: - makecacheCommand, - makedagCommand, versionCommand, versionCheckCommand, licenseCommand, @@ -262,25 +283,21 @@ // This function should be called before launching devp2p stack. func prepare(ctx *cli.Context) { // If we're running a known preset, log it for convenience. switch { - case ctx.GlobalIsSet(utils.RopstenFlag.Name): - log.Info("Starting Geth on Ropsten testnet...") - - case ctx.GlobalIsSet(utils.RinkebyFlag.Name): - log.Info("Starting Geth on Rinkeby testnet...") + case ctx.GlobalIsSet(utils.BaklavaFlag.Name): + log.Info("Starting Geth on Baklava testnet...")   - case ctx.GlobalIsSet(utils.GoerliFlag.Name): - log.Info("Starting Geth on Görli testnet...") - + case ctx.GlobalIsSet(utils.AlfajoresFlag.Name): + log.Info("Starting Geth on Alfajores testnet...") case ctx.GlobalIsSet(utils.DeveloperFlag.Name): log.Info("Starting Geth in ephemeral dev mode...")   case !ctx.GlobalIsSet(utils.NetworkIdFlag.Name): - log.Info("Starting Geth on Ethereum mainnet...") + log.Info("Starting Geth on Celo mainnet...") } // If we're a full node on mainnet without --cache specified, bump default cache allowance if ctx.GlobalString(utils.SyncModeFlag.Name) != "light" && !ctx.GlobalIsSet(utils.CacheFlag.Name) && !ctx.GlobalIsSet(utils.NetworkIdFlag.Name) { // Make sure we're not on any supported preconfigured testnet either - if !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.DeveloperFlag.Name) { + if !ctx.GlobalIsSet(utils.DeveloperFlag.Name) && !ctx.GlobalIsSet(utils.AlfajoresFlag.Name) && !ctx.GlobalIsSet(utils.BaklavaFlag.Name) { // Nope, we're really on mainnet. Bump that cache up! log.Info("Bumping default cache on mainnet", "provided", ctx.GlobalInt(utils.CacheFlag.Name), "updated", 4096) ctx.GlobalSet(utils.CacheFlag.Name, strconv.Itoa(4096)) @@ -376,19 +393,26 @@ // Spawn a standalone goroutine for status synchronization monitoring, // close the node when synchronization is complete if user required. if ctx.GlobalBool(utils.ExitWhenSyncedFlag.Name) { go func() { - sub := stack.EventMux().Subscribe(downloader.DoneEvent{}) + // Subscribing to both events since les has its own downloader + sub := stack.EventMux().Subscribe(downloader.DoneEvent{}, lesDownloader.DoneEvent{}) defer sub.Unsubscribe() for { event := <-sub.Chan() if event == nil { continue } - done, ok := event.Data.(downloader.DoneEvent) - if !ok { + var latest *types.Header + if done, ok := event.Data.(downloader.DoneEvent); ok { + latest = done.Latest + } + if lesDone, ok := event.Data.(lesDownloader.DoneEvent); ok { + latest = lesDone.Latest + } + if latest == nil { continue } - if timestamp := time.Unix(int64(done.Latest.Time), 0); time.Since(timestamp) < 10*time.Minute { - log.Info("Synchronisation completed", "latestnum", done.Latest.Number, "latesthash", done.Latest.Hash(), + if timestamp := time.Unix(int64(latest.Time), 0); time.Since(timestamp) < 10*time.Minute { + log.Info("Synchronisation completed", "latestnum", latest.Number, "latesthash", latest.Hash(), "age", common.PrettyAge(timestamp)) stack.Close() } @@ -396,22 +420,40 @@ } }() }   + isFullNode := ctx.GlobalString(utils.SyncModeFlag.Name) == "full" || ctx.GlobalString(utils.SyncModeFlag.Name) == "fast" + // Miners and proxies only makes sense if a full node is running + if ctx.GlobalBool(utils.ProxyFlag.Name) || ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) { + if !isFullNode { + utils.Fatalf("Miners and Proxies must be run as a full node") + } + } + // Replicas only makes sense if we are mining + if ctx.GlobalBool(utils.IstanbulReplicaFlag.Name) { + if !(ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name)) { + utils.Fatalf("Must run a replica with mining enabled or in dev mode.") + } + } + // Start auxiliary services if enabled if ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) { - // Mining only makes sense if a full Ethereum node is running - if ctx.GlobalString(utils.SyncModeFlag.Name) == "light" { - utils.Fatalf("Light clients do not support mining") + if ctx.GlobalBool(utils.ProxyFlag.Name) { + utils.Fatalf("Proxies can't mine") } ethBackend, ok := backend.(*eth.EthAPIBackend) if !ok { utils.Fatalf("Ethereum service not running: %v", err) } - // Set the gas price to the limits from the CLI and start mining - gasprice := utils.GlobalBig(ctx, utils.MinerGasPriceFlag.Name) - ethBackend.TxPool().SetGasPrice(gasprice) - // start mining - threads := ctx.GlobalInt(utils.MinerThreadsFlag.Name) - if err := ethBackend.StartMining(threads); err != nil { + // // TODO: Handle gas price. + // // Set the gas price to the limits from the CLI and start mining + // // gasprice := utils.GlobalBig(ctx, utils.LegacyMinerGasPriceFlag.Name) // MinerGasPriceFlag + // gasprice := utils.GlobalBig(ctx, utils.MinerGasPriceFlag.Name) + // // Migration from legacy miner gas price to new flag + // if ctx.GlobalIsSet(utils.LegacyMinerGasPriceFlag.Name) && !ctx.GlobalIsSet(utils.MinerGasPriceFlag.Name) { + // gasprice = utils.GlobalBig(ctx, utils.LegacyMinerGasPriceFlag.Name) + // } + // ethBackend.TxPool().SetGasPrice(gasprice) + + if err := ethBackend.StartMining(); err != nil { utils.Fatalf("Failed to start mining: %v", err) } }