Blockchain

1Error: Property 'body' cannot be accessed on 'Response?' because it is potentially null.
2 - 'Response' is from 'package:http/src/response.dart' ('/D:/flutter/.pub-cache/hosted/pub.dartlang.org/http-0.13.4/lib/src/response.dart').
3Try accessing using ?. instead.
4          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
5                                                                    ^^^^
6/D:/flutter/packages/flutter/lib/src/widgets/async.dart:242:12: Context: 'data' refers to a property so it couldn't be promoted.
7See http://dart.dev/go/non-promo-property
8  final T? data;
9           ^
10import 'dart:convert';
11import 'package:flutter/cupertino.dart';
12import 'package:flutter/material.dart';
13import 'package:http/http.dart' as http;
14
15Future<http.Response> fetchBTCPrice() async {
16  final response = await http.get(Uri.https('blockhain.info', 'ticker'));
17  return response;
18}
19
20Widget buildBTCPrice() {
21  return FutureBuilder<http.Response>(
22    future: fetchBTCPrice(),
23    builder: (context, snapshot) {
24      if (snapshot.hasData) {
25        int? statusCode = snapshot.data?.statusCode;
26        if (statusCode == 200) {
27          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
28        }
29        return Text('$statusCode');
30
31      } else if (snapshot.hasError) {
32        return Text('${snapshot.error}');
33      }
34      return CircularProgressIndicator();
35    },
36  );
37}
38
39class BTCPrice {
40  final double eur;
41  BTCPrice({required this.eur});
42
43  factory BTCPrice.fromJson(Map<String, dynamic> json) {
44    print(json);
45    return BTCPrice(
46      eur: json['eur']['15m']
47    );
48  }
49}
50if (statusCode == 200) {
51  return Text(
52 "${BTCPrice.fromJson(jsonDecode(snapshot.data!.body)).eur}"); // adding ! on data
53}
54

1Error: Property 'body' cannot be accessed on 'Response?' because it is potentially null.
2 - 'Response' is from 'package:http/src/response.dart' ('/D:/flutter/.pub-cache/hosted/pub.dartlang.org/http-0.13.4/lib/src/response.dart').
3Try accessing using ?. instead.
4          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
5                                                                    ^^^^
6/D:/flutter/packages/flutter/lib/src/widgets/async.dart:242:12: Context: 'data' refers to a property so it couldn't be promoted.
7See http://dart.dev/go/non-promo-property
8  final T? data;
9           ^
10import 'dart:convert';
11import 'package:flutter/cupertino.dart';
12import 'package:flutter/material.dart';
13import 'package:http/http.dart' as http;
14
15Future<http.Response> fetchBTCPrice() async {
16  final response = await http.get(Uri.https('blockhain.info', 'ticker'));
17  return response;
18}
19
20Widget buildBTCPrice() {
21  return FutureBuilder<http.Response>(
22    future: fetchBTCPrice(),
23    builder: (context, snapshot) {
24      if (snapshot.hasData) {
25        int? statusCode = snapshot.data?.statusCode;
26        if (statusCode == 200) {
27          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
28        }
29        return Text('$statusCode');
30
31      } else if (snapshot.hasError) {
32        return Text('${snapshot.error}');
33      }
34      return CircularProgressIndicator();
35    },
36  );
37}
38
39class BTCPrice {
40  final double eur;
41  BTCPrice({required this.eur});
42
43  factory BTCPrice.fromJson(Map<String, dynamic> json) {
44    print(json);
45    return BTCPrice(
46      eur: json['eur']['15m']
47    );
48  }
49}
50if (statusCode == 200) {
51  return Text(
52 "${BTCPrice.fromJson(jsonDecode(snapshot.data!.body)).eur}"); // adding ! on data
53}
54final response = await http.get(Uri.https('blockhain.info', 'ticker'));
55

1Error: Property 'body' cannot be accessed on 'Response?' because it is potentially null.
2 - 'Response' is from 'package:http/src/response.dart' ('/D:/flutter/.pub-cache/hosted/pub.dartlang.org/http-0.13.4/lib/src/response.dart').
3Try accessing using ?. instead.
4          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
5                                                                    ^^^^
6/D:/flutter/packages/flutter/lib/src/widgets/async.dart:242:12: Context: 'data' refers to a property so it couldn't be promoted.
7See http://dart.dev/go/non-promo-property
8  final T? data;
9           ^
10import 'dart:convert';
11import 'package:flutter/cupertino.dart';
12import 'package:flutter/material.dart';
13import 'package:http/http.dart' as http;
14
15Future<http.Response> fetchBTCPrice() async {
16  final response = await http.get(Uri.https('blockhain.info', 'ticker'));
17  return response;
18}
19
20Widget buildBTCPrice() {
21  return FutureBuilder<http.Response>(
22    future: fetchBTCPrice(),
23    builder: (context, snapshot) {
24      if (snapshot.hasData) {
25        int? statusCode = snapshot.data?.statusCode;
26        if (statusCode == 200) {
27          return Text("${BTCPrice.fromJson(jsonDecode(snapshot.data.body)).eur}");
28        }
29        return Text('$statusCode');
30
31      } else if (snapshot.hasError) {
32        return Text('${snapshot.error}');
33      }
34      return CircularProgressIndicator();
35    },
36  );
37}
38
39class BTCPrice {
40  final double eur;
41  BTCPrice({required this.eur});
42
43  factory BTCPrice.fromJson(Map<String, dynamic> json) {
44    print(json);
45    return BTCPrice(
46      eur: json['eur']['15m']
47    );
48  }
49}
50if (statusCode == 200) {
51  return Text(
52 "${BTCPrice.fromJson(jsonDecode(snapshot.data!.body)).eur}"); // adding ! on data
53}
54final response = await http.get(Uri.https('blockhain.info', 'ticker'));
55final response = await http.get(Uri.parse('https://blockchain.info/ticker'));
56

1let number_string = String::from_utf8_lossy(&my_bytes_array)
2            .to_owned()
3            .to_string();
4let number = u64::from_str_radix(&number_string , 16).unwrap();
5let number = u64::from_le_bytes(my_bytes_array);
6pub fn hex_to_u64(x: &[u8]) -> Option<u64> {
7    let mut result: u64 = 0;
8    for i in x {
9        result *= 16;
10        result += (*i as char).to_digit(16)? as u64;
11    }
12    Some(result)
13}
14

1from solcx import compile_standard
2from web3 import Web3
3import json
4import os
5from dotenv import load_dotenv
6
7load_dotenv()
8
9with open("./SimpleStorage.sol", "r") as file:
10    simple_storage_file = file.read()
11
12compiled_sol = compile_standard(
13    {
14        "language": "Solidity",
15        "sources": {"SimpleStorage.sol": {"content": simple_storage_file}},
16        "settings": {
17            "outputSelection": {
18                "*": {"*": ["abi", "metadata", "evm.bytecode", "evm.sourceMap"]}
19            }
20        },
21    },
22    solc_version="0.6.0",
23)
24
25with open("compiled_code.json", "w") as file:
26    json.dump(compiled_sol, file)
27
28
29# get bytecode
30bytecode = compiled_sol["contracts"]["SimpleStorage.sol"]["SimpleStorage"]["evm"][
31    "bytecode"
32]["object"]
33
34
35# get ABI
36abi = compiled_sol["contracts"]["SimpleStorage.sol"]["SimpleStorage"]["abi"]
37
38# to connect to ganache blockchain
39w3 = Web3(Web3.HTTPProvider("HTTP://127.0.0.1:7545"))
40chain_id = 5777
41my_address = "0xca1EA31e644F13E3E36631382686fD471c62267A"
42private_key = os.getenv("PRIVATE_KEY")
43
44
45# create the contract in python
46
47SimpleStorage = w3.eth.contract(abi=abi, bytecode=bytecode)
48
49# get the latest transaction
50nonce = w3.eth.getTransactionCount(my_address)
51
52# 1. Build a transaction
53# 2. Sign a transaction
54# 3. Send a transaction
55
56
57transaction = SimpleStorage.constructor().buildTransaction(
58    {"chainId": chain_id, "from": my_address, "nonce": nonce}
59)
60print(transaction)
61
62Traceback (most recent call last):
63File "C:\Users\evens\demos\web3_py_simple_storage\deploy.py", line 
6452, in <module>
65transaction = SimpleStorage.constructor().buildTransaction(
66File "C:\Python310\lib\site-packages\eth_utils\decorators.py", line 
6718, in _wrapper
68return self.method(obj, *args, **kwargs)
69File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
70packages\web3\contract.py", line 684, in buildTransaction
71return fill_transaction_defaults(self.web3, built_transaction)
72File "cytoolz/functoolz.pyx", line 250, in 
73cytoolz.functoolz.curry.__call__
74return self.func(*args, **kwargs)
75File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
76packages\web3\_utils\transactions.py", line 114, in 
77fill_transaction_defaults
78default_val = default_getter(web3, transaction)
79File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
80packages\web3\_utils\transactions.py", line 60, in <lambda>
81'gas': lambda web3, tx: web3.eth.estimate_gas(tx),
82File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
83packages\web3\eth.py", line 820, in estimate_gas
84return self._estimate_gas(transaction, block_identifier)
85File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
86packages\web3\module.py", line 57, in caller
87result = w3.manager.request_blocking(method_str,
88File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
89packages\web3\manager.py", line 197, in request_blocking
90response = self._make_request(method, params)
91File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
92packages\web3\manager.py", line 150, in _make_request
93return request_func(method, params)
94File "cytoolz/functoolz.pyx", line 250, in 
95cytoolz.functoolz.curry.__call__
96return self.func(*args, **kwargs)
97File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
98packages\web3\middleware\formatting.py", line 76, in 
99apply_formatters
100response = make_request(method, params)
101File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
102packages\web3\middleware\gas_price_strategy.py", line 90, in 
103middleware
104return make_request(method, params)
105File "cytoolz/functoolz.pyx", line 250, in 
106cytoolz.functoolz.curry.__call__
107return self.func(*args, **kwargs)
108File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
109packages\web3\middleware\formatting.py", line 74, in 
110apply_formatters
111response = make_request(method, formatted_params)
112File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
113packages\web3\middleware\attrdict.py", line 33, in middleware
114response = make_request(method, params)
115File "cytoolz/functoolz.pyx", line 250, in 
116cytoolz.functoolz.curry.__call__
117return self.func(*args, **kwargs)
118File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
119packages\web3\middleware\formatting.py", line 74, in 
120apply_formatters
121response = make_request(method, formatted_params)
122File "cytoolz/functoolz.pyx", line 250, in 
123cytoolz.functoolz.curry.__call__
124return self.func(*args, **kwargs)
125File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
126packages\web3\middleware\formatting.py", line 73, in 
127apply_formatters
128formatted_params = formatter(params)
129File "cytoolz/functoolz.pyx", line 503, in 
130cytoolz.functoolz.Compose.__call__
131ret = PyObject_Call(self.first, args, kwargs)
132File "cytoolz/functoolz.pyx", line 250, in 
133cytoolz.functoolz.curry.__call__
134return self.func(*args, **kwargs)
135File "C:\Python310\lib\site-packages\eth_utils\decorators.py", line 
13691, in wrapper
137return ReturnType(result)  # type: ignore
138File "C:\Python310\lib\site-packages\eth_utils\applicators.py", line 
13922, in apply_formatter_at_index
140yield formatter(item)
141File "cytoolz/functoolz.pyx", line 250, in 
142cytoolz.functoolz.curry.__call__
143File "cytoolz/functoolz.pyx", line 250, in 
144cytoolz.functoolz.curry.__call__
145return self.func(*args, **kwargs)
146File "C:\Python310\lib\site-packages\eth_utils\applicators.py", line 
14772, in apply_formatter_if
148return formatter(value)
149File "cytoolz/functoolz.pyx", line 250, in 
150cytoolz.functoolz.curry.__call__
151return self.func(*args, **kwargs)
152File "C:\Users\evens\AppData\Roaming\Python\Python310\site- 
153packages\web3\middleware\validation.py", line 57, in 
154validate_chain_id
155raise ValidationError(
156web3.exceptions.ValidationError: The transaction declared chain ID 
1575777, but the connected node is on 1337
158transaction = 
159 SimpleStorage.constructor().buildTransaction( {
160    "gasPrice": w3.eth.gas_price, 
161    "chainId": chain_id, 
162    "from": my_address, 
163    "nonce": nonce, 
164})
165print(transaction)
166

1from bip_utils import *
2
3MNEMONIC = "...12 words phrase..."
4
5seed_bytes = Bip39SeedGenerator(MNEMONIC).Generate("")
6
7bip44_mst_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.SOLANA)
8
9bip44_acc_ctx = bip44_mst_ctx.Purpose().Coin().Account(0)
10
11bip44_chg_ctx = bip44_acc_ctx.Change(Bip44Changes.CHAIN_EXT)
12
13print(bip44_chg_ctx.PublicKey().ToAddress())
14

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
198

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
198package main
199
200import (
201    "encoding/hex"
202    "fmt"
203
204    "math/big"
205
206    "github.com/cosmos/cosmos-sdk/crypto/hd"
207    "github.com/cosmos/go-bip39"
208    "github.com/tendermint/tendermint/crypto/secp256k1"
209
210    //"github.com/btcsuite/btcd/btcec"
211    "golang.org/x/crypto/cryptobyte"
212    "golang.org/x/crypto/cryptobyte/asn1"
213)
214
215func main() {
216
217    //
218    // Derive private and public key (this part works)
219    //
220    seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
221    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
222
223    master, ch := hd.ComputeMastersFromSeed(seed)
224    path := "m/44'/1022'/0'/0/0'"
225    priv, _ := hd.DerivePrivateKeyForPath(master, ch, path)
226    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/1022'/0'/0/0'
227    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
228
229    var privKey = secp256k1.PrivKey(priv)
230    pubKey := privKey.PubKey()
231    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
232
233    //
234    // Sign (this part needs to be fixed)
235    //
236    data := "test"
237
238    signature, _ := privKey.Sign([]byte(data))
239    fmt.Println(hex.EncodeToString(signature))
240
241    rVal := new(big.Int)
242    rVal.SetBytes(signature[0:32])
243    sVal := new(big.Int)
244    sVal.SetBytes(signature[32:64])
245    var b cryptobyte.Builder
246    b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
247        b.AddASN1BigInt(rVal)
248        b.AddASN1BigInt(sVal)
249    })
250    signatureDER, _ := b.Bytes()
251    fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
252
253    /*
254        hash, _ := hex.DecodeString("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
255
256        // Sign without hashing
257        privateKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), priv)
258        signature, _ := privateKey.Sign(hash[:])
259
260        // Convert to ASN1/DER
261        rVal := new(big.Int)
262        rVal.SetBytes(signature.R.Bytes())
263        sVal := new(big.Int)
264        sVal.SetBytes(signature.S.Bytes())
265        var b cryptobyte.Builder
266        b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
267            b.AddASN1BigInt(rVal)
268            b.AddASN1BigInt(sVal)
269        })
270        signatureDER, _ := b.Bytes()
271        fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
272    */
273}
274

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
198package main
199
200import (
201    "encoding/hex"
202    "fmt"
203
204    "math/big"
205
206    "github.com/cosmos/cosmos-sdk/crypto/hd"
207    "github.com/cosmos/go-bip39"
208    "github.com/tendermint/tendermint/crypto/secp256k1"
209
210    //"github.com/btcsuite/btcd/btcec"
211    "golang.org/x/crypto/cryptobyte"
212    "golang.org/x/crypto/cryptobyte/asn1"
213)
214
215func main() {
216
217    //
218    // Derive private and public key (this part works)
219    //
220    seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
221    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
222
223    master, ch := hd.ComputeMastersFromSeed(seed)
224    path := "m/44'/1022'/0'/0/0'"
225    priv, _ := hd.DerivePrivateKeyForPath(master, ch, path)
226    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/1022'/0'/0/0'
227    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
228
229    var privKey = secp256k1.PrivKey(priv)
230    pubKey := privKey.PubKey()
231    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
232
233    //
234    // Sign (this part needs to be fixed)
235    //
236    data := "test"
237
238    signature, _ := privKey.Sign([]byte(data))
239    fmt.Println(hex.EncodeToString(signature))
240
241    rVal := new(big.Int)
242    rVal.SetBytes(signature[0:32])
243    sVal := new(big.Int)
244    sVal.SetBytes(signature[32:64])
245    var b cryptobyte.Builder
246    b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
247        b.AddASN1BigInt(rVal)
248        b.AddASN1BigInt(sVal)
249    })
250    signatureDER, _ := b.Bytes()
251    fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
252
253    /*
254        hash, _ := hex.DecodeString("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
255
256        // Sign without hashing
257        privateKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), priv)
258        signature, _ := privateKey.Sign(hash[:])
259
260        // Convert to ASN1/DER
261        rVal := new(big.Int)
262        rVal.SetBytes(signature.R.Bytes())
263        sVal := new(big.Int)
264        sVal.SetBytes(signature.S.Bytes())
265        var b cryptobyte.Builder
266        b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
267            b.AddASN1BigInt(rVal)
268            b.AddASN1BigInt(sVal)
269        })
270        signatureDER, _ := b.Bytes()
271        fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
272    */
273}
274Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
275Derivation Path:  m/44'/1022'/0'/0/0'
276Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
277Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
27857624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e5035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
279Signature, DER:  3044022057624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e02205035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
280

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
198package main
199
200import (
201    "encoding/hex"
202    "fmt"
203
204    "math/big"
205
206    "github.com/cosmos/cosmos-sdk/crypto/hd"
207    "github.com/cosmos/go-bip39"
208    "github.com/tendermint/tendermint/crypto/secp256k1"
209
210    //"github.com/btcsuite/btcd/btcec"
211    "golang.org/x/crypto/cryptobyte"
212    "golang.org/x/crypto/cryptobyte/asn1"
213)
214
215func main() {
216
217    //
218    // Derive private and public key (this part works)
219    //
220    seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
221    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
222
223    master, ch := hd.ComputeMastersFromSeed(seed)
224    path := "m/44'/1022'/0'/0/0'"
225    priv, _ := hd.DerivePrivateKeyForPath(master, ch, path)
226    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/1022'/0'/0/0'
227    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
228
229    var privKey = secp256k1.PrivKey(priv)
230    pubKey := privKey.PubKey()
231    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
232
233    //
234    // Sign (this part needs to be fixed)
235    //
236    data := "test"
237
238    signature, _ := privKey.Sign([]byte(data))
239    fmt.Println(hex.EncodeToString(signature))
240
241    rVal := new(big.Int)
242    rVal.SetBytes(signature[0:32])
243    sVal := new(big.Int)
244    sVal.SetBytes(signature[32:64])
245    var b cryptobyte.Builder
246    b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
247        b.AddASN1BigInt(rVal)
248        b.AddASN1BigInt(sVal)
249    })
250    signatureDER, _ := b.Bytes()
251    fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
252
253    /*
254        hash, _ := hex.DecodeString("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
255
256        // Sign without hashing
257        privateKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), priv)
258        signature, _ := privateKey.Sign(hash[:])
259
260        // Convert to ASN1/DER
261        rVal := new(big.Int)
262        rVal.SetBytes(signature.R.Bytes())
263        sVal := new(big.Int)
264        sVal.SetBytes(signature.S.Bytes())
265        var b cryptobyte.Builder
266        b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
267            b.AddASN1BigInt(rVal)
268            b.AddASN1BigInt(sVal)
269        })
270        signatureDER, _ := b.Bytes()
271        fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
272    */
273}
274Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
275Derivation Path:  m/44'/1022'/0'/0/0'
276Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
277Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
27857624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e5035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
279Signature, DER:  3044022057624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e02205035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
280return signing_key.sign_digest(  # type: ignore
281    digest=bytearray.fromhex(data),
282    sigencode=sigencode_der
283).hex()
284

1    def test_sign_message(self):
2        """ Tests the ability of the signer to sing message """
3      
4        # Loading up the signer object to use for the operation
5        signer: TestSigners = TestSigners.from_mnemonic("blast about old claw current first paste risk involve victory edit current")
6        sample_payload_to_sign = "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842'
7        # print("test".encode("UTF-8").hex())
8        s = signer.sign(sample_payload_to_sign)
9        print(s)
10
11
12from typing import List, Tuple, Dict, Union, Any
13from hdwallet.hdwallet import HDWallet
14from ecdsa.util import sigencode_der
15from ecdsa.curves import SECP256k1
16from ecdsa.keys import SigningKey
17import mnemonic
18import hashlib
19import ecdsa
20
21
22class TestSigners():
23
24    HD_WALLET_PARAMS: Dict[str, Tuple[int, bool]] = {
25        "purpose": (44, True),
26        "coinType": (1022, True),
27        "account": (0, True),
28        "change": (0, False),
29    }
30
31    def __init__(
32            self,
33            seed: Union[bytes, bytearray, str]
34    ) -> None:
35        """ Instantiates a new signer object from the seed phrase
36
37        Args:
38            seed (Union[bytes, bytearray, str]): The seed phrase used to generate the public and
39                private keys.
40        """
41
42        self.seed: Union[bytes, bytearray] = seed if isinstance(seed, (bytes, bytearray)) else bytearray.fromhex(seed)
43
44    @classmethod
45    def from_mnemonic(
46            cls,
47            mnemonic_phrase: Union[str, List[str], Tuple[str]]
48    ) -> 'Signer':
49        """
50        Instantiates a new Signer object from the mnemonic phrase passed.
51
52        Args:
53            mnemonic_phrase (Union[str, :obj:`list` of :obj:`str`, :obj:`tuple` of :obj:`str`):
54                A string, list, or a tuple of the mnemonic phrase. If the argument is passed as an
55                iterable, then it will be joined with a space.
56
57        Returns:
58            Signer: A new signer initalized through the mnemonic phrase.
59        """
60
61        # If the supplied mnemonic phrase is a list then convert it to a string
62        if isinstance(mnemonic_phrase, (list, tuple)):
63            mnemonic_string: str = " ".join(mnemonic_phrase)
64        else:
65            mnemonic_string: str = mnemonic_phrase
66
67        mnemonic_string: str = " ".join(mnemonic_phrase) if isinstance(mnemonic_phrase,
68                                                                       (list, tuple)) else mnemonic_phrase
69
70        return cls(mnemonic.Mnemonic.to_seed(mnemonic_string))
71
72    def public_key(
73            self,
74            index: int = 0
75    ) -> str:
76        """
77        Gets the public key for the signer for the specified account index
78
79        Args:
80            index (int): The account index to get the public keys for.
81
82        Returns:
83            str: A string of the public key for the wallet
84        """
85
86        return str(self.hdwallet(index).public_key())
87
88    def private_key(
89            self,
90            index: int = 0
91    ) -> str:
92        """
93        Gets the private key for the signer for the specified account index
94
95        Args:
96            index (int): The account index to get the private keys for.
97
98        Returns:
99            str: A string of the private key for the wallet
100        """
101
102        return str(self.hdwallet(index).private_key())
103
104    def hdwallet(
105            self,
106            index: int = 0
107    ) -> HDWallet:
108        """
109        Creates an HDWallet object suitable for the Radix blockchain with the passed account index.
110
111        Args:
112            index (int): The account index to create the HDWallet object for.
113
114        Returns:
115            HDWallet: An HD wallet object created with the Radix Parameters for a given account
116                index.
117        """
118
119        hdwallet: HDWallet = HDWallet()
120        hdwallet.from_seed(seed=self.seed.hex())
121        for _, values_tuple in self.HD_WALLET_PARAMS.items():
122            value, hardened = values_tuple
123            hdwallet.from_index(value, hardened=hardened)
124        hdwallet.from_index(index, True)
125
126        return hdwallet
127
128    def sign(
129            self,
130            data: str,
131            index: int = 0
132    ) -> str:
133        """
134        Signs the given data using the private keys for the account at the specified account index.
135
136        Arguments:
137            data (str): A string of the data which we wish to sign.
138            index (int): The account index to get the private keys for.
139
140        Returns:
141            str: A string of the signed data
142        """
143
144        signing_key: SigningKey = ecdsa.SigningKey.from_string(  # type: ignore
145            string=bytearray.fromhex(self.private_key(index)),
146            curve=SECP256k1,
147            hashfunc=hashlib.sha256
148        )
149
150        return signing_key.sign_digest(  # type: ignore
151            digest=bytearray.fromhex(data),
152            sigencode=sigencode_der
153        ).hex()
154package main
155
156import (
157    "encoding/hex"
158    "fmt"
159    "log"
160
161    "github.com/cosmos/cosmos-sdk/crypto/hd"
162    "github.com/cosmos/go-bip39"
163    "github.com/decred/dcrd/bech32"
164    "github.com/tendermint/tendermint/crypto/secp256k1"
165)
166
167func main() {
168
169   seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
170    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
171
172    master, ch := hd.ComputeMastersFromSeed(seed)
173    path := "m/44'/1022'/0'/0/0'"
174    priv, err := hd.DerivePrivateKeyForPath(master, ch, path)
175    if err != nil {
176        t.Fatal(err)
177    }
178    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/118'/0'/0/0'
179    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  69668f2378b43009b16b5c6eb5e405d9224ca2a326a65a17919e567105fa4e5a
180
181    var privKey = secp256k1.PrivKey(priv)
182    pubKey := privKey.PubKey()
183    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  03de79435cbc8a799efc24cdce7d3b180fb014d5f19949fb8d61de3f21b9f6c1f8
184
185    //str := "test"
186    str := "75628d14409a5126e6c882d05422c06f5eccaa192c082a9a5695a8e707109842"
187    //hx := hex.EncodeToString([]byte(str))
188    //fmt.Println(hx)
189    sign, err := privKey.Sign([]byte(str))
190    if err != nil {
191        return
192    }
193
194    fmt.Println(hex.EncodeToString(sign))
195}
19633f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
197026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
198package main
199
200import (
201    "encoding/hex"
202    "fmt"
203
204    "math/big"
205
206    "github.com/cosmos/cosmos-sdk/crypto/hd"
207    "github.com/cosmos/go-bip39"
208    "github.com/tendermint/tendermint/crypto/secp256k1"
209
210    //"github.com/btcsuite/btcd/btcec"
211    "golang.org/x/crypto/cryptobyte"
212    "golang.org/x/crypto/cryptobyte/asn1"
213)
214
215func main() {
216
217    //
218    // Derive private and public key (this part works)
219    //
220    seed := bip39.NewSeed("blast about old claw current first paste risk involve victory edit current", "")
221    fmt.Println("Seed: ", hex.EncodeToString(seed)) // Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
222
223    master, ch := hd.ComputeMastersFromSeed(seed)
224    path := "m/44'/1022'/0'/0/0'"
225    priv, _ := hd.DerivePrivateKeyForPath(master, ch, path)
226    fmt.Println("Derivation Path: ", path)                 // Derivation Path:  m/44'/1022'/0'/0/0'
227    fmt.Println("Private Key: ", hex.EncodeToString(priv)) // Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
228
229    var privKey = secp256k1.PrivKey(priv)
230    pubKey := privKey.PubKey()
231    fmt.Println("Public Key: ", hex.EncodeToString(pubKey.Bytes())) // Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
232
233    //
234    // Sign (this part needs to be fixed)
235    //
236    data := "test"
237
238    signature, _ := privKey.Sign([]byte(data))
239    fmt.Println(hex.EncodeToString(signature))
240
241    rVal := new(big.Int)
242    rVal.SetBytes(signature[0:32])
243    sVal := new(big.Int)
244    sVal.SetBytes(signature[32:64])
245    var b cryptobyte.Builder
246    b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
247        b.AddASN1BigInt(rVal)
248        b.AddASN1BigInt(sVal)
249    })
250    signatureDER, _ := b.Bytes()
251    fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
252
253    /*
254        hash, _ := hex.DecodeString("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
255
256        // Sign without hashing
257        privateKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), priv)
258        signature, _ := privateKey.Sign(hash[:])
259
260        // Convert to ASN1/DER
261        rVal := new(big.Int)
262        rVal.SetBytes(signature.R.Bytes())
263        sVal := new(big.Int)
264        sVal.SetBytes(signature.S.Bytes())
265        var b cryptobyte.Builder
266        b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
267            b.AddASN1BigInt(rVal)
268            b.AddASN1BigInt(sVal)
269        })
270        signatureDER, _ := b.Bytes()
271        fmt.Println("Signature, DER: ", hex.EncodeToString(signatureDER))
272    */
273}
274Seed:  dd5ffa7088c0fa4c665085bca7096a61e42ba92e7243a8ad7fbc6975a4aeea1845c6b668ebacd024fd2ca215c6cd510be7a9815528016af3a5e6f47d1cca30dd
275Derivation Path:  m/44'/1022'/0'/0/0'
276Private Key:  33f34dad4bc0ce9dc320863509aed43cab33a93a29752779ae0df6dbbea33e56
277Public Key:  026557fe37d5cab1cc8edf474f4baff67dbb2305f1764e42d31b09f83296f5de2b
27857624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e5035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
279Signature, DER:  3044022057624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e02205035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b
280return signing_key.sign_digest(  # type: ignore
281    digest=bytearray.fromhex(data),
282    sigencode=sigencode_der
283).hex()
284from ecdsa.util import sigdecode_der 
285signature = signing_key.sign_digest(  # from Python Code
286    digest=bytearray.fromhex(data),
287    sigencode=sigencode_der
288)
289#signature = bytes.fromhex('3044022057624717f71fae8b5917cde0f82dfe6c2e2104183ba01c6a1c9f0a8e66d3303e02205035b52876d833522aace232c1d231b3aeeff303cf02d1677a240102365ce71b') # from Go code    
290verifying_key = signing_key.verifying_key
291verified = verifying_key.verify_digest(signature, digest=bytearray.fromhex(data), sigdecode=sigdecode_der)
292print(verified)
293return signature.hex()
294

1Retrieving compiler information:
2Compiler using remote version: 'v0.8.0+commit.c7dfd78e', solidity version: 0.8.0+commit.c7dfd78e.Emscripten.clang
3PS D:\Python projects\Solidity dev\demo\smartcontract-lottery> brownie compile
4INFO: Could not find files for the given pattern(s).
5Brownie v1.17.2 - Python development framework for Ethereum
6
7Compiling contracts...
8  Solc version: 0.6.12
9  Optimizer: Enabled  Runs: 200
10  EVM Version: Istanbul
11CompilerError: solc returned the following errors:
12
13C:/Users/rosne/.brownie/packages/OpenZeppelin/openzeppelin-contracts@4.3.0/contracts/access/Ownable.sol:3:1: ParserError: Source file requires different compiler version (current compiler is 0.6.12+commit.27d51765.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
14pragma solidity ^0.8.0;
15^---------------------^
16
17C:/Users/rosne/.brownie/packages/smartcontractkit/chainlink-brownie-contracts@0.2.1/contracts/src/v0.8/VRFConsumerBase.sol:2:1: ParserError: Source file requires different compiler version (current compiler is 0.6.12+commit.27d51765.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
18pragma solidity ^0.8.0;
19^---------------------^
20
21PS D:\Python projects\Solidity dev\demo\smartcontract-lottery>
22// SPDX-License-Identifier: MIT
23pragma solidity ^0.6.0;
24
25import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
26import "@openzeppelin/contracts/access/Ownable.sol";
27import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
28
29contract Lottery is VRFConsumerBase, Ownable {
30    uint256 usdEntryFee;
31    address payable[] public players;
32    address payable public recentWinner;
33    uint256 public randomness;
34    AggregatorV3Interface internal ethUsdPriceFeed;
35    enum LOTTERY_STATE {
36        OPEN,
37        CLOSED,
38        CALCULATING_WINNER
39    }
40
41    LOTTERY_STATE public lottery_state;
42    uint256 public fee;
43    bytes32 public keyhash;
44
45    constructor(
46        address _priceFeedAddress,
47        address _vrfCoordinator,
48        address _link,
49        uint256 _fee,
50        bytes32 _keyhash
51    ) public VRFConsumerBase(_vrfCoordinator, _link) {
52        usdEntryFee = 50 * (10**18);
53        ethUsdPriceFeed = AggregatorV3Interface(_priceFeedAddress);
54        lottery_state = LOTTERY_STATE.CLOSED;
55        fee = _fee;
56        keyhash = _keyhash;
57    }
58
59    function enter() public payable {
60        //$50 min
61        require(lottery_state == LOTTERY_STATE.OPEN);
62        require(msg.value >= getEntranceFee(), "Not enough ETH!");
63        players.push(payable(msg.sender));
64    }
65
66    function getEntranceFee() public view returns (uint256) {
67        (, int256 price, , , ) = ethUsdPriceFeed.latestRoundData();
68        uint256 adjustedPrice = uint256(price) * 10**12; //18 decimals
69        //$50, 2000 ETH
70        //50/2000
71        //50*10000/2000
72        uint256 costToEnter = (usdEntryFee * 10**18) / adjustedPrice;
73        return costToEnter;
74    }
75
76    function startLottery() public onlyOwner {
77        require(
78            lottery_state == LOTTERY_STATE.CLOSED,
79            "cant start a new lottery yet"
80        );
81        lottery_state = LOTTERY_STATE.OPEN;
82    }
83
84    function endLottery() public onlyOwner {
85        lottery_state = LOTTERY_STATE.CALCULATING_WINNER;
86        bytes32 requestId = requestRandomness(keyhash, fee);
87    }
88
89    function FulfillRandomness(bytes32 _requestId, uint256 _randomness)
90        internal
91        override
92    {
93        require(
94            lottery_state == LOTTERY_STATE.CALCULATING_WINNER,
95            "you arent there yet!"
96        );
97
98        require(_randomness > 0, "random not found");
99        uint256 indexOfWinner = _randomness % players.length;
100        recentWinner = players[indexOfWinner];
101        recentWinner.transfer(address(this).balance);
102
103        //reset
104
105        players = new address payable[](0);
106        lottery_state = LOTTERY_STATE.CLOSED;
107        randomness = _randomness;
108    }
109}
110
111{
112    "solidity.compileUsingRemoteVersion": "v0.8.0+commit.c7dfd78e",
113    "solidity.defaultCompiler": "remote",
114    "solidity.compileUsingLocalVersion": "d:\\Python projects\\Solidity dev\\demo\\smartcontract-lottery\\soljson-v0.8.0+commit.c7dfd78e.js"
115    // "solidity.compileUsingRemoteVersion": "v0.7.4+commit.3f05b770",
116    // "solidity.enableLocalNodeCompiler": false
117}
118dependencies:
119  - smartcontractkit/chainlink-brownie-contracts@1.1.1
120  - OpenZeppelin/openzeppelin-contracts@4.3.0
121compiler:
122  solc:
123    remappings:
124      - '@chainlink=smartcontractkit/chainlink-brownie-contracts@0.2.1'
125      - '@openzeppelin=OpenZeppelin/openzeppelin-contracts@4.3.0'
126networks:
127  mainnet-fork:
128    eth_usd_price_feed: '0xaEA2808407B7319A31A383B6F8B60f04BCa23cE2'
129// SPDX-License-Identifier: MIT
130pragma solidity ^0.8.0;
131INFO: Could not find files for the given pattern(s).
132Brownie v1.17.2 - Python development framework for Ethereum
133
134Compiling contracts...
135  Solc version: 0.8.11
136  Optimizer: Enabled  Runs: 200
137  EVM Version: Istanbul
138CompilerError: solc returned the following errors:
139
140ParserError: Source file requires different compiler version (current compiler is 0.8.11+commit.d7f03943.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
141 --> C:/Users/rosne/.brownie/packages/smartcontractkit/chainlink-brownie-contracts@0.2.1/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol:2:1:
142  |
1432 | pragma solidity ^0.6.0;
144  | ^^^^^^^^^^^^^^^^^^^^^^^
145
146PS D:\Python projects\Solidity dev\demo\smartcontract-lottery> 
147pragma solidity >=0.4.22 <0.9.0;
148

1Retrieving compiler information:
2Compiler using remote version: 'v0.8.0+commit.c7dfd78e', solidity version: 0.8.0+commit.c7dfd78e.Emscripten.clang
3PS D:\Python projects\Solidity dev\demo\smartcontract-lottery> brownie compile
4INFO: Could not find files for the given pattern(s).
5Brownie v1.17.2 - Python development framework for Ethereum
6
7Compiling contracts...
8  Solc version: 0.6.12
9  Optimizer: Enabled  Runs: 200
10  EVM Version: Istanbul
11CompilerError: solc returned the following errors:
12
13C:/Users/rosne/.brownie/packages/OpenZeppelin/openzeppelin-contracts@4.3.0/contracts/access/Ownable.sol:3:1: ParserError: Source file requires different compiler version (current compiler is 0.6.12+commit.27d51765.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
14pragma solidity ^0.8.0;
15^---------------------^
16
17C:/Users/rosne/.brownie/packages/smartcontractkit/chainlink-brownie-contracts@0.2.1/contracts/src/v0.8/VRFConsumerBase.sol:2:1: ParserError: Source file requires different compiler version (current compiler is 0.6.12+commit.27d51765.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
18pragma solidity ^0.8.0;
19^---------------------^
20
21PS D:\Python projects\Solidity dev\demo\smartcontract-lottery>
22// SPDX-License-Identifier: MIT
23pragma solidity ^0.6.0;
24
25import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
26import "@openzeppelin/contracts/access/Ownable.sol";
27import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
28
29contract Lottery is VRFConsumerBase, Ownable {
30    uint256 usdEntryFee;
31    address payable[] public players;
32    address payable public recentWinner;
33    uint256 public randomness;
34    AggregatorV3Interface internal ethUsdPriceFeed;
35    enum LOTTERY_STATE {
36        OPEN,
37        CLOSED,
38        CALCULATING_WINNER
39    }
40
41    LOTTERY_STATE public lottery_state;
42    uint256 public fee;
43    bytes32 public keyhash;
44
45    constructor(
46        address _priceFeedAddress,
47        address _vrfCoordinator,
48        address _link,
49        uint256 _fee,
50        bytes32 _keyhash
51    ) public VRFConsumerBase(_vrfCoordinator, _link) {
52        usdEntryFee = 50 * (10**18);
53        ethUsdPriceFeed = AggregatorV3Interface(_priceFeedAddress);
54        lottery_state = LOTTERY_STATE.CLOSED;
55        fee = _fee;
56        keyhash = _keyhash;
57    }
58
59    function enter() public payable {
60        //$50 min
61        require(lottery_state == LOTTERY_STATE.OPEN);
62        require(msg.value >= getEntranceFee(), "Not enough ETH!");
63        players.push(payable(msg.sender));
64    }
65
66    function getEntranceFee() public view returns (uint256) {
67        (, int256 price, , , ) = ethUsdPriceFeed.latestRoundData();
68        uint256 adjustedPrice = uint256(price) * 10**12; //18 decimals
69        //$50, 2000 ETH
70        //50/2000
71        //50*10000/2000
72        uint256 costToEnter = (usdEntryFee * 10**18) / adjustedPrice;
73        return costToEnter;
74    }
75
76    function startLottery() public onlyOwner {
77        require(
78            lottery_state == LOTTERY_STATE.CLOSED,
79            "cant start a new lottery yet"
80        );
81        lottery_state = LOTTERY_STATE.OPEN;
82    }
83
84    function endLottery() public onlyOwner {
85        lottery_state = LOTTERY_STATE.CALCULATING_WINNER;
86        bytes32 requestId = requestRandomness(keyhash, fee);
87    }
88
89    function FulfillRandomness(bytes32 _requestId, uint256 _randomness)
90        internal
91        override
92    {
93        require(
94            lottery_state == LOTTERY_STATE.CALCULATING_WINNER,
95            "you arent there yet!"
96        );
97
98        require(_randomness > 0, "random not found");
99        uint256 indexOfWinner = _randomness % players.length;
100        recentWinner = players[indexOfWinner];
101        recentWinner.transfer(address(this).balance);
102
103        //reset
104
105        players = new address payable[](0);
106        lottery_state = LOTTERY_STATE.CLOSED;
107        randomness = _randomness;
108    }
109}
110
111{
112    "solidity.compileUsingRemoteVersion": "v0.8.0+commit.c7dfd78e",
113    "solidity.defaultCompiler": "remote",
114    "solidity.compileUsingLocalVersion": "d:\\Python projects\\Solidity dev\\demo\\smartcontract-lottery\\soljson-v0.8.0+commit.c7dfd78e.js"
115    // "solidity.compileUsingRemoteVersion": "v0.7.4+commit.3f05b770",
116    // "solidity.enableLocalNodeCompiler": false
117}
118dependencies:
119  - smartcontractkit/chainlink-brownie-contracts@1.1.1
120  - OpenZeppelin/openzeppelin-contracts@4.3.0
121compiler:
122  solc:
123    remappings:
124      - '@chainlink=smartcontractkit/chainlink-brownie-contracts@0.2.1'
125      - '@openzeppelin=OpenZeppelin/openzeppelin-contracts@4.3.0'
126networks:
127  mainnet-fork:
128    eth_usd_price_feed: '0xaEA2808407B7319A31A383B6F8B60f04BCa23cE2'
129// SPDX-License-Identifier: MIT
130pragma solidity ^0.8.0;
131INFO: Could not find files for the given pattern(s).
132Brownie v1.17.2 - Python development framework for Ethereum
133
134Compiling contracts...
135  Solc version: 0.8.11
136  Optimizer: Enabled  Runs: 200
137  EVM Version: Istanbul
138CompilerError: solc returned the following errors:
139
140ParserError: Source file requires different compiler version (current compiler is 0.8.11+commit.d7f03943.Windows.msvc) - note that nightly builds are considered to be strictly less than the released version
141 --> C:/Users/rosne/.brownie/packages/smartcontractkit/chainlink-brownie-contracts@0.2.1/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol:2:1:
142  |
1432 | pragma solidity ^0.6.0;
144  | ^^^^^^^^^^^^^^^^^^^^^^^
145
146PS D:\Python projects\Solidity dev\demo\smartcontract-lottery> 
147pragma solidity >=0.4.22 <0.9.0;
148 pragma solidity >=0.4.22 <0.8.0;
149