Nucypher
/
nucypher
mirror of https://github.com/nucypher/nucypher.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #951 from nucypher/hawksbeard 

[EPIC] Decentralized Characters & Integrated Ethereum Node Providers
pull/1069/head
K Prasch 2019-06-05 09:06:12 -07:00 committed by GitHub
parent 04e39e51e8 c873ad8784
commit 9330e69bee
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
101 changed files with 3918 additions and 1353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
.circleci/config.yml
View File

@ -243,6 +243,19 @@ commands:
command: ./scripts/installation/install_solc.sh
- check_nucypher_entrypoints
pip_install_no_dev:
description: "Install NuCypher with Pip (no development dependencies)"
steps:
- checkout
- run:
name: Install Python Dependencies with Pip
command: pip3 install --user .
- check_nucypher_entrypoints # Ensure Standard Installation Entry-points Work
- run:
name: Install Solidity Compiler
command: ./scripts/installation/install_solc.sh
- check_nucypher_entrypoints
prepare_environment:
description: "Checkout application code and Attach the Workspace"
steps:
@ -345,7 +358,7 @@ jobs:
- run:
name: Tests for Blockhain interfaces, Crypto functions, Node Configuration and Keystore
command: |
pipenv run pytest --durations=0 --cov=nucypher --cov-report xml:reports/coverage.xml $(circleci tests glob "tests/config/**/test_*.py" "tests/crypto/**/test_*.py" "tests/keystore/**/test_*.py" "tests/blockchain/eth/interfaces/**/test_*.py" | circleci tests split --split-by=timings)
pipenv run pytest --durations=0 --cov=nucypher --cov-report xml:reports/coverage.xml $(circleci tests glob "tests/config/**/test_*.py" "tests/crypto/**/test_*.py" "tests/keystore/**/test_*.py" "tests/blockchain/eth/interfaces/**/test_*.py" "tests/blockchain/eth/clients/**/test_*.py" | circleci tests split --split-by=timings)
- capture_test_results
network:
@ -390,22 +403,25 @@ jobs:
heartbeat_demo:
<<: *python_36_base
steps:
- checkout
- pip_install
- run:
name: Run demo Ursula fleet, Alicia and the Doctor
command: ./scripts/demos/run_heartbeat_demo.sh
- store_artifacts:
path: /tmp/ursulas-logs
- checkout
- pip_install_no_dev
- run:
name: Run demo Ursula fleet, Alicia and the Doctor
command: ./scripts/demos/run_heartbeat_demo.sh
- store_artifacts:
path: /tmp/ursulas-logs
finnegans_wake_demo:
<<: *python_36_base
steps:
- checkout
- pip_install
- pip_install_no_dev
- run:
name: Run demo Ursula fleet, Finnegans wake Demo code
command: ./scripts/demos/run_finnegans_wake_demo.sh
command: |
./scripts/demos/run_finnegans_wake_demo.sh || true
sleep 5
./scripts/demos/run_finnegans_wake_demo.sh
- store_artifacts:
path: /tmp/ursulas-logs

2
README.md
View File

@ -102,5 +102,3 @@ A great place to begin your research is by working on our testnet.
Please see our [documentation](https://docs.nucypher.com) to get started.
We ask that you please respect testnet machines and their owners.
If you find a vulnerability that you suspect has given you access to a machine against the owner's permission, stop what you're doing and immediately email security@nucypher.com.

117
deploy/ansible/felix/initialize_felix.yml Normal file
View File

@ -0,0 +1,117 @@
- name: "Start Felix"
hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_felix' }}"
user: ubuntu
gather_facts: false
pre_tasks:
- name: "Install Python2.7 for Ansible Control"
raw: sudo apt -y update && sudo apt install -y python2.7-minimal python2.7-setuptools
- include_vars: "{{ lookup('env', 'ANSIBLE_VARIABLES') }}"
- include_vars:
file: "{{ networks_filepath }}"
name: networks
tasks:
- name: "Register Ethereum PPA"
become: yes
become_flags: "-H -S"
apt_repository:
repo: 'ppa:ethereum/ethereum'
state: present
- name: "Install System Dependencies"
become: yes
become_flags: "-H -S"
apt:
name: "{{ packages }}"
update_cache: yes
state: latest
vars:
packages:
- python-pip
- python3
- python3-pip
- python3-dev
- python3-setuptools
- libffi-dev
- software-properties-common
- ethereum
- npm
- git:
repo: "{{ git_repo }}"
dest: ./code
version: "{{ git_version }}"
- pip:
chdir: ./code
name: '.'
editable: true
virtualenv: '/home/ubuntu/venv'
virtualenv_python: python3.6
virtualenv_site_packages: true
environment:
LC_ALL: en_US.UTF-8
LANG: en_US.UTF-8
- name: "Check if 'felix.config' Exists"
become: yes
become_flags: "-H -S"
stat:
path: "~/.local/share/nucypher/felix.config"
register: config_stat_result
- name: "Initialize Felix Configuration"
become: yes
become_flags: "-H -S"
shell: "{{ nucypher_exec }} felix init --geth --network {{ network }}"
environment:
NUCYPHER_KEYRING_PASSWORD: "{{ lookup('env', 'NUCYPHER_FELIX_KEYRING_PASSWORD') }}"
LC_ALL: en_US.UTF-8
LANG: en_US.UTF-8
vars:
nucypher_exec: "/home/ubuntu/venv/bin/nucypher"
network: "{{ lookup('env', 'NUCYPHER_NETWORK_NAME') }}"
when: config_stat_result.stat.exists == False
- name: "Check if 'felix.db' Exists"
become: yes
become_flags: "-H -S"
stat:
path: "~/.local/share/nucypher/felix.db"
register: db_stat_result
- name: "Initialize Felix Database"
become: yes
become_flags: "-H -S"
shell: "{{ nucypher_exec }} felix createdb --geth --network {{ network }}"
environment:
NUCYPHER_KEYRING_PASSWORD: "{{ lookup('env', 'NUCYPHER_FELIX_KEYRING_PASSWORD') }}"
NUCYPHER_FELIX_DB_SECRET: "{{ lookup('env', 'NUCYPHER_FELIX_DB_SECRET') }}"
LC_ALL: en_US.UTF-8
LANG: en_US.UTF-8
vars:
nucypher_exec: "/home/ubuntu/venv/bin/nucypher"
network: "{{ lookup('env', 'NUCYPHER_NETWORK_NAME') }}"
when: db_stat_result.stat.exists == False
- name: "Open Felix HTTP Port"
become: yes
become_flags: "-H -S"
shell: 'iptables -A INPUT -p tcp -m conntrack --dport {{ felix_http_port }} --ctstate NEW,ESTABLISHED -j ACCEPT'
vars:
felix_http_port: 6151
- name: "Render Felix's Node Service"
become: yes
become_flags: "-H -S"
template:
src: ../../services/felix_faucet.j2
dest: /etc/systemd/system/felix_faucet.service
mode: 0755
vars:
keyring_password: "{{ lookup('env', 'NUCYPHER_FELIX_KEYRING_PASSWORD') }}"
db_secret: "{{ lookup('env', 'NUCYPHER_FELIX_DB_SECRET') }}"
virtualenv_path: '/home/ubuntu/venv'
nucypher_network_domain: "{{ lookup('env', 'NUCYPHER_NETWORK_NAME') }}"

51
deploy/ansible/felix/launch_felix.yml Normal file
View File

@ -0,0 +1,51 @@
- name: "Start Felix"
hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_felix' }}"
user: ubuntu
gather_facts: false
pre_tasks:
- name: "Install Python2.7 for Ansible Control"
raw: sudo apt -y update && sudo apt install -y python2.7-minimal python2.7-setuptools
- include_vars: "{{ lookup('env', 'ANSIBLE_VARIABLES') }}"
- include_vars:
file: "{{ networks_filepath }}"
name: networks
tasks:
- git:
repo: "{{ git_repo }}"
dest: ./code
version: "{{ git_version }}"
- name: "Render Felix's Node Service"
become: yes
become_flags: "-H -S"
template:
src: ../../services/felix_faucet.j2
dest: /etc/systemd/system/felix_faucet.service
mode: 0755
vars:
keyring_password: "{{ lookup('env', 'NUCYPHER_FELIX_KEYRING_PASSWORD') }}"
db_secret: "{{ lookup('env', 'NUCYPHER_FELIX_DB_SECRET') }}"
virtualenv_path: '/home/ubuntu/venv'
nucypher_network_domain: "{{ lookup('env', 'NUCYPHER_NETWORK_NAME') }}"
teacher_uri: "{{ networks[lookup('env', 'NUCYPHER_NETWORK_NAME')][0] }}"
- name: "Open Felix HTTP Port"
become: yes
become_flags: "-H -S"
shell: 'iptables -A INPUT -p tcp -m conntrack --dport {{ felix_http_port }} --ctstate NEW,ESTABLISHED -j ACCEPT'
vars:
felix_http_port: 6151
- name: "Enable and Start Distribution"
become: yes
become_flags: "-H -S"
systemd:
daemon_reload: yes
no_block: yes
enabled: yes
state: restarted
name: "felix_faucet"

44
deploy/ansible/felix/update_felix.yml Normal file
View File

@ -0,0 +1,44 @@
- name: "Start Felix"
hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_felix' }}"
user: ubuntu
gather_facts: false
pre_tasks:
- name: "Install Python2.7 for Ansible Control"
raw: sudo apt -y update && sudo apt install -y python2.7-minimal python2.7-setuptools
- include_vars: "{{ lookup('env', 'ANSIBLE_VARIABLES') }}"
- include_vars:
file: "{{ networks_filepath }}"
name: networks
tasks:
- git:
repo: "{{ git_repo }}"
dest: ./code
version: "{{ git_version }}"
- name: "Open Felix HTTP Port"
become: yes
become_flags: "-H -S"
shell: 'iptables -A INPUT -p tcp -m conntrack --dport {{ felix_http_port }} --ctstate NEW,ESTABLISHED -j ACCEPT'
vars:
felix_http_port: 80
- name: "Open Felix HTTP Port"
become: yes
become_flags: "-H -S"
shell: 'iptables -A INPUT -p tcp -m conntrack --dport {{ felix_http_port }} --ctstate NEW,ESTABLISHED -j ACCEPT'
vars:
felix_http_port: 6151
- name: "Enable and Start Distribution"
become: yes
become_flags: "-H -S"
systemd:
daemon_reload: yes
no_block: yes
enabled: yes
state: restarted
name: "felix_faucet"

7
deploy/ansible/geth/files/bootnodes.txt
View File

@ -1 +1,6 @@
enode://3797aea9ce4ba1595be264f623dcb3b4e441744ed46dac44b80df2ae0d5164cf711a9f3868cb81315dbdd991bf614671a13ca1c778ba4b175aa4b31f655a7c11@3.81.88.207:30301
enode://bf150c793f378775e8cf09bee4fba37ea65363fe7a41171790a80ef6462de619cad2c05f42fc58655ad317503d5da8fee898e911fdf386ac6d15da12b5e883eb@3.92.166.78:30301
enode://13da3c4b5b1ca32dfb0fcd662b9c69daf6b564e6f791ddae107d57049f25952aac329de336fd393f5b42b6aa2bbb263d7aa5c426b473be611739795aa18b0212@54.173.27.77:30303
enode://4f7a27820107c235bb0f8086ee1c2bad62174450ec2eec12cb29e3fa7ecb9f332710373c1d11a3115aa72f2dabbae27b73eac51f06d3df558dd9fb51007da653@52.91.112.249:30303
enode://6b58a9437aa88f254b75110019c54807cf1d7da9729f2c022a2463bae86b639288909fe00ffac0599e616676eea2de3c503bacaf4be835a02195bea0b349ca80@54.88.246.77:30303
enode://562051180eca42514e44b4428ed20a3cb626654631f53bbfa549de7d3b7e418376e8f784c232429d7ff01bd0597e3ce7327699bb574d39ac3b2ac1729ed0dd44@54.224.110.32:30303
enode://d372b6a4ebd63a39d55cb9a50fc3c8a95ef0cbb1921da20c7e1de3dbf94a5f82969fe6396140e89bf73b792af291c91446ea8851fe0aae6847e934d8a52b22a4@34.226.198.231:30303

31
deploy/ansible/geth/files/genesis.j2
View File

@ -1,17 +1,20 @@
{
"config": {
"chainId": 112358,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0
"coinbase" : "0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1",
"difficulty" : "10000",
"extraData" : "0x",
"gasLimit" : "8000000",
"nonce" : "0x0112358132134550",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"alloc": {
"0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1": {"balance": "100000000000000000000000"}
},
"alloc" : {},
"coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "400",
"extraData" : "",
"gasLimit" : "8000000",
"nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00"
"config": {
"chainId": 112358,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0,
"byzantiumBlock": 0
}
}

52
deploy/ansible/geth/init_blockchain.yml Normal file
View File

@ -0,0 +1,52 @@
---
- hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_bootnodes' }}"
name: "GatherBootnode Facts"
user: ubuntu
tasks: [ ]
- name: "Initialize blockchain database"
hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_miners' }}"
user: ubuntu
gather_facts: false
tasks:
- name: "Render Genesis Configuration"
become: yes
become_flags: "-H -S"
template:
src: ./files/genesis.j2
dest: /home/ubuntu/genesis.json
mode: 0755
- name: "Create Custom Blockchain Data Directory"
file:
path: /home/ubuntu/chaindata
state: directory
mode: 0755
- name: "Learn About Existing Accounts"
shell: geth account list --datadir {{datadir}}
register: geth_accounts
vars:
datadir: "/home/ubuntu/chaindata"
- name: "Generate Geth Password"
shell: head -c 32 /dev/urandom | sha256sum | awk '{print $1}'
register: geth_password
- name: "Create Geth Account"
become: yes
become_flags: "-H -S"
shell: geth account new --datadir /home/ubuntu/chaindata --password ./password.txt
register: new_geth_account
when: "'Account' not in geth_accounts.stdout"
- name: "Initialize New Blockchain - Awh"
become: yes
become_flags: "-H -S"
shell: geth --datadir {{datadir}} --networkid {{networkid}} init {{genesis_file}}
vars:
networkid: "112358"
datadir: "/home/ubuntu/chaindata"
genesis_file: "/home/ubuntu/genesis.json"

50
deploy/ansible/geth/launch_nodes.yml
View File

@ -48,52 +48,6 @@
name: pm2
global: yes
- name: "Render Genesis Configuration"
become: yes
become_flags: "-H -S"
template:
src: ./files/genesis.j2
dest: /home/ubuntu/genesis.json
mode: 0755
- name: "Create Custom Blockchain Data Directory"
file:
path: /home/ubuntu/chaindata
state: directory
mode: 0755
- name: "Learn About Existing Accounts"
shell: geth account list --datadir {{datadir}}
register: geth_accounts
vars:
datadir: "/home/ubuntu/chaindata"
- name: "Generate Geth Password"
shell: head -c 32 /dev/urandom | sha256sum | awk '{print $1}'
register: geth_password
- name: "Generate Password File"
become: yes
become_flags: "-H -S"
shell: "echo {{ geth_password }} > ./password.txt"
when: "'Account' not in geth_accounts.stdout"
- name: "Create Geth Account"
become: yes
become_flags: "-H -S"
shell: geth account new --datadir /home/ubuntu/chaindata --password ./password.txt
register: new_geth_account
when: "'Account' not in geth_accounts.stdout"
- name: "Initialize New Blockchain - Awh"
become: yes
become_flags: "-H -S"
shell: geth --datadir {{datadir}} --networkid {{networkid}} init {{genesis_file}}
vars:
networkid: "112358"
datadir: "/home/ubuntu/chaindata"
genesis_file: "/home/ubuntu/genesis.json"
- name: "Render Geth Node Service"
become: yes
become_flags: "-H -S"
@ -102,11 +56,11 @@
dest: /etc/systemd/system/geth_miner.service
mode: 0755
vars:
etherbase: "0"
datadir: "/home/ubuntu/chaindata"
networkid: "112358"
rpchost: "localhost"
syncmode: "full"
nickname: "testnet-miner-{{ inventory_hostname }}"
nickname: "NuCypher-Testnet-{{ hostvars[inventory_hostname].ec2_tag_Name }}"
eth_netstats_secret: "{{ lookup('env', 'ETH_NETSTATS_SECRET') }}"
eth_netstats_ip: "{{ hostvars[groups['tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_eth_netstats'][0]].ansible_host }}"
eth_netstats_port: "3000"

58
deploy/ansible/geth/wipe_chaindata.yml
View File

@ -28,59 +28,15 @@
state: absent
mode: 0755
- name: "Create Custom Blockchain Data Directory"
- name: "Destroy Standard Blockchain Data Directory"
become: yes
become_flags: "-H -S"
file:
path: /home/ubuntu/chaindata
state: directory
path: /home/.ethereum/geth/chaindata
state: absent
mode: 0755
- name: "Render Genesis Configuration"
- name: "Destroy DAG"
become: yes
become_flags: "-H -S"
template:
src: ./files/genesis.j2
dest: /home/ubuntu/genesis.json
mode: 0755
- name: "Learn About Existing Accounts"
shell: geth account list --datadir {{datadir}}
register: geth_accounts
vars:
datadir: "/home/ubuntu/chaindata"
- name: "Initialize Blockchain Database"
become: yes
become_flags: "-H -S"
shell: geth --datadir {{datadir}} --networkid {{networkid}} init {{genesis_file}}
vars:
networkid: "112358"
datadir: "/home/ubuntu/chaindata"
genesis_file: "/home/ubuntu/genesis.json"
- name: "Render Geth Node Service"
become: yes
become_flags: "-H -S"
template:
src: ../../services/geth_miner.j2
dest: /etc/systemd/system/geth_miner.service
mode: 0755
vars:
etherbase: "0"
datadir: "/home/ubuntu/chaindata"
networkid: "112358"
syncmode: "full"
nickname: "testnet-miner-{{ inventory_hostname }}"
eth_netstats_secret: "{{ lookup('env', 'ETH_NETSTATS_SECRET') }}"
eth_netstats_ip: "{{ hostvars[groups['tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_eth_netstats'][0]].ansible_host }}"
eth_netstats_port: "3000"
bootnode_uri: "{{ lookup('file', './files/bootnodes.txt') }}"
- name: "Enable and Start Geth Node Service"
become: yes
become_flags: "-H -S"
systemd:
daemon_reload: yes
no_block: yes
enabled: yes
state: restarted
name: "geth_miner"
shell: "rm -rf /root/.ethash"

18
deploy/ansible/ursulas/rename_configs.yml Normal file
View File

@ -0,0 +1,18 @@
- name: "Rename Ursula configuration files"
hosts: "{{ 'tag_Role_' + lookup('env', 'NUCYPHER_NETWORK_NAME') + '_ursulas' }}"
user: ubuntu
gather_facts: false
vars:
old: ~/.local/share/nucypher/Ursula.config
new: ~/.local/share/nucypher/ursula.config
pre_tasks:
- include_vars: "{{ lookup('env', 'ANSIBLE_VARIABLES') }}"
tasks:
- name: Check for existing configuration file
stat: path={{ old }}
register: configuration_file
- name: Rename Configuration File (if existing)
command: mv {{ old }} {{ new }}
when: configuration_file.stat.exists

17
deploy/geth/custom_genesis.json
View File

@ -1,17 +0,0 @@
{
"coinbase" : "0x0000000000000000000000000000000000000001",
"difficulty" : "0x20000",
"extraData" : "",
"gasLimit" : "0x8000000",
"nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"alloc": {},
"config": {
"chainId": 15,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0
}
}

20
deploy/geth/genesis.json Normal file
View File

@ -0,0 +1,20 @@
{
"coinbase" : "0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1",
"difficulty" : "10000",
"extraData" : "0x",
"gasLimit" : "8000000",
"nonce" : "0x0112358132134550",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"alloc": {
"0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1": {"balance": "100000000000000000000000"}
},
"config": {
"chainId": 112358,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0,
"byzantiumBlock": 0
}
}

12
deploy/services/felix_faucet.j2 Normal file
View File

@ -0,0 +1,12 @@
[Unit]
Description="Run 'Felix', A NuCypher Test-ERC20 Faucet."
[Service]
User=root
Type=simple
Environment="NUCYPHER_KEYRING_PASSWORD={{ keyring_password }}"
Environment="NUCYPHER_FELIX_DB_SECRET={{ db_secret }}"
ExecStart={{ virtualenv_path }}/bin/nucypher --debug felix run --network {{ nucypher_network_domain }} --geth
[Install]
WantedBy=multi-user.target

8
deploy/services/geth_miner.j2
View File

@ -9,14 +9,14 @@ ExecStart=/usr/bin/geth --datadir {{ datadir }} \
--port 30303 \
--syncmode {{ syncmode }} \
--rpc \
--rpcaddr 'localhost' \
--rpcapi "db,eth,net,web3" \
--rpcaddr "{{ rpchost }}" \
--rpcapi "eth,net,web3,miner,debug,personal,rpc,admin" \
--rpccorsdomain "*" \
--mine \
--minerthreads 1 \
--ethstats {{ nickname }}:{{ eth_netstats_secret }}@{{ eth_netstats_ip }}:{{ eth_netstats_port }} \
--bootnodes {{ bootnode_uri }} \
--etherbase {{ etherbase }} \
--verbosity 6 \
--verbosity 8 \
[Install]
WantedBy=multi-user.target

7
deploy/static-nodes.json Normal file
View File

@ -0,0 +1,7 @@
[
"enode://bf150c793f378775e8cf09bee4fba37ea65363fe7a41171790a80ef6462de619cad2c05f42fc58655ad317503d5da8fee898e911fdf386ac6d15da12b5e883eb@3.92.166.78:30301",
"enode://13da3c4b5b1ca32dfb0fcd662b9c69daf6b564e6f791ddae107d57049f25952aac329de336fd393f5b42b6aa2bbb263d7aa5c426b473be611739795aa18b0212@54.173.27.77:30303",
"enode://4f7a27820107c235bb0f8086ee1c2bad62174450ec2eec12cb29e3fa7ecb9f332710373c1d11a3115aa72f2dabbae27b73eac51f06d3df558dd9fb51007da653@52.91.112.249:30303",
"enode://6b58a9437aa88f254b75110019c54807cf1d7da9729f2c022a2463bae86b639288909fe00ffac0599e616676eea2de3c503bacaf4be835a02195bea0b349ca80@54.88.246.77:30303",
"enode://562051180eca42514e44b4428ed20a3cb626654631f53bbfa549de7d3b7e418376e8f784c232429d7ff01bd0597e3ce7327699bb574d39ac3b2ac1729ed0dd44@54.224.110.32:30303"
]

20
deploy/testnet_genesis.json Normal file
View File

@ -0,0 +1,20 @@
{
"coinbase" : "0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1",
"difficulty" : "10000",
"extraData" : "0x",
"gasLimit" : "8000000",
"nonce" : "0x0112358132134550",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"alloc": {
"0xA87722643685B38D37ecc7637ACA9C1E09c8C5e1": {"balance": "100000000000000000000000"}
},
"config": {
"chainId": 112358,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0,
"byzantiumBlock": 0
}
}

2
docs/NuCypher_Beachhead.ipynb
View File

@ -584,7 +584,7 @@
"source": [
" delivered_cleartext = BOB.retrieve(message_kit=message_kit,\n",
" data_source=enrico_as_understood_by_bob,\n",
" alice_pubkey_sig=alices_pubkey_saved_for_posterity)"
" alice_verifying_key=alices_pubkey_saved_for_posterity)"
]
},
{

4
docs/source/guides/character_control_guide.rst
View File

@ -122,7 +122,7 @@ This endpoint controls the ``Alice.grant`` method.
- HTTP Method: ``PUT``
- Required arguments:
- ``bob_encrypting_key`` -- encoded as hex
- ``label`` -- encoded as base64
- ``label`` -- a unicode string
- ``m`` -- an integer
- ``n`` -- an integer
- ``expiration`` -- an ISO-8601 formatted datetime string
@ -147,7 +147,7 @@ This endpoint controls the ``Bob.retrieve`` method.
- ``policy_encrypting_pubkey`` -- encoded as hex
- ``alice_signing_pubkey`` -- encoded as hex
- ``datasource_signing_pubkey`` -- encoded as hex
- ``label`` -- encoded as base64
- ``label`` -- a unicode string
- ``message_kit`` -- encoded as base64
- Returns: a JSON-array of base64-encoded decrypted plaintexts as ``plaintext``

4
examples/finnegans_wake_demo/download_finnegans_wake.sh
View File

@ -1,5 +1,5 @@
#!/usr/bin/env bash
echo "Downloading Finnegan's Wake Text..."
wget "https://github.com/nucypher/nucypher-kms/files/1765576/finnegans-wake.txt" -O ./finnegans-wake.txt
echo "Successfully downloaded. To run the demo execute 'python finnegans-wake-concise-demo.py'"
wget "https://github.com/nucypher/nucypher/files/1765576/finnegans-wake.txt" -O ./finnegans-wake.txt
echo "Successfully downloaded. To run the demo execute 'python finnegans-wake-demo.py'"

8
examples/finnegans_wake_demo/finnegans-wake-demo.py
View File

@ -9,7 +9,7 @@ from nucypher.characters.lawful import Alice, Bob, Ursula
from nucypher.characters.lawful import Enrico as Enrico
from nucypher.network.middleware import RestMiddleware
from nucypher.utilities.logging import SimpleObserver
from nucypher.utilities.sandbox.constants import TEMPORARY_DOMAIN
######################
# Boring setup stuff #
@ -31,7 +31,7 @@ globalLogPublisher.addObserver(SimpleObserver())
# (will fail with bad connection) #####
#######################################
SEEDNODE_URI = "https://localhost:11501"
SEEDNODE_URI = "localhost:11500"
##############################################
# Ursula, the Untrusted Re-Encryption Proxy #
@ -50,6 +50,7 @@ label = b"secret/files/and/stuff"
######################################
ALICE = Alice(network_middleware=RestMiddleware(),
domains={TEMPORARY_DOMAIN},
known_nodes=[ursula],
learn_on_same_thread=True,
federated_only=True)
@ -58,9 +59,10 @@ ALICE = Alice(network_middleware=RestMiddleware(),
# From this moment on, any Data Source that knows the public key
# can encrypt data originally intended for Alice, but that can be shared with
# any Bob that Alice grants access.
policy_pubkey = ALICE.get_policy_pubkey_from_label(label)
policy_pubkey = ALICE.get_policy_encrypting_key_from_label(label)
BOB = Bob(known_nodes=[ursula],
domains={TEMPORARY_DOMAIN},
network_middleware=RestMiddleware(),
federated_only=True,
start_learning_now=True,

8
examples/heartbeat_demo/alicia.py
View File

@ -8,8 +8,6 @@ from twisted.logger import globalLogPublisher
from nucypher.characters.lawful import Bob, Ursula
from nucypher.config.characters import AliceConfiguration
from nucypher.crypto.powers import DecryptingPower, SigningPower
from nucypher.network.middleware import RestMiddleware
from nucypher.utilities.logging import SimpleObserver
@ -19,11 +17,12 @@ from nucypher.utilities.logging import SimpleObserver
# Twisted Logger
from nucypher.utilities.sandbox.constants import TEMPORARY_DOMAIN
globalLogPublisher.addObserver(SimpleObserver())
TEMP_ALICE_DIR = os.path.join('/', 'tmp', 'heartbeat-demo-alice')
# We expect the url of the seednode as the first argument.
SEEDNODE_URL = 'localhost:11500'
POLICY_FILENAME = "policy-metadata.json"
@ -50,6 +49,7 @@ ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL,
alice_config = AliceConfiguration(
config_root=os.path.join(TEMP_ALICE_DIR),
is_me=True,
domains={TEMPORARY_DOMAIN},
known_nodes={ursula},
start_learning_now=False,
federated_only=True,
@ -75,7 +75,7 @@ label = label.encode()
# Alicia can create the public key associated to the policy label,
# even before creating any associated policy.
policy_pubkey = alicia.get_policy_pubkey_from_label(label)
policy_pubkey = alicia.get_policy_encrypting_key_from_label(label)
print("The policy public key for "
"label '{}' is {}".format(label.decode("utf-8"), policy_pubkey.to_bytes().hex()))

2
examples/heartbeat_demo/doctor.py
View File

@ -17,6 +17,7 @@ from nucypher.network.middleware import RestMiddleware
from umbral.keys import UmbralPublicKey
from nucypher.utilities.logging import SimpleObserver
from nucypher.utilities.sandbox.constants import TEMPORARY_DOMAIN
globalLogPublisher.addObserver(SimpleObserver())
@ -51,6 +52,7 @@ print("Creating the Doctor ...")
doctor = Bob(
is_me=True,
domains={TEMPORARY_DOMAIN},
federated_only=True,
crypto_power_ups=power_ups,
start_learning_now=True,

175
nucypher/blockchain/eth/actors.py
View File

@ -16,7 +16,9 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import json
import os
from datetime import datetime
from decimal import Decimal
from json import JSONDecodeError
from typing import Tuple, List, Dict, Union
@ -49,12 +51,13 @@ from nucypher.blockchain.eth.deployers import (
PolicyManagerDeployer,
UserEscrowProxyDeployer,
UserEscrowDeployer,
MiningAdjudicatorDeployer
)
MiningAdjudicatorDeployer,
ContractDeployer)
from nucypher.blockchain.eth.interfaces import BlockchainDeployerInterface
from nucypher.blockchain.eth.registry import AllocationRegistry
from nucypher.blockchain.eth.token import NU, Stake
from nucypher.blockchain.eth.utils import datetime_to_period, calculate_period_duration
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
def only_me(func):
@ -87,10 +90,10 @@ class NucypherTokenActor:
self.checksum_public_address = checksum_address # type: str
if blockchain is None:
blockchain = Blockchain.connect()
blockchain = Blockchain.connect() # Attempt to connect
self.blockchain = blockchain
self.token_agent = NucypherTokenAgent()
self.token_agent = NucypherTokenAgent(blockchain=self.blockchain)
self._transaction_cache = list() # type: list # track transactions transmitted
def __repr__(self):
@ -100,10 +103,10 @@ class NucypherTokenActor:
return r
@property
def eth_balance(self) -> int:
def eth_balance(self) -> Decimal:
"""Return this actors's current ETH balance"""
balance = self.token_agent.blockchain.interface.w3.eth.getBalance(self.checksum_public_address)
return self.blockchain.interface.w3.fromWei(balance, 'ether')
balance = self.blockchain.interface.get_balance(self.checksum_public_address)
return self.blockchain.interface.fromWei(balance, 'ether')
@property
def token_balance(self) -> NU:
@ -128,6 +131,9 @@ class Deployer(NucypherTokenActor):
__interface_class = BlockchainDeployerInterface
class UnknownContract(ValueError):
pass
def __init__(self,
blockchain: Blockchain,
deployer_address: str = None,
@ -136,8 +142,8 @@ class Deployer(NucypherTokenActor):
self.blockchain = blockchain
self.__deployer_address = NO_DEPLOYER_ADDRESS
if deployer_address:
self.deployer_address = deployer_address
self.deployer_address = deployer_address
self.checksum_public_address = self.deployer_address
if not bare:
self.token_agent = NucypherTokenAgent(blockchain=blockchain)
@ -146,14 +152,7 @@ class Deployer(NucypherTokenActor):
self.adjudicator_agent = MiningAdjudicatorAgent(blockchain=blockchain)
self.user_escrow_deployers = dict()
self.deployers = {
NucypherTokenDeployer.contract_name: self.deploy_token_contract,
MinerEscrowDeployer.contract_name: self.deploy_miner_contract,
PolicyManagerDeployer.contract_name: self.deploy_policy_contract,
UserEscrowProxyDeployer.contract_name: self.deploy_escrow_proxy,
MiningAdjudicatorDeployer.contract_name: self.deploy_mining_adjudicator_contract,
}
self.deployers = {d.contract_name: d for d in self.deployers}
self.log = Logger("Deployment-Actor")
@ -185,89 +184,88 @@ class Deployer(NucypherTokenActor):
raise self.ActorError(message)
return super().token_balance
def deploy_token_contract(self) -> dict:
token_deployer = NucypherTokenDeployer(blockchain=self.blockchain, deployer_address=self.deployer_address)
txhashes = token_deployer.deploy()
self.token_agent = token_deployer.make_agent()
def __get_deployer(self, contract_name: str):
try:
Deployer = self.deployers[contract_name]
except KeyError:
raise self.UnknownContract(contract_name)
return Deployer
def deploy_contract(self,
contract_name: str,
gas_limit: int = None,
plaintext_secret: str = None,
) -> Tuple[dict, ContractDeployer]:
Deployer = self.__get_deployer(contract_name=contract_name)
deployer = Deployer(blockchain=self.blockchain, deployer_address=self.deployer_address)
if Deployer._upgradeable:
if not plaintext_secret:
raise ValueError("Upgrade plaintext_secret must be passed to deploy an upgradeable contract.")
secret_hash = self.blockchain.interface.keccak(bytes(plaintext_secret, encoding='utf-8'))
txhashes = deployer.deploy(secret_hash=secret_hash, gas_limit=gas_limit)
else:
txhashes = deployer.deploy(gas_limit=gas_limit)
return txhashes, deployer
def upgrade_contract(self, contract_name: str, existing_plaintext_secret: str, new_plaintext_secret: str) -> dict:
Deployer = self.__get_deployer(contract_name=contract_name)
deployer = Deployer(blockchain=self.blockchain, deployer_address=self.deployer_address)
new_secret_hash = self.blockchain.interface.keccak(bytes(new_plaintext_secret, encoding='utf-8'))
txhashes = deployer.upgrade(existing_secret_plaintext=bytes(existing_plaintext_secret, encoding='utf-8'),
new_secret_hash=new_secret_hash)
return txhashes
def deploy_miner_contract(self, secret: bytes) -> dict:
secret = self.blockchain.interface.w3.keccak(secret)
miner_escrow_deployer = MinerEscrowDeployer(blockchain=self.blockchain,
deployer_address=self.deployer_address,
secret_hash=secret)
def rollback_contract(self, contract_name: str, existing_plaintext_secret: str, new_plaintext_secret: str):
Deployer = self.__get_deployer(contract_name=contract_name)
deployer = Deployer(blockchain=self.blockchain, deployer_address=self.deployer_address)
new_secret_hash = self.blockchain.interface.keccak(bytes(new_plaintext_secret, encoding='utf-8'))
txhash = deployer.rollback(existing_secret_plaintext=bytes(existing_plaintext_secret, encoding='utf-8'),
new_secret_hash=new_secret_hash)
return txhash
txhashes = miner_escrow_deployer.deploy()
self.miner_agent = miner_escrow_deployer.make_agent()
return txhashes
def deploy_policy_contract(self, secret: bytes) -> dict:
secret = self.blockchain.interface.w3.keccak(secret)
policy_manager_deployer = PolicyManagerDeployer(blockchain=self.blockchain,
deployer_address=self.deployer_address,
secret_hash=secret)
txhashes = policy_manager_deployer.deploy()
self.policy_agent = policy_manager_deployer.make_agent()
return txhashes
def deploy_mining_adjudicator_contract(self, secret: bytes) -> dict:
secret = self.blockchain.interface.w3.keccak(secret)
mining_adjudicator_deployer = MiningAdjudicatorDeployer(blockchain=self.blockchain,
deployer_address=self.deployer_address,
secret_hash=secret)
txhashes = mining_adjudicator_deployer.deploy()
self.adjudicator_agent = mining_adjudicator_deployer.make_agent()
return txhashes
def deploy_escrow_proxy(self, secret: bytes) -> dict:
secret = self.blockchain.interface.w3.keccak(secret)
escrow_proxy_deployer = UserEscrowProxyDeployer(blockchain=self.blockchain,
deployer_address=self.deployer_address,
secret_hash=secret)
txhashes = escrow_proxy_deployer.deploy()
return txhashes
def deploy_user_escrow(self, allocation_registry: AllocationRegistry) -> UserEscrowDeployer:
def deploy_user_escrow(self, allocation_registry: AllocationRegistry):
user_escrow_deployer = UserEscrowDeployer(blockchain=self.blockchain,
deployer_address=self.deployer_address,
allocation_registry=allocation_registry)
user_escrow_deployer.deploy()
principal_address = user_escrow_deployer.contract.address
self.user_escrow_deployers[principal_address] = user_escrow_deployer
return user_escrow_deployer
def deploy_network_contracts(self,
miner_secret: bytes,
policy_secret: bytes,
adjudicator_secret: bytes
miner_secret: str,
policy_secret: str,
adjudicator_secret: str,
user_escrow_proxy_secret: str,
) -> Tuple[dict, dict]:
"""
Musketeers, if you will; Deploy the "big three" contracts to the blockchain.
"""
token_txhashes = self.deploy_token_contract()
miner_txhashes = self.deploy_miner_contract(secret=miner_secret)
policy_txhashes = self.deploy_policy_contract(secret=policy_secret)
adjudicator_txhashes = self.deploy_mining_adjudicator_contract(secret=adjudicator_secret)
token_txs, token_deployer = self.deploy_contract(contract_name='NuCypherToken')
miner_txs, miner_deployer = self.deploy_contract(contract_name='MinersEscrow', plaintext_secret=miner_secret)
policy_txs, policy_deployer = self.deploy_contract(contract_name='PolicyManager', plaintext_secret=policy_secret)
adjudicator_txs, adjudicator_deployer = self.deploy_contract(contract_name='MiningAdjudicator', plaintext_secret=adjudicator_secret)
user_escrow_proxy_txs, user_escrow_proxy_deployer = self.deploy_contract(contract_name='UserEscrowProxy', plaintext_secret=user_escrow_proxy_secret)
deployers = (token_deployer,
miner_deployer,
policy_deployer,
adjudicator_deployer,
user_escrow_proxy_deployer,
)
txhashes = {
NucypherTokenDeployer.contract_name: token_txhashes,
MinerEscrowDeployer.contract_name: miner_txhashes,
PolicyManagerDeployer.contract_name: policy_txhashes,
MiningAdjudicatorDeployer.contract_name: adjudicator_txhashes
NucypherTokenDeployer.contract_name: token_txs,
MinerEscrowDeployer.contract_name: miner_txs,
PolicyManagerDeployer.contract_name: policy_txs,
MiningAdjudicatorDeployer.contract_name: adjudicator_txs,
UserEscrowProxyDeployer.contract_name: user_escrow_proxy_txs,
}
agents = {
NucypherTokenDeployer.contract_name: self.token_agent,
MinerEscrowDeployer.contract_name: self.miner_agent,
PolicyManagerDeployer.contract_name: self.policy_agent,
MiningAdjudicatorDeployer.contract_name: self.adjudicator_agent
}
return txhashes, agents
deployers = {deployer.contract_name: deployer for deployer in deployers}
return txhashes, deployers
def deploy_beneficiary_contracts(self,
allocations: List[Dict[str, Union[str, int]]],
@ -330,6 +328,23 @@ class Deployer(NucypherTokenActor):
txhashes = self.deploy_beneficiary_contracts(allocations=allocations, allocation_outfile=allocation_outfile)
return txhashes
def save_deployment_receipts(self, transactions: dict) -> str:
filename = f'deployment-receipts-{self.deployer_address[:6]}-{maya.now().epoch}.json'
filepath = os.path.join(DEFAULT_CONFIG_ROOT, filename)
# TODO: Do not assume default config root
os.makedirs(DEFAULT_CONFIG_ROOT, exist_ok=True)
with open(filepath, 'w') as file:
data = dict()
for contract_name, transactions in transactions.items():
contract_records = dict()
for tx_name, txhash in transactions.items():
receipt = {item: str(result) for item, result in self.blockchain.wait_for_receipt(txhash).items()}
contract_records.update({tx_name: receipt for tx_name in transactions})
data[contract_name] = contract_records
data = json.dumps(data, indent=4)
file.write(data)
return filepath
class Miner(NucypherTokenActor):
"""

6
nucypher/blockchain/eth/agents.py
View File

@ -14,6 +14,8 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import random
from abc import ABC
@ -102,7 +104,7 @@ class NucypherTokenAgent(EthereumContractAgent):
def approve_transfer(self, amount: int, target_address: str, sender_address: str) -> str:
"""Approve the transfer of token from the sender address to the target address."""
txhash = self.contract.functions.approve(target_address, amount).transact({'from': sender_address}) # TODO #413: gas needed for use with geth.
txhash = self.contract.functions.approve(target_address, amount).transact({'from': sender_address, 'gas': 500_000}) # TODO #413: gas needed for use with geth.
self.blockchain.wait_for_receipt(txhash)
return txhash
@ -244,7 +246,7 @@ class MinerAgent(EthereumContractAgent):
miners_population = self.get_miner_population()
if quantity > miners_population:
raise self.NotEnoughMiners('{} miners are available'.format(miners_population))
raise self.NotEnoughMiners('{} miners are available, need {} (for wiggle room)'.format(miners_population, quantity))
system_random = random.SystemRandom()
n_select = round(quantity*additional_ursulas) # Select more Ursulas

93
nucypher/blockchain/eth/chains.py
View File

@ -14,8 +14,11 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import time
import geth
import maya
from geth.chain import write_genesis_file, initialize_chain
from twisted.logger import Logger
from web3.middleware import geth_poa_middleware
@ -36,12 +39,16 @@ class Blockchain:
_instance = NO_BLOCKCHAIN_AVAILABLE
__default_interface_class = BlockchainInterface
class ConnectionNotEstablished(RuntimeError):
pass
def __init__(
self,
provider_process=None,
interface: Union[BlockchainInterface, BlockchainDeployerInterface] = None,
dev: bool = False):
def __init__(self, interface: Union[BlockchainInterface, BlockchainDeployerInterface] = None) -> None:
self.log = Logger("blockchain")
self.dev = dev
self.log = Logger("blockchain") # type: Logger
self.__provider_process = provider_process
# Default interface
if interface is None:
@ -56,36 +63,88 @@ class Blockchain:
def __repr__(self):
class_name = self.__class__.__name__
r = "{}(interface={})"
return r.format(class_name, self.__interface)
r = "{}(interface={}, process={})"
return r.format(class_name, self.__interface, self.__provider_process)
@property
def interface(self) -> Union[BlockchainInterface, BlockchainDeployerInterface]:
return self.__interface
@property
def peers(self):
if self._instance is NO_BLOCKCHAIN_AVAILABLE:
raise self.ConnectionNotEstablished
return self.interface.peers()
@property
def chain_id(self):
return self.interface.chain_id
def chain_name(self):
return self.interface.chain_name
@property
def syncing(self):
if self._instance is NO_BLOCKCHAIN_AVAILABLE:
raise self.ConnectionNotEstablished
return self.interface.client.syncing
def sync(self, timeout: int = 600):
"""
Blocking call that polls the ethereum client for at least one ethereum peer
and knowledge of all blocks known by bootnodes.
"""
return self.interface.client.sync(timeout=timeout)
@classmethod
def connect(cls,
provider_process=None,
provider_uri: str = None,
registry: EthereumContractRegistry = None,
deployer: bool = False,
compile: bool = False,
poa: bool = False
poa: bool = False,
force: bool = True,
fetch_registry: bool = True,
sync: bool = True,
dev: bool = False,
) -> 'Blockchain':
log = Logger('blockchain-init')
if cls._instance is NO_BLOCKCHAIN_AVAILABLE:
registry = registry or EthereumContractRegistry()
# Spawn child process
if provider_process:
provider_process.start()
provider_uri = provider_process.provider_uri(scheme='file')
else:
log.info(f"Using external Web3 Provider '{provider_uri}'")
compiler = SolidityCompiler() if compile is True else None
InterfaceClass = BlockchainDeployerInterface if deployer is True else BlockchainInterface
interface = InterfaceClass(provider_uri=provider_uri, registry=registry, compiler=compiler)
interface = InterfaceClass(
provider_uri=provider_uri,
compiler=compiler,
registry=registry,
fetch_registry=fetch_registry,
)
if poa is True:
interface.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
log.debug('Injecting POA middleware at layer 0')
interface.middleware_onion.inject(geth_poa_middleware, layer=0)
cls._instance = cls(interface=interface, provider_process=provider_process, dev=dev)
# Sync blockchain
if sync:
cls._instance.sync()
cls._instance = cls(interface=interface)
else:
if provider_uri is not None:
existing_uri = cls._instance.interface.provider_uri
if existing_uri != provider_uri:
if (existing_uri != provider_uri) and not force:
raise ValueError("There is an existing blockchain connection to {}. "
"Use Interface.add_provider to connect additional providers".format(existing_uri))
@ -96,6 +155,12 @@ class Blockchain:
return cls._instance
@classmethod
def disconnect(cls):
if cls._instance is not NO_BLOCKCHAIN_AVAILABLE:
if cls._instance.__provider_process:
cls._instance.__provider_process.stop()
def get_contract(self, name: str) -> Contract:
"""
Gets an existing contract from the registry, or raises UnknownContract
@ -103,7 +168,7 @@ class Blockchain:
"""
return self.__interface.get_contract_by_name(name)
def wait_for_receipt(self, txhash: str, timeout: int = None) -> dict:
def wait_for_receipt(self, txhash: bytes, timeout: int = None) -> dict:
"""Wait for a transaction receipt and return it"""
timeout = timeout if timeout is not None else self.interface.timeout
result = self.__interface.w3.eth.waitForTransactionReceipt(txhash, timeout=timeout)

455
nucypher/blockchain/eth/clients.py Normal file
View File

@ -0,0 +1,455 @@
import json
import os
import shutil
import time
from typing import Union
import maya
from constant_sorrow.constants import NOT_RUNNING, UNKNOWN_DEVELOPMENT_CHAIN_ID
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_utils import to_canonical_address
from eth_utils import to_checksum_address, is_checksum_address
from geth import LoggingMixin
from geth.accounts import get_accounts, create_new_account
from geth.chain import (
get_chain_data_dir,
initialize_chain,
is_live_chain,
is_ropsten_chain
)
from geth.process import BaseGethProcess
from twisted.logger import Logger
from web3 import Web3
from web3.exceptions import BlockNotFound
from nucypher.config.constants import DEFAULT_CONFIG_ROOT, DEPLOY_DIR, USER_LOG_DIR
class Web3ClientError(Exception):
pass
class Web3ClientConnectionFailed(Web3ClientError):
pass
class Web3ClientUnexpectedVersionString(Web3ClientError):
pass
PUBLIC_CHAINS = {0: "Olympic",
1: "Mainnet",
2: "Morden",
3: "Ropsten",
4: "Rinkeby",
5: "Goerli",
6: "Kotti",
8: "Ubiq",
42: "Kovan",
60: "GoChain",
77: "Sokol",
99: "Core",
100: "xDai",
31337: "GoChain",
401697: "Tobalaba",
7762959: "Musicoin",
61717561: "Aquachain"}
LOCAL_CHAINS = {1337: "GethDev",
5777: "Ganache/TestRPC"}
class Web3Client(object):
is_local = False
GETH = 'Geth'
PARITY = 'Parity'
ALT_PARITY = 'Parity-Ethereum'
GANACHE = 'EthereumJS TestRPC'
ETHEREUM_TESTER = 'EthereumTester' # (PyEVM)
def __init__(self,
w3,
node_technology: str,
version: str,
platform: str,
backend: str):
self.w3 = w3
self.node_technology = node_technology
self.node_version = version
self.platform = platform
self.backend = backend
self.log = Logger(self.__class__.__name__)
@classmethod
def from_w3(cls, w3: Web3) -> 'Web3Client':
"""
Client version strings
======================
Geth -> 'Geth/v1.4.11-stable-fed692f6/darwin/go1.7'
Parity -> 'Parity-Ethereum/v2.5.1-beta-e0141f8-20190510/x86_64-linux-gnu/rustc1.34.1'
Ganache -> 'EthereumJS TestRPC/v2.1.5/ethereum-js'
PyEVM -> 'EthereumTester/0.1.0b39/linux/python3.6.7'
"""
clients = {
# Geth
cls.GETH: GethClient,
# Parity
cls.PARITY: ParityClient,
cls.ALT_PARITY: ParityClient,
# Test Clients
cls.GANACHE: GanacheClient,
cls.ETHEREUM_TESTER: EthereumTesterClient,
}
try:
client_data = w3.clientVersion.split('/')
node_technology = client_data[0]
ClientSubclass = clients[node_technology]
except (ValueError, IndexError):
raise ValueError(f"Invalid client version string. Got '{w3.clientVersion}'")
except KeyError:
raise NotImplementedError(f'{w3.clientVersion} is not a supported ethereum client')
client_kwargs = {
'node_technology': node_technology,
'version': client_data[1],
'backend': client_data[-1],
'platform': client_data[2] if len(client_data) == 4 else None # Plaftorm is optional
}
instance = ClientSubclass(w3, **client_kwargs)
return instance
class ConnectionNotEstablished(RuntimeError):
pass
class SyncTimeout(RuntimeError):
pass
@property
def peers(self):
raise NotImplementedError
@property
def chain_name(self) -> str:
if not self.is_local:
return PUBLIC_CHAINS[self.w3.net.version]
name = LOCAL_CHAINS.get(self.w3.net.version, UNKNOWN_DEVELOPMENT_CHAIN_ID)
return name
@property
def syncing(self) -> Union[bool, dict]:
return self.w3.eth.syncing
def unlock_account(self, address, password) -> bool:
if not self.is_local:
return self.unlock_account(address, password)
def is_connected(self):
return self.w3.isConnected()
@property
def accounts(self):
return self.w3.eth.accounts
def get_balance(self, address):
return self.w3.eth.getBalance(address)
@property
def chain_id(self):
return self.w3.net.version
def sync(self, timeout: int = 600):
if self.is_local:
return
# Record start time for timeout calculation
now = maya.now()
start_time = now
def check_for_timeout(t):
last_update = maya.now()
duration = (last_update - start_time).seconds
if duration > t:
raise self.SyncTimeout
# Check for ethereum peers
self.log.info(f"Waiting for ethereum peers...")
while not self.peers:
time.sleep(0)
check_for_timeout(t=30)
needs_sync = False
for peer in self.peers:
peer_block_header = peer['protocols']['eth']['head']
try:
self.w3.eth.getBlock(peer_block_header)
except BlockNotFound:
needs_sync = True
break
# Start
if needs_sync:
peers = len(self.peers)
self.log.info(f"Waiting for sync to begin ({peers} ethereum peers)")
while not self.syncing:
time.sleep(0)
check_for_timeout(t=timeout)
# Continue until done
while self.syncing:
current = self.syncing['currentBlock']
total = self.syncing['highestBlock']
self.log.info(f"Syncing {current}/{total}")
time.sleep(1)
check_for_timeout(t=timeout)
return True
def sign_message(self, account: str, message: bytes) -> str:
"""
Calls the appropriate signing function for the specified account on the
backend. If the backend is based on eth-tester, then it uses the
eth-tester signing interface to do so.
"""
return self.w3.eth.sign(account, data=message)
class GethClient(Web3Client):
@property
def is_local(self):
return int(self.w3.net.version) not in PUBLIC_CHAINS
@property
def peers(self):
return self.w3.geth.admin.peers()
def unlock_account(self, address, password):
return self.w3.geth.personal.unlockAccount(address, password)
class ParityClient(Web3Client):
@property
def peers(self) -> list:
"""
TODO: Look for web3.py support for Parity Peers endpoint
"""
return self.w3.manager.request_blocking("parity_netPeers", [])
def unlock_account(self, address, password):
return self.w3.parity.unlockAccount.unlockAccount(address, password)
class GanacheClient(Web3Client):
is_local = True
def unlock_account(self, address, password):
return True
def sync(self, *args, **kwargs):
return True
class EthereumTesterClient(Web3Client):
is_local = True
def unlock_account(self, address, password):
return True
def sync(self, *args, **kwargs):
return True
def sign_message(self, account: str, message: bytes) -> str:
# Get signing key of test account
address = to_canonical_address(account)
signing_key = self.w3.provider.ethereum_tester.backend._key_lookup[address]
# Sign, EIP-191 (Geth) Style
signable_message = encode_defunct(primitive=message)
signature_and_stuff = Account.sign_message(signable_message=signable_message, private_key=signing_key)
return signature_and_stuff['signature']
class NuCypherGethProcess(LoggingMixin, BaseGethProcess):
IPC_PROTOCOL = 'http'
IPC_FILENAME = 'geth.ipc'
VERBOSITY = 5
CHAIN_ID = NotImplemented # 1
_CHAIN_NAME = 'mainnet'
LOG_PATH = os.path.join(USER_LOG_DIR, 'nucypher-geth.log')
def __init__(self,
geth_kwargs: dict,
stdout_logfile_path: str = LOG_PATH,
stderr_logfile_path: str = LOG_PATH,
*args, **kwargs):
super().__init__(geth_kwargs=geth_kwargs,
stdout_logfile_path=stdout_logfile_path,
stderr_logfile_path=stderr_logfile_path,
*args, **kwargs)
self.log = Logger('nucypher-geth')
def provider_uri(self, scheme: str = None) -> str:
if not scheme:
scheme = self.IPC_PROTOCOL
if scheme == 'file':
location = self.ipc_path
elif scheme in ('http', 'ws'):
location = f'{self.rpc_host}:{self.rpc_port}'
else:
raise ValueError(f'{scheme} is an unknown ethereum node IPC protocol.')
uri = f"{scheme}://{location}"
return uri
def start(self, timeout: int = 30, extra_delay: int = 1):
self.log.info("STARTING GETH NOW")
super().start()
self.wait_for_ipc(timeout=timeout) # on for all nodes by default
if self.IPC_PROTOCOL in ('rpc', 'http'):
self.wait_for_rpc(timeout=timeout)
time.sleep(extra_delay)
class NuCypherGethDevProcess(NuCypherGethProcess):
_CHAIN_NAME = 'poa-development'
def __init__(self, config_root: str = None, *args, **kwargs):
base_dir = config_root if config_root else DEFAULT_CONFIG_ROOT
base_dir = os.path.join(base_dir, '.ethereum')
self.data_dir = get_chain_data_dir(base_dir=base_dir, name=self._CHAIN_NAME)
ipc_path = os.path.join(self.data_dir, 'geth.ipc')
self.geth_kwargs = {'ipc_path': ipc_path}
super().__init__(geth_kwargs=self.geth_kwargs, *args, **kwargs)
self.geth_kwargs.update({'dev': True})
self.command = [*self.command, '--dev']
def start(self, timeout: int = 30, extra_delay: int = 1):
self.log.info("STARTING GETH DEV NOW")
BaseGethProcess.start(self) # <--- START GETH
time.sleep(extra_delay) # give it a second
self.wait_for_ipc(timeout=timeout)
class NuCypherGethDevnetProcess(NuCypherGethProcess):
IPC_PROTOCOL = 'file'
GENESIS_FILENAME = 'testnet_genesis.json'
GENESIS_SOURCE_FILEPATH = os.path.join(DEPLOY_DIR, GENESIS_FILENAME)
P2P_PORT = 30303
_CHAIN_NAME = 'devnet'
__CHAIN_ID = 112358
def __init__(self,
config_root: str = None,
overrides: dict = None,
*args, **kwargs):
log = Logger('nucypher-geth-devnet')
if overrides is None:
overrides = dict()
# Validate
invalid_override = f"You cannot specify `network_id` for a {self.__class__.__name__}"
if 'data_dir' in overrides:
raise ValueError(invalid_override)
if 'network_id' in overrides:
raise ValueError(invalid_override)
# Set the data dir
if config_root is None:
base_dir = os.path.join(DEFAULT_CONFIG_ROOT, '.ethereum')
else:
base_dir = os.path.join(config_root, '.ethereum')
self.data_dir = get_chain_data_dir(base_dir=base_dir, name=self._CHAIN_NAME)
# Hardcoded Geth CLI args for devnet child process ("light client")
ipc_path = os.path.join(self.data_dir, self.IPC_FILENAME)
geth_kwargs = {'network_id': str(self.__CHAIN_ID),
'port': str(self.P2P_PORT),
'verbosity': str(self.VERBOSITY),
'data_dir': self.data_dir,
'ipc_path': ipc_path,
'rpc_enabled': True,
'no_discover': True,
}
# Genesis & Blockchain Init
self.genesis_filepath = os.path.join(self.data_dir, self.GENESIS_FILENAME)
needs_init = all((
not os.path.exists(self.genesis_filepath),
not is_live_chain(self.data_dir),
not is_ropsten_chain(self.data_dir),
))
if needs_init:
log.debug("Local system needs geth blockchain initialization")
self.initialized = False
else:
self.initialized = True
self.__process = NOT_RUNNING
super().__init__(geth_kwargs=geth_kwargs, *args, **kwargs) # Attaches self.geth_kwargs in super call
self.command = [*self.command, '--syncmode', 'fast']
def get_accounts(self):
accounts = get_accounts(**self.geth_kwargs)
return accounts
def initialize_blockchain(self, overwrite: bool = True) -> None:
log = Logger('nucypher-geth-init')
with open(self.GENESIS_SOURCE_FILEPATH, 'r') as file:
genesis_data = json.loads(file.read())
log.info(f"Read genesis file '{self.GENESIS_SOURCE_FILEPATH}'")
genesis_data.update(dict(overwrite=overwrite))
log.info(f'Initializing new blockchain database and genesis block.')
initialize_chain(genesis_data=genesis_data, **self.geth_kwargs)
# Write static nodes file to data dir
bootnodes_filepath = os.path.join(DEPLOY_DIR, 'static-nodes.json')
shutil.copy(bootnodes_filepath, os.path.join(self.data_dir))
def ensure_account_exists(self, password: str) -> str:
accounts = get_accounts(**self.geth_kwargs)
if not accounts:
account = create_new_account(password=password.encode(), **self.geth_kwargs)
else:
account = accounts[0]
checksum_address = to_checksum_address(account.decode())
assert is_checksum_address(checksum_address), f"GETH RETURNED INVALID ETH ADDRESS {checksum_address}"
return checksum_address
def start(self, *args, **kwargs):
# FIXME: Quick and Dirty
# Write static nodes file to data dir
bootnodes_filepath = os.path.join(DEPLOY_DIR, 'static-nodes.json')
shutil.copy(bootnodes_filepath, os.path.join(self.data_dir))
super().start()

348
nucypher/blockchain/eth/deployers.py
View File

@ -40,7 +40,7 @@ class ContractDeployer:
agency = NotImplemented
contract_name = NotImplemented
_interface_class = BlockchainDeployerInterface
__upgradeable = NotImplemented
_upgradeable = NotImplemented
__proxy_deployer = NotImplemented
class ContractDeploymentError(Exception):
@ -129,7 +129,7 @@ class ContractDeployer:
raise self.ContractDeploymentError(message)
return True
def deploy(self) -> dict:
def deploy(self, secret_hash: bytes, gas_limit: int) -> dict:
"""
Provides for the setup, deployment, and initialization of ethereum smart contracts.
Emits the configured blockchain network transactions for single contract instance publication.
@ -145,7 +145,7 @@ class NucypherTokenDeployer(ContractDeployer):
agency = NucypherTokenAgent
contract_name = agency.registry_contract_name
__upgradeable = False
_upgradeable = False
def __init__(self,
deployer_address: str,
@ -159,7 +159,7 @@ class NucypherTokenDeployer(ContractDeployer):
economics = TokenEconomics()
self.__economics = economics
def deploy(self) -> dict:
def deploy(self, gas_limit: int = None) -> dict:
"""
Deploy and publish the NuCypher Token contract
to the blockchain network specified in self.blockchain.network.
@ -183,21 +183,40 @@ class DispatcherDeployer(ContractDeployer):
"""
contract_name = 'Dispatcher'
__upgradeable = False
_upgradeable = False
DISPATCHER_SECRET_LENGTH = 32
def __init__(self, target_contract: Contract, secret_hash: bytes, *args, **kwargs):
def __init__(self, target_contract: Contract, bare: bool = False, *args, **kwargs):
super().__init__(*args, **kwargs)
self.target_contract = target_contract
self.secret_hash = secret_hash
if bare:
self._contract = self.blockchain.interface.get_proxy(target_address=self.target_contract.address,
proxy_name=self.contract_name)
def deploy(self) -> dict:
args = (self.contract_name, self.target_contract.address, self.secret_hash)
dispatcher_contract, txhash = self.blockchain.interface.deploy_contract(*args)
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> dict:
args = (self.contract_name, self.target_contract.address, secret_hash)
dispatcher_contract, txhash = self.blockchain.interface.deploy_contract(gas_limit=gas_limit, *args)
self._contract = dispatcher_contract
return {'txhash': txhash}
def retarget(self, new_target: str, existing_secret_plaintext: bytes, new_secret_hash: bytes) -> bytes:
if new_target == self.target_contract.address:
raise self.ContractDeploymentError(f"{new_target} is already targeted by {self.contract_name}: {self._contract.address}")
if new_target == self._contract.address:
raise self.ContractDeploymentError(f"{self.contract_name} {self._contract.address} cannot target itself.")
origin_args = {'from': self.deployer_address, 'gasPrice': self.blockchain.interface.w3.eth.gasPrice} # TODO: Gas management
txhash = self._contract.functions.upgrade(new_target, existing_secret_plaintext, new_secret_hash).transact(origin_args)
_receipt = self.blockchain.wait_for_receipt(txhash=txhash)
return txhash
def rollback(self, existing_secret_plaintext: bytes, new_secret_hash: bytes) -> bytes:
origin_args = {'from': self.deployer_address, 'gasPrice': self.blockchain.interface.w3.eth.gasPrice} # TODO: Gas management
txhash = self._contract.functions.rollback(existing_secret_plaintext, new_secret_hash).transact(origin_args)
_receipt = self.blockchain.wait_for_receipt(txhash=txhash)
return txhash
class MinerEscrowDeployer(ContractDeployer):
"""
@ -206,17 +225,13 @@ class MinerEscrowDeployer(ContractDeployer):
agency = MinerAgent
contract_name = agency.registry_contract_name
__upgradeable = True
_upgradeable = True
__proxy_deployer = DispatcherDeployer
def __init__(self,
secret_hash,
economics: TokenEconomics = None,
*args, **kwargs):
def __init__(self, economics: TokenEconomics = None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.token_agent = NucypherTokenAgent(blockchain=self.blockchain)
self.secret_hash = secret_hash
if not economics:
economics = TokenEconomics()
self.__economics = economics
@ -226,7 +241,7 @@ class MinerEscrowDeployer(ContractDeployer):
if result is self.blockchain.NULL_ADDRESS:
raise RuntimeError("PolicyManager contract is not initialized.")
def deploy(self) -> dict:
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> dict:
"""
Deploy and publish the MinersEscrow contract
to the blockchain network specified in self.blockchain.network.
@ -246,7 +261,10 @@ class MinerEscrowDeployer(ContractDeployer):
self.check_deployment_readiness()
# Build deployment arguments
origin_args = {'from': self.deployer_address, 'gasPrice': self.blockchain.interface.w3.eth.gasPrice}
origin_args = {'from': self.deployer_address,
'gasPrice': self.blockchain.interface.w3.eth.gasPrice}
if gas_limit:
origin_args.update({'gas': gas_limit})
# 1 - Deploy #
the_escrow_contract, deploy_txhash, = \
@ -257,10 +275,9 @@ class MinerEscrowDeployer(ContractDeployer):
# 2 - Deploy the dispatcher used for updating this contract #
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=the_escrow_contract,
deployer_address=self.deployer_address,
secret_hash=self.secret_hash)
deployer_address=self.deployer_address)
dispatcher_deploy_txhashes = dispatcher_deployer.deploy()
dispatcher_deploy_txhashes = dispatcher_deployer.deploy(secret_hash=secret_hash, gas_limit=gas_limit)
# Cache the dispatcher contract
dispatcher_contract = dispatcher_deployer.contract
@ -280,6 +297,7 @@ class MinerEscrowDeployer(ContractDeployer):
).transact(origin_args)
_reward_receipt = self.blockchain.wait_for_receipt(reward_txhash)
escrow_balance = self.token_agent.get_balance(address=the_escrow_contract.address)
# 4 - Initialize the Miner Escrow contract
init_txhash = the_escrow_contract.functions.initialize().transact(origin_args)
@ -296,6 +314,55 @@ class MinerEscrowDeployer(ContractDeployer):
self.deployment_transactions = deployment_transactions
return deployment_transactions
def upgrade(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
# Raise if not all-systems-go
self.check_deployment_readiness()
origin_args = {'from': self.deployer_address, 'gas': 5000000} # TODO: Gas management
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
# 2 - Deploy new version #
the_escrow_contract, deploy_txhash = self.blockchain.interface.deploy_contract(self.contract_name,
self.token_agent.contract_address,
*self.__economics.staking_deployment_parameters)
# 5 - Wrap the escrow contract
wrapped_escrow_contract = self.blockchain.interface._wrap_contract(wrapper_contract=dispatcher_deployer.contract,
target_contract=the_escrow_contract)
self._contract = wrapped_escrow_contract
# 4 - Set the new Dispatcher target
upgrade_tx_hash = dispatcher_deployer.retarget(new_target=the_escrow_contract.address,
existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_upgrade_receipt = self.blockchain.wait_for_receipt(upgrade_tx_hash)
# Respond
upgrade_transaction = {'deploy': deploy_txhash, 'retarget': upgrade_tx_hash}
return upgrade_transaction
def rollback(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
rollback_txhash = dispatcher_deployer.rollback(existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_rollback_receipt = self.blockchain.wait_for_receipt(txhash=rollback_txhash)
return rollback_txhash
def make_agent(self) -> EthereumContractAgent:
self.__check_policy_manager() # Ensure the PolicyManager contract has already been initialized
agent = self.agency(blockchain=self.blockchain, contract=self._contract)
@ -309,47 +376,45 @@ class PolicyManagerDeployer(ContractDeployer):
agency = PolicyAgent
contract_name = agency.registry_contract_name
__upgradeable = True
_upgradeable = True
__proxy_deployer = DispatcherDeployer
def make_agent(self) -> EthereumContractAgent:
agent = self.agency(blockchain=self.blockchain, contract=self._contract)
return agent
def __init__(self, secret_hash, *args, **kwargs):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.token_agent = NucypherTokenAgent(blockchain=self.blockchain)
self.miner_agent = MinerAgent(blockchain=self.blockchain)
self.secret_hash = secret_hash
def deploy(self) -> Dict[str, str]:
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> Dict[str, str]:
self.check_deployment_readiness()
# Creator deploys the policy manager
policy_manager_contract, deploy_txhash = self.blockchain.interface.deploy_contract(
self.contract_name, self.miner_agent.contract_address)
policy_manager_contract, deploy_txhash = self.blockchain.interface.deploy_contract(self.contract_name, self.miner_agent.contract_address)
proxy_deployer = self.__proxy_deployer(blockchain=self.blockchain,
target_contract=policy_manager_contract,
deployer_address=self.deployer_address,
secret_hash=self.secret_hash)
deployer_address=self.deployer_address)
proxy_deploy_txhashes = proxy_deployer.deploy()
proxy_deploy_txhashes = proxy_deployer.deploy(secret_hash=secret_hash, gas_limit=gas_limit)
# Cache the dispatcher contract
proxy_contract = proxy_deployer.contract
self.__proxy_contract = proxy_contract
# Wrap the escrow contract
wrapped_policy_manager_contract = self.blockchain.interface._wrap_contract(proxy_contract, target_contract=policy_manager_contract)
wrapped = self.blockchain.interface._wrap_contract(proxy_contract, target_contract=policy_manager_contract)
# Switch the contract for the wrapped one
policy_manager_contract = wrapped_policy_manager_contract
policy_manager_contract = wrapped
# Configure the MinerEscrow by setting the PolicyManager
policy_setter_txhash = self.miner_agent.contract.functions.setPolicyManager(policy_manager_contract.address) \
.transact({'from': self.deployer_address})
tx_args = {'from': self.deployer_address}
if gas_limit:
tx_args.update({'gas': gas_limit})
policy_setter_txhash = self.miner_agent.contract.functions.setPolicyManager(policy_manager_contract.address).transact(tx_args)
self.blockchain.wait_for_receipt(policy_setter_txhash)
# Gather the transaction hashes
@ -362,39 +427,102 @@ class PolicyManagerDeployer(ContractDeployer):
return deployment_transactions
def upgrade(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
self.check_deployment_readiness()
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
proxy_deployer = self.__proxy_deployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
# Creator deploys the policy manager
policy_manager_contract, deploy_txhash = self.blockchain.interface.deploy_contract(self.contract_name,
self.miner_agent.contract_address)
upgrade_tx_hash = proxy_deployer.retarget(new_target=policy_manager_contract.address,
existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_upgrade_receipt = self.blockchain.wait_for_receipt(upgrade_tx_hash)
# Wrap the escrow contract
wrapped_policy_manager_contract = self.blockchain.interface._wrap_contract(proxy_deployer.contract,
target_contract=policy_manager_contract)
# Switch the contract for the wrapped one
policy_manager_contract = wrapped_policy_manager_contract
self._contract = policy_manager_contract
upgrade_transaction = {'deploy': deploy_txhash,
'retarget': upgrade_tx_hash}
return upgrade_transaction
def rollback(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
rollback_txhash = dispatcher_deployer.rollback(existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_rollback_receipt = self.blockchain.wait_for_receipt(txhash=rollback_txhash)
return rollback_txhash
class LibraryLinkerDeployer(ContractDeployer):
contract_name = 'UserEscrowLibraryLinker'
def __init__(self, target_contract: Contract, secret_hash: bytes, *args, **kwargs):
def __init__(self, target_contract: Contract, bare: bool = False, *args, **kwargs):
self.target_contract = target_contract
self.secret_hash = secret_hash
super().__init__(*args, **kwargs)
if bare:
self._contract = self.blockchain.interface.get_proxy(target_address=self.target_contract.address,
proxy_name=self.contract_name)
def deploy(self) -> dict:
linker_args = (self.contract_name, self.target_contract.address, self.secret_hash)
linker_contract, linker_deployment_txhash = self.blockchain.interface.deploy_contract(*linker_args)
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> dict:
linker_args = (self.contract_name, self.target_contract.address, secret_hash)
linker_contract, linker_deployment_txhash = self.blockchain.interface.deploy_contract(gas_limit=gas_limit, *linker_args)
self._contract = linker_contract
return {'txhash': linker_deployment_txhash}
def retarget(self, new_target: str, existing_secret_plaintext: bytes, new_secret_hash: bytes):
if new_target == self.target_contract.address:
raise self.ContractDeploymentError(f"{new_target} is already targeted by {self.contract_name}: {self._contract.address}")
if new_target == self._contract.address:
raise self.ContractDeploymentError(f"{self.contract_name} {self._contract.address} cannot target itself.")
origin_args = {'from': self.deployer_address} # TODO: Gas management
txhash = self._contract.functions.upgrade(new_target, existing_secret_plaintext, new_secret_hash).transact(origin_args)
_receipt = self.blockchain.wait_for_receipt(txhash=txhash)
return txhash
class UserEscrowProxyDeployer(ContractDeployer):
contract_name = 'UserEscrowProxy'
__proxy_deployer = LibraryLinkerDeployer
def __init__(self, secret_hash: bytes, *args, **kwargs):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.token_agent = NucypherTokenAgent(blockchain=self.blockchain)
self.miner_agent = MinerAgent(blockchain=self.blockchain)
self.policy_agent = PolicyAgent(blockchain=self.blockchain)
self.secret_hash = secret_hash
def __get_state_contract(self) -> str:
return self.contract.functions.getStateContract()
def deploy(self) -> dict:
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> dict:
deployment_transactions = dict()
@ -403,18 +531,17 @@ class UserEscrowProxyDeployer(ContractDeployer):
self.token_agent.contract_address,
self.miner_agent.contract_address,
self.policy_agent.contract_address)
user_escrow_proxy_contract, proxy_deployment_txhash = self.blockchain.interface.deploy_contract(*proxy_args)
user_escrow_proxy_contract, proxy_deployment_txhash = self.blockchain.interface.deploy_contract(gas_limit=gas_limit, *proxy_args)
self._contract = user_escrow_proxy_contract
deployment_transactions['deployment_txhash'] = proxy_deployment_txhash
# Proxy-Proxy
proxy_deployer = self.__proxy_deployer(deployer_address=self.deployer_address,
target_contract=user_escrow_proxy_contract,
secret_hash=self.secret_hash)
target_contract=user_escrow_proxy_contract)
proxy_deployment_txhashes = proxy_deployer.deploy(secret_hash=secret_hash, gas_limit=gas_limit)
proxy_deployment_txhashes = proxy_deployer.deploy()
deployment_transactions['proxy_deployment'] = proxy_deployment_txhash
return deployment_transactions
@classmethod
@ -423,11 +550,57 @@ class UserEscrowProxyDeployer(ContractDeployer):
proxy_name=cls.__proxy_deployer.contract_name)
return contract
def upgrade(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
deployment_transactions = dict()
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
# Proxy-Proxy
proxy_deployer = self.__proxy_deployer(deployer_address=self.deployer_address,
target_contract=existing_bare_contract,
bare=True)
# Proxy
proxy_args = (self.contract_name,
self.token_agent.contract_address,
self.miner_agent.contract_address,
self.policy_agent.contract_address)
user_escrow_proxy_contract, proxy_deployment_txhash = self.blockchain.interface.deploy_contract(*proxy_args)
self._contract = user_escrow_proxy_contract
deployment_transactions['deployment_txhash'] = proxy_deployment_txhash
proxy_deployer.retarget(new_target=user_escrow_proxy_contract.address,
existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
deployment_transactions['proxy_deployment'] = proxy_deployment_txhash
return deployment_transactions
def rollback(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
rollback_txhash = dispatcher_deployer.rollback(existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_rollback_receipt = self.blockchain.wait_for_receipt(txhash=rollback_txhash)
return rollback_txhash
class UserEscrowDeployer(ContractDeployer):
agency = UserEscrowAgent
contract_name = agency.registry_contract_name
_upgradeable = True
__linker_deployer = LibraryLinkerDeployer
__allocation_registry = AllocationRegistry
@ -455,7 +628,9 @@ class UserEscrowDeployer(ContractDeployer):
"""Relinquish ownership of a UserEscrow deployment to the beneficiary"""
if not is_checksum_address(beneficiary_address):
raise self.ContractDeploymentError("{} is not a valid checksum address.".format(beneficiary_address))
txhash = self.contract.functions.transferOwnership(beneficiary_address).transact({'from': self.deployer_address})
txhash = self.contract.functions.transferOwnership(beneficiary_address).transact({'from': self.deployer_address,
'gas': 500_000,
'gasPrice': self.blockchain.interface.w3.eth.gasPrice}) # TODO: Gas
self.blockchain.wait_for_receipt(txhash)
self.__beneficiary_address = beneficiary_address
return txhash
@ -473,10 +648,12 @@ class UserEscrowDeployer(ContractDeployer):
# Deposit
try:
# TODO: Gas management
args = {'from': self.deployer_address, 'gasPrice': self.blockchain.interface.w3.eth.gasPrice}
args = {'from': self.deployer_address,
'gasPrice': self.blockchain.interface.w3.eth.gasPrice,
'gas': 200_000}
txhash = self.contract.functions.initialDeposit(value, duration).transact(args)
except TransactionFailed:
raise
raise # TODO
allocation_transactions['initial_deposit'] = txhash
self.blockchain.wait_for_receipt(txhash)
@ -505,7 +682,7 @@ class UserEscrowDeployer(ContractDeployer):
self.enroll_principal_contract()
return dict(deposit_txhash=deposit_txhash, assign_txhash=assign_txhash)
def deploy(self) -> dict:
def deploy(self, gas_limit: int = None) -> dict:
"""Deploy a new instance of UserEscrow to the blockchain."""
self.check_deployment_readiness()
@ -513,7 +690,7 @@ class UserEscrowDeployer(ContractDeployer):
deployment_transactions = dict()
linker_contract = self.blockchain.interface.get_contract_by_name(name=self.__linker_deployer.contract_name)
args = (self.contract_name, linker_contract.address, self.token_agent.contract_address)
user_escrow_contract, deploy_txhash = self.blockchain.interface.deploy_contract(*args, enroll=False)
user_escrow_contract, deploy_txhash = self.blockchain.interface.deploy_contract(*args, gas_limit=gas_limit, enroll=False)
deployment_transactions['deploy_user_escrow'] = deploy_txhash
self._contract = user_escrow_contract
@ -524,36 +701,32 @@ class MiningAdjudicatorDeployer(ContractDeployer):
agency = MiningAdjudicatorAgent
contract_name = agency.registry_contract_name
__upgradeable = True
_upgradeable = True
__proxy_deployer = DispatcherDeployer
def __init__(self,
secret_hash,
economics: SlashingEconomics = None,
*args, **kwargs):
def __init__(self, economics: SlashingEconomics = None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.token_agent = NucypherTokenAgent(blockchain=self.blockchain)
self.miner_agent = MinerAgent(blockchain=self.blockchain)
self.secret_hash = secret_hash
if not economics:
economics = SlashingEconomics()
self.__economics = economics
def deploy(self) -> Dict[str, str]:
def deploy(self, secret_hash: bytes, gas_limit: int = None) -> Dict[str, str]:
self.check_deployment_readiness()
mining_adjudicator_contract, deploy_txhash = self.blockchain.interface \
.deploy_contract(self.contract_name,
self.miner_agent.contract_address,
*self.__economics.deployment_parameters)
*self.__economics.deployment_parameters,
gas_limit=gas_limit)
proxy_deployer = self.__proxy_deployer(blockchain=self.blockchain,
target_contract=mining_adjudicator_contract,
deployer_address=self.deployer_address,
secret_hash=self.secret_hash)
deployer_address=self.deployer_address)
proxy_deploy_txhashes = proxy_deployer.deploy()
proxy_deploy_txhashes = proxy_deployer.deploy(secret_hash=secret_hash)
# Cache the dispatcher contract
proxy_contract = proxy_deployer.contract
@ -574,4 +747,51 @@ class MiningAdjudicatorDeployer(ContractDeployer):
return deployment_transactions
def upgrade(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
self.check_deployment_readiness()
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
proxy_deployer = self.__proxy_deployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True)
mining_adjudicator_contract, deploy_txhash = self.blockchain.interface.deploy_contract(self.contract_name,
self.miner_agent.contract_address,
*self.__economics.deployment_parameters)
upgrade_tx_hash = proxy_deployer.retarget(new_target=mining_adjudicator_contract.address,
existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_upgrade_receipt = self.blockchain.wait_for_receipt(upgrade_tx_hash)
# Wrap the escrow contract
wrapped_adjudicator_contract = self.blockchain.interface._wrap_contract(proxy_deployer.contract,
target_contract=mining_adjudicator_contract)
# Switch the contract for the wrapped one
policy_manager_contract = wrapped_adjudicator_contract
self._contract = policy_manager_contract
upgrade_transaction = {'deploy': deploy_txhash, 'retarget': upgrade_tx_hash}
return upgrade_transaction
def rollback(self, existing_secret_plaintext: bytes, new_secret_hash: bytes):
existing_bare_contract = self.blockchain.interface.get_contract_by_name(name=self.contract_name,
proxy_name=self.__proxy_deployer.contract_name,
use_proxy_address=False)
dispatcher_deployer = DispatcherDeployer(blockchain=self.blockchain,
target_contract=existing_bare_contract,
deployer_address=self.deployer_address,
bare=True) # acquire agency for the dispatcher itself.
rollback_txhash = dispatcher_deployer.rollback(existing_secret_plaintext=existing_secret_plaintext,
new_secret_hash=new_secret_hash)
_rollback_receipt = self.blockchain.wait_for_receipt(txhash=rollback_txhash)
return rollback_txhash

467
nucypher/blockchain/eth/interfaces.py
View File

@ -15,36 +15,43 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from urllib.parse import urlparse
from eth_keys.datatypes import PublicKey, Signature
from eth_utils import to_canonical_address
from twisted.logger import Logger
import os
from typing import List
from typing import Tuple, Union
from web3 import Web3, WebsocketProvider, HTTPProvider, IPCProvider
from web3.contract import Contract
from web3.providers.eth_tester.main import EthereumTesterProvider
from urllib.parse import urlparse
from constant_sorrow.constants import (
NO_BLOCKCHAIN_CONNECTION,
NO_COMPILATION_PERFORMED,
MANUAL_PROVIDERS_SET,
NO_DEPLOYER_CONFIGURED
NO_DEPLOYER_CONFIGURED,
UNKNOWN_TX_STATUS,
)
from eth_tester import EthereumTester
from eth_tester import PyEVMBackend
from eth_utils import to_canonical_address
from twisted.logger import Logger
from web3 import Web3, WebsocketProvider, HTTPProvider, IPCProvider
from web3.contract import Contract
from web3.providers.eth_tester.main import EthereumTesterProvider
from nucypher.blockchain.eth.clients import NuCypherGethDevProcess
from nucypher.blockchain.eth.clients import Web3Client
from nucypher.blockchain.eth.registry import EthereumContractRegistry
from nucypher.blockchain.eth.sol.compile import SolidityCompiler
Web3Providers = Union[IPCProvider, WebsocketProvider, HTTPProvider, EthereumTester]
class BlockchainInterface:
"""
Interacts with a solidity compiler and a registry in order to instantiate compiled
ethereum contracts with the given web3 provider backend.
"""
__default_timeout = 10 # seconds
# __default_transaction_gas_limit = 500000 # TODO #842: determine sensible limit and validate transactions
__default_timeout = 180 # seconds
__default_transaction_gas = 500_000 # TODO #842: determine sensible limit and validate transactions
process = None # TODO
Web3 = Web3
class InterfaceError(Exception):
pass
@ -61,9 +68,9 @@ class BlockchainInterface:
def __init__(self,
provider_uri: str = None,
provider=None,
auto_connect: bool = True,
timeout: int = None,
registry: EthereumContractRegistry = None,
fetch_registry: bool = True,
compiler: SolidityCompiler = None) -> None:
"""
@ -123,43 +130,126 @@ class BlockchainInterface:
https: // github.com / ethereum / eth - tester # available-backends
* HTTP Provider - supply endpiont_uri
* Websocket Provider - supply endpoint uri and websocket=True
* IPC Provider - supply IPC path
* Custom Provider - supply an iterable of web3.py provider instances
* HTTP Provider - Web3 HTTP provider, typically JSON RPC 2.0 over HTTP
* Websocket Provider - Web3 WS provider, typically JSON RPC 2.0 over WS, supply endpoint uri and websocket=True
* IPC Provider - Web3 File based IPC provider transported over standard I/O
* Custom Provider - A pre-initialized web3.py provider instance to attach to this interface
"""
self.log = Logger("blockchain-interface") # type: Logger
self.log = Logger("blockchain-interface")
#
# Providers
#
self.w3 = NO_BLOCKCHAIN_CONNECTION
self.client = NO_BLOCKCHAIN_CONNECTION
self.__provider = provider or NO_BLOCKCHAIN_CONNECTION
self.provider_uri = NO_BLOCKCHAIN_CONNECTION
self.timeout = timeout if timeout is not None else self.__default_timeout
self.registry = registry
if provider_uri and provider:
raise self.InterfaceError("Pass a provider URI string, or a list of provider instances.")
elif provider_uri:
self.provider_uri = provider_uri
self.add_provider(provider_uri=provider_uri)
elif provider:
self.provider_uri = MANUAL_PROVIDERS_SET
self.add_provider(provider)
# Connect to Provider
self._connect(provider=provider, provider_uri=provider_uri)
# Establish contact with NuCypher contracts
if not registry:
self._configure_registry(fetch_registry=fetch_registry)
self._setup_solidity(compiler=compiler)
def __repr__(self):
r = '{name}({uri})'.format(name=self.__class__.__name__, uri=self.provider_uri)
return r
def __getattr__(self, name):
"""
MAGIC...
allows the interface class to defer to methods of its client
or its client.w3
for example:
methods/properties of w3 can be called through eg. interface.toWei()
if a particular eth provider needs a different method,
override that method for that provider's client
"""
# does BlockchainInterface have this attr/method?
if name not in self.__dict__:
# do we have a client?
if self.client is not NO_BLOCKCHAIN_CONNECTION:
# does the client have this property/method?
# most likely it is because of an implementation difference
# between parity/geth/etc.
if hasattr(self.client, name):
return getattr(self.client, name)
# ok, does w3 have it?
if hasattr(self.client.w3, name):
return getattr(self.client.w3, name)
# return the default getattr behavior (could be an AttributeError)
return object.__getattribute__(self, name)
@property
def client_version(self) -> str:
if self.__provider is NO_BLOCKCHAIN_CONNECTION:
return "Unknown"
return self.client.node_version
def _connect(self, provider: Web3Providers = None, provider_uri: str = None):
self.log.info("Connecting to {}".format(self.provider_uri))
self._attach_provider(provider=provider, provider_uri=provider_uri)
if self.__provider is NO_BLOCKCHAIN_CONNECTION:
raise self.NoProvider(
"There are no configured blockchain providers")
# Connect if not connected
self.client = Web3Client.from_w3(w3=self.Web3(provider=self.__provider))
# Check connection
if self.is_connected:
return True
raise self.ConnectionFailed('Failed to connect to provider: {}'.format(self.__provider))
@property
def provider(self) -> Union[IPCProvider, WebsocketProvider, HTTPProvider]:
return self.__provider
@property
def is_connected(self) -> bool:
"""
https://web3py.readthedocs.io/en/stable/__provider.html#examples-using-automated-detection
"""
return self.client.is_connected
@property
def _node_technology(self):
if self.client:
return self.client.node_technology
return NO_BLOCKCHAIN_CONNECTION
def _configure_registry(self, fetch_registry: bool = True):
RegistryClass = EthereumContractRegistry._get_registry_class(
local=self.client.is_local
)
if fetch_registry:
registry = RegistryClass.from_latest_publication()
else:
self.log.warn("No provider supplied for new blockchain interface; Using defaults")
registry = RegistryClass()
self.registry = registry
def _setup_solidity(self, compiler: SolidityCompiler=None):
# if a SolidityCompiler class instance was passed, compile from solidity source code
recompile = True if compiler is not None else False
self.__recompile = recompile
self.__sol_compiler = compiler
# Setup the registry and base contract factory cache
registry = registry if registry is not None else EthereumContractRegistry()
self.registry = registry
self.log.info("Using contract registry {}".format(self.registry.filepath))
if self.__recompile is True:
@ -171,55 +261,12 @@ class BlockchainInterface:
__raw_contract_cache = NO_COMPILATION_PERFORMED
self.__raw_contract_cache = __raw_contract_cache
# Auto-connect
self.autoconnect = auto_connect
if self.autoconnect is True:
self.connect()
def __repr__(self):
r = '{name}({uri})'.format(name=self.__class__.__name__, uri=self.provider_uri)
return r
def connect(self):
self.log.info("Connecting to {}".format(self.provider_uri))
if self.__provider is NO_BLOCKCHAIN_CONNECTION:
raise self.NoProvider("There are no configured blockchain providers")
# Connect
web3_instance = Web3(provider=self.__provider) # Instantiate Web3 object with provider
self.w3 = web3_instance
# Check connection
if not self.is_connected:
raise self.ConnectionFailed('Failed to connect to provider: {}'.format(self.__provider))
if self.is_connected:
self.log.info('Successfully Connected to {}'.format(self.provider_uri))
return self.is_connected
else:
raise self.ConnectionFailed("Failed to connect to {}.".format(self.provider_uri))
@property
def provider(self) -> Union[IPCProvider, WebsocketProvider, HTTPProvider]:
return self.__provider
@property
def is_connected(self) -> bool:
def _attach_provider(self, provider: Web3Providers = None, provider_uri: str = None) -> None:
"""
https://web3py.readthedocs.io/en/stable/__provider.html#examples-using-automated-detection
https://web3py.readthedocs.io/en/latest/providers.html#providers
"""
return self.w3.isConnected()
@property
def node_version(self) -> str:
"""Return node version information"""
return self.w3.node_version.node
def add_provider(self,
provider: Union[IPCProvider, WebsocketProvider, HTTPProvider, EthereumTester] = None,
provider_uri: str = None,
timeout: int = None) -> None:
self.provider_uri = provider_uri or NO_BLOCKCHAIN_CONNECTION
if not provider_uri and not provider:
raise self.NoProvider("No URI or provider instances supplied.")
@ -227,44 +274,99 @@ class BlockchainInterface:
if provider_uri and not provider:
uri_breakdown = urlparse(provider_uri)
# PyEVM
if uri_breakdown.scheme == 'tester':
if uri_breakdown.netloc == 'pyevm':
from nucypher.utilities.sandbox.constants import PYEVM_GAS_LIMIT, NUMBER_OF_ETH_TEST_ACCOUNTS
# Initialize
genesis_params = PyEVMBackend._generate_genesis_params(overrides={'gas_limit': PYEVM_GAS_LIMIT})
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
pyevm_backend.reset_to_genesis(genesis_params=genesis_params, num_accounts=NUMBER_OF_ETH_TEST_ACCOUNTS)
# Test provider entry-point
eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True)
provider = EthereumTesterProvider(ethereum_tester=eth_tester)
elif uri_breakdown.netloc == 'geth':
# TODO: Hardcoded geth - dev IPC provider - for now
provider = IPCProvider(ipc_path='/tmp/geth.ipc', timeout=timeout)
else:
raise ValueError("{} is an invalid or unsupported blockchain provider URI".format(provider_uri))
# IPC
elif uri_breakdown.scheme == 'ipc':
provider = IPCProvider(ipc_path=uri_breakdown.path, timeout=timeout)
# Websocket
elif uri_breakdown.scheme == 'ws':
provider = WebsocketProvider(endpoint_uri=provider_uri)
# HTTP
elif uri_breakdown.scheme in ('http', 'https'):
provider = HTTPProvider(endpoint_uri=provider_uri)
providers = {
'pyevm': self._get_tester_pyevm,
'geth': self._get_test_geth_parity_provider,
'parity-ethereum': self._get_test_geth_parity_provider,
}
lookup_attr = uri_breakdown.netloc
else:
raise self.InterfaceError("'{}' is not a supported provider protocol".format(uri_breakdown.scheme))
providers = {
'auto': self._get_auto_provider,
'infura': self._get_infura_provider,
'ipc': self._get_IPC_provider,
'file': self._get_IPC_provider,
'ws': self._get_websocket_provider,
'http': self._get_HTTP_provider,
'https': self._get_HTTP_provider,
}
lookup_attr = uri_breakdown.scheme
try:
self.__provider = providers[lookup_attr]()
except KeyError:
raise ValueError(
"{} is an invalid or unsupported blockchain"
" provider URI".format(provider_uri)
)
self.__provider = provider
def _get_IPC_provider(self):
uri_breakdown = urlparse(self.provider_uri)
return IPCProvider(ipc_path=uri_breakdown.path, timeout=self.timeout)
def _get_HTTP_provider(self):
return HTTPProvider(endpoint_uri=self.provider_uri)
def _get_websocket_provider(self):
return WebsocketProvider(endpoint_uri=self.provider_uri)
def _get_infura_provider(self):
# https://web3py.readthedocs.io/en/latest/providers.html#infura-mainnet
infura_envvar = 'WEB3_INFURA_API_SECRET'
if infura_envvar not in os.environ:
raise self.InterfaceError(f'{infura_envvar} must be set in order to use an Infura Web3 provider.')
from web3.auto.infura import w3
connected = w3.isConnected()
if not connected:
raise self.InterfaceError('Cannot auto-detect node. Provide a full URI instead.')
return w3.provider
def _get_auto_provider(self):
from web3.auto import w3
# how-automated-detection-works: https://web3py.readthedocs.io/en/latest/providers.html
connected = w3.isConnected()
if not connected:
raise self.InterfaceError('Cannot auto-detect node. Provide a full URI instead.')
return w3.provider
def _get_tester_pyevm(self):
# https://web3py.readthedocs.io/en/latest/providers.html#httpprovider
from nucypher.utilities.sandbox.constants import PYEVM_GAS_LIMIT, NUMBER_OF_ETH_TEST_ACCOUNTS
# Initialize
genesis_params = PyEVMBackend._generate_genesis_params(overrides={'gas_limit': PYEVM_GAS_LIMIT})
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
pyevm_backend.reset_to_genesis(genesis_params=genesis_params, num_accounts=NUMBER_OF_ETH_TEST_ACCOUNTS)
# Test provider entry-point
eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True)
provider = EthereumTesterProvider(ethereum_tester=eth_tester)
return provider
def _get_test_geth_parity_provider(self):
# geth --dev
geth_process = NuCypherGethDevProcess()
geth_process.start()
geth_process.wait_for_ipc(timeout=30)
provider = IPCProvider(ipc_path=geth_process.ipc_path, timeout=self.timeout)
# TODO: this seems strange to modify a class attr here?
BlockchainInterface.process = geth_process
return provider
def _get_tester_ganache(self, endpoint_uri=None):
endpoint_uri = endpoint_uri or 'http://localhost:7545'
return HTTPProvider(endpoint_uri=endpoint_uri)
@classmethod
def disconnect(cls):
if BlockchainInterface.process:
if BlockchainInterface.process.is_running:
BlockchainInterface.process.stop()
def get_contract_factory(self, contract_name: str) -> Contract:
"""Retrieve compiled interface data from the cache and return web3 contract"""
@ -278,7 +380,7 @@ class BlockchainInterface:
raise self.InterfaceError(message)
raise
else:
contract = self.w3.eth.contract(abi=interface['abi'],
contract = self.client.w3.eth.contract(abi=interface['abi'],
bytecode=interface['bin'],
ContractFactoryClass=Contract)
return contract
@ -293,7 +395,7 @@ class BlockchainInterface:
"""
# Wrap the contract
wrapped_contract = self.w3.eth.contract(abi=target_contract.abi,
wrapped_contract = self.client.w3.eth.contract(abi=target_contract.abi,
address=wrapper_contract.address,
ContractFactoryClass=factory)
return wrapped_contract
@ -303,35 +405,62 @@ class BlockchainInterface:
try:
contract_records = self.registry.search(contract_address=address)
except RuntimeError:
raise self.InterfaceError('Corrupted Registrar') # TODO #461: Integrate with Registry
# TODO #461: Integrate with Registry
raise self.InterfaceError(f'Corrupted contract registry: {self.registry.filepath}.')
else:
if not contract_records:
raise self.UnknownContract("No such contract with address {}".format(address))
raise self.UnknownContract(f"No such contract with address: {address}.")
return contract_records[0]
def get_proxy(self, target_address: str, proxy_name: str, factory: Contract = Contract):
# Lookup proxies; Search for a registered proxy that targets this contract record
records = self.registry.search(contract_name=proxy_name)
dispatchers = list()
for name, addr, abi in records:
proxy_contract = self.client.w3.eth.contract(abi=abi,
address=addr,
ContractFactoryClass=factory)
# Read this dispatchers target address from the blockchain
proxy_live_target_address = proxy_contract.functions.target().call()
if proxy_live_target_address == target_address:
dispatchers.append(proxy_contract)
if len(dispatchers) > 1:
message = f"Multiple Dispatcher deployments are targeting {target_address}"
raise self.InterfaceError(message)
try:
return dispatchers[0]
except IndexError:
raise self.UnknownContract(f"No registered Dispatcher deployments target {target_address}")
def get_contract_by_name(self,
name: str,
proxy_name: str = None,
use_proxy_address: bool = True,
factory: Contract = Contract) -> Contract:
factory: Contract = Contract) -> Union[Contract, List[tuple]]:
"""
Instantiate a deployed contract from registry data,
and assimilate it with it's proxy if it is upgradeable.
and assimilate it with it's proxy if it is upgradeable,
or return all registered records if use_proxy_address is False.
"""
target_contract_records = self.registry.search(contract_name=name)
if not target_contract_records:
raise self.UnknownContract("No such contract records with name {}".format(name))
raise self.UnknownContract(f"No such contract records with name {name}.")
if proxy_name: # It's upgradeable
# Lookup proxies; Search fot a published proxy that targets this contract record
proxy_records = self.registry.search(contract_name=proxy_name)
unified_pairs = list()
results = list()
for proxy_name, proxy_addr, proxy_abi in proxy_records:
proxy_contract = self.w3.eth.contract(abi=proxy_abi,
proxy_contract = self.client.w3.eth.contract(abi=proxy_abi,
address=proxy_addr,
ContractFactoryClass=factory)
@ -347,15 +476,15 @@ class BlockchainInterface:
else:
continue
unified_pairs.append(pair)
results.append(pair)
if len(unified_pairs) > 1:
address, abi = unified_pairs[0]
if len(results) > 1:
address, abi = results[0]
message = "Multiple {} deployments are targeting {}".format(proxy_name, address)
raise self.InterfaceError(message.format(name))
else:
selected_address, selected_abi = unified_pairs[0]
selected_address, selected_abi = results[0]
else: # It's not upgradeable
if len(target_contract_records) != 1:
@ -364,43 +493,12 @@ class BlockchainInterface:
_target_contract_name, selected_address, selected_abi = target_contract_records[0]
# Create the contract from selected sources
unified_contract = self.w3.eth.contract(abi=selected_abi,
unified_contract = self.client.w3.eth.contract(abi=selected_abi,
address=selected_address,
ContractFactoryClass=factory)
return unified_contract
def call_backend_sign(self, account: str, message: bytes) -> str:
"""
Calls the appropriate signing function for the specified account on the
backend. If the backend is based on eth-tester, then it uses the
eth-tester signing interface to do so.
"""
if isinstance(self.provider, EthereumTesterProvider):
# Tests only
address = to_canonical_address(account)
sig_key = self.provider.ethereum_tester.backend._key_lookup[address]
signed_message = sig_key.sign_msg(message)
return signed_message
else:
return self.w3.eth.sign(account, data=message) # TODO: Use node signing APIs
def call_backend_verify(self, pubkey: PublicKey, signature: Signature, msg_hash: bytes) -> bool:
"""
Verifies a hex string signature and message hash are from the provided
public key.
"""
is_valid_sig = signature.verify_msg_hash(msg_hash, pubkey)
sig_pubkey = signature.recover_public_key_from_msg_hash(msg_hash)
return is_valid_sig and (sig_pubkey == pubkey)
def unlock_account(self, address, password, duration):
if 'tester' in self.provider_uri:
return True # Test accounts are unlocked by default.
return self.w3.geth.personal.unlockAccount(address, password, duration)
class BlockchainDeployerInterface(BlockchainInterface):
@ -426,6 +524,7 @@ class BlockchainDeployerInterface(BlockchainInterface):
contract_name: str,
*constructor_args,
enroll: bool = True,
gas_limit: int = None,
**kwargs
) -> Tuple[Contract, str]:
"""
@ -439,48 +538,60 @@ class BlockchainDeployerInterface(BlockchainInterface):
# Build the deployment transaction #
#
deployment_gas = 6_000_000 # TODO: Gas management
deploy_transaction = {'from': self.deployer_address, 'gasPrice': self.w3.eth.gasPrice}
deploy_transaction = {'from': self.deployer_address, 'gasPrice': self.client.w3.eth.gasPrice}
if gas_limit:
deploy_transaction.update({'gas': gas_limit})
self.log.info("Deployer address is {}".format(deploy_transaction['from']))
contract_factory = self.get_contract_factory(contract_name=contract_name)
deploy_bytecode = contract_factory.constructor(*constructor_args, **kwargs).buildTransaction(deploy_transaction)
self.log.info("Deploying contract: {}: {} bytes".format(contract_name, len(deploy_bytecode['data'])))
transaction = contract_factory.constructor(*constructor_args, **kwargs).buildTransaction(deploy_transaction)
self.log.info("Deploying contract: {}: {} bytes".format(contract_name, len(transaction['data'])))
#
# Transmit the deployment tx #
#
txhash = contract_factory.constructor(*constructor_args, **kwargs).transact(transaction=deploy_transaction)
txhash = self.client.w3.eth.sendTransaction(transaction=transaction)
self.log.info("{} Deployment TX sent : txhash {}".format(contract_name, txhash.hex()))
# Wait for receipt
self.log.info(f"Waiting for deployment receipt for {contract_name}")
receipt = self.w3.eth.waitForTransactionReceipt(txhash)
receipt = self.client.w3.eth.waitForTransactionReceipt(txhash, timeout=240)
#
# Verify deployment success
#
# Primary check
deployment_status = receipt['status']
deployment_status = receipt.get('status', UNKNOWN_TX_STATUS)
if deployment_status is 0:
failure = f"{contract_name.upper()} Deployment transaction submitted, but receipt returned status code 0. " \
f"Full receipt: \n {receipt}"
failure = f"{contract_name.upper()} Deployment transaction transmitted, but receipt returned status code 0. " \
f"Full receipt: \n {pprint.pformat(receipt, indent=2)}"
raise self.DeploymentFailed(failure)
# Secondary check
tx = self.w3.eth.getTransaction(txhash)
if tx["gas"] == receipt["gasUsed"]:
raise self.DeploymentFailed(f"Deployment transaction failed and consumed 100% of transaction gas ({deployment_gas})")
if deployment_status is UNKNOWN_TX_STATUS:
self.log.info(f"Unknown transaction status for {txhash} (receipt did not contain a status field)")
# Secondary check TODO: Is this a sensible check?
tx = self.client.w3.eth.getTransaction(txhash)
if tx["gas"] == receipt["gasUsed"]:
raise self.DeploymentFailed(f"Deployment transaction consumed 100% of transaction gas."
f"Full receipt: \n {pprint.pformat(receipt, indent=2)}")
# Success
address = receipt['contractAddress']
self.log.info("Confirmed {} deployment: address {}".format(contract_name, address))
#
# Instantiate & Enroll contract
#
contract = contract_factory(address=address)
contract = self.client.w3.eth.contract(address=address, abi=contract_factory.abi)
if enroll is True:
self.registry.enroll(contract_name=contract_name,
contract_address=contract.address,
contract_abi=contract_factory.abi)
return contract, txhash
return contract, txhash # receipt

5
nucypher/blockchain/eth/policies.py
View File

@ -258,7 +258,10 @@ class BlockchainPolicy(Policy):
if self.value is NON_PAYMENT:
self.value = 0
payload = {'from': self.author.checksum_public_address, 'value': self.value}
payload = {'from': self.author.checksum_public_address,
'value': self.value,
'gasPrice': self.author.blockchain.interface.w3.eth.gasPrice}
prearranged_ursulas = list(a.ursula.checksum_public_address for a in self._accepted_arrangements)
txhash = self.author.policy_agent.contract.functions.createPolicy(self.hrac()[:16],

129
nucypher/blockchain/eth/registry.py
View File

@ -14,12 +14,14 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import base64
import json
import os
import pprint
import tempfile
from json import JSONDecodeError
import requests
from twisted.logger import Logger
import shutil
@ -43,6 +45,10 @@ class EthereumContractRegistry:
_default_registry_filepath = os.path.join(DEFAULT_CONFIG_ROOT, 'contract_registry.json')
__PUBLICATION_USER = "nucypher"
__PUBLICATION_REPO = "nucypher/ethereum-contract-registry"
__PUBLICATION_FILENAME = "contract_registry.json" # TODO: Versioning
class RegistryError(Exception):
pass
@ -62,6 +68,100 @@ class EthereumContractRegistry:
self.log = Logger("registry")
self.__filepath = registry_filepath or self._default_registry_filepath
@classmethod
def _get_registry_class(cls, local=False):
"""
If "local" is True, it means we are running a local blockchain and we
have deployed the Nucypher contracts on that blockchain, therefore
we do not want to download a registry from github.
"""
return LocalEthereumContractRegistry if local else cls
@classmethod
def download_latest_publication(cls,
filepath: str = None,
branch: str = 'goerli'
) -> str:
"""
Get the latest published contract registry from github and save it on the local file system.
"""
from nucypher.config.node import NodeConfiguration
github_endpoint = f'https://raw.githubusercontent.com/{cls.__PUBLICATION_REPO}/{branch}/{cls.__PUBLICATION_FILENAME}'
response = requests.get(github_endpoint)
if response.status_code != 200:
raise cls.RegistryError(f"Failed to fetch registry from {github_endpoint} with status code {response.status_code} ")
filepath = filepath or cls._default_registry_filepath
# TODO : Use envvar for config root and registry path
try:
with open(filepath, 'wb') as registry_file: # TODO: Skip re-write if already up to date
registry_file.write(response.content)
except FileNotFoundError:
raise NodeConfiguration.NoConfigurationRoot
return filepath
@classmethod
def from_latest_publication(cls,
filepath: str = None,
branch: str = 'goerli'
) -> 'EthereumContractRegistry':
filepath = cls.download_latest_publication(filepath=filepath, branch=branch)
instance = cls(registry_filepath=filepath)
return instance
def publish(self, branch: str = 'goerli') -> dict:
# TODO: NuCypher Org GPG Signed Commits?
#
# Build Request
#
try:
github_token = os.environ['GITHUB_API_TOKEN']
except KeyError:
raise self.RegistryError("Please set the 'GITHUB_API_TOKEN' environment variable and try again.")
base_url = "api.github.com/repos"
headers = {"Authorization": f"token {github_token}"}
github_endpoint = f"https://{base_url}/{self.__PUBLICATION_REPO}/contents/{self.__PUBLICATION_FILENAME}"
# Encode registry
with open(self.filepath, "rb") as registry_file:
base64_registry = base64.b64encode(registry_file.read())
#
# Transmit
#
# [GET] -> latest commit
response = requests.get(url=github_endpoint, params={'ref': branch}, headers=headers)
if response.status_code != 200:
message = f"Failed to fetch registry from {github_endpoint} with status code {response.status_code}."
raise self.RegistryError(message)
response_data = response.json()
latest_sha = response_data['sha']
# Compare local vs. remote file contents
existing_content = base64_registry.decode('utf-8').strip('\n')
latest_content = response_data['content'].strip('\n') # GH adds newlines for whatever reason
if existing_content != latest_content:
# Update needed... Encode Upload Request
message = json.dumps({"message": "[automated]", # TODO: Better commit message including versioning
"branch": branch,
"content": base64_registry.decode("utf-8"),
"sha": latest_sha})
# [PUT] -> Update Registry and Commit
headers.update({"Content-Type": "application/json"})
response = requests.put(url=github_endpoint, data=message, headers=headers) # TODO: Error handling
response_data = response.json()
return response_data
else:
raise self.RegistryError(f"Already up to date with {latest_sha}")
@property
def filepath(self):
return self.__filepath
@ -102,19 +202,21 @@ class EthereumContractRegistry:
this function first to get the current state to append to the dict or
modify it because _write_registry_file overwrites the file.
"""
try:
with open(self.__filepath, 'r') as registry_file:
self.log.debug("Reading from registrar: filepath {}".format(self.__filepath))
with open(self.filepath, 'r') as registry_file:
self.log.debug("Reading from registrar: filepath {}".format(self.filepath))
registry_file.seek(0)
file_data = registry_file.read()
if file_data:
registry_data = json.loads(file_data)
try:
registry_data = json.loads(file_data)
except JSONDecodeError:
raise self.RegistryError(f"Registry contains invalid JSON at '{self.__filepath}'")
else:
registry_data = list() if self._multi_contract else dict()
except FileNotFoundError:
raise self.NoRegistry("No registry at filepath: {}".format(self.__filepath))
raise self.NoRegistry("No registry at filepath: {}".format(self.filepath))
except JSONDecodeError:
raise
@ -171,6 +273,19 @@ class EthereumContractRegistry:
return contracts if contract_name else contracts[0]
class LocalEthereumContractRegistry(EthereumContractRegistry):
_default_registry_filepath = os.path.join(
DEFAULT_CONFIG_ROOT, 'dev_contract_registry.json'
)
__filepath = _default_registry_filepath
@classmethod
def download_latest_publication(cls, *args, **kwargs):
return cls._default_registry_filepath
class TemporaryEthereumContractRegistry(EthereumContractRegistry):
def __init__(self) -> None:

3
nucypher/blockchain/eth/token.py
View File

@ -286,9 +286,6 @@ class Stake:
'Stake duration of ({duration}) is too short; must be at least {minimum} periods.'
.format(minimum=self.economics.minimum_locked_periods, duration=self.duration)),
(self.economics.maximum_locked_periods >= self.duration,
'Stake duration of ({duration}) is too long; must be no more than {maximum} periods.'
.format(maximum=self.economics.maximum_locked_periods, duration=self.duration)),
)
if raise_on_fail is True:

81
nucypher/characters/base.py
View File

@ -14,8 +14,7 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from contextlib import suppress
import contextlib
from typing import Dict, ClassVar, Set
from typing import Optional
from typing import Union, List
@ -28,18 +27,20 @@ from constant_sorrow.constants import (
NO_DECRYPTION_PERFORMED,
NO_NICKNAME,
NO_SIGNING_POWER,
NO_WSGI_APP,
SIGNATURE_TO_FOLLOW,
SIGNATURE_IS_ON_CIPHERTEXT,
STRANGER,
FEDERATED_ONLY
)
from cryptography.exceptions import InvalidSignature
from eth_keys import KeyAPI as EthKeyAPI
from eth_utils import to_checksum_address, to_canonical_address
from umbral.keys import UmbralPublicKey
from umbral.signing import Signature
from nucypher.blockchain.eth.agents import MinerAgent
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.config.constants import GLOBAL_DOMAIN
from nucypher.config.node import NodeConfiguration
from nucypher.crypto.api import encrypt_and_sign
from nucypher.crypto.kits import UmbralMessageKit
from nucypher.crypto.powers import (
@ -61,15 +62,16 @@ class Character(Learner):
A base-class for any character in our cryptography protocol narrative.
"""
_display_name_template = "({})⇀{}↽ ({})" # Used in __repr__ and in cls.from_bytes
_default_crypto_powerups = None
_stamp = None
_crashed = False
from nucypher.network.protocols import SuspiciousActivity # Ship this exception with every Character.
from nucypher.crypto.signing import InvalidSignature
from nucypher.crypto.signing import InvalidSignature # TODO: Restore nucypher Signing exceptions
def __init__(self,
domains: Set = (GLOBAL_DOMAIN,),
domains: Set = None,
is_me: bool = True,
federated_only: bool = False,
blockchain: Blockchain = None,
@ -104,7 +106,6 @@ class Character(Learner):
represented by zero Characters or by more than one Character.
"""
self.federated_only = federated_only # type: bool
#
@ -122,12 +123,23 @@ class Character(Learner):
self._crypto_power = CryptoPower(power_ups=self._default_crypto_powerups)
self._checksum_address = checksum_public_address
# Fleet and Blockchain Connection (Everyone)
if not domains:
domains = (NodeConfiguration.DEFAULT_DOMAIN, )
# Needed for on-chain verification
if not self.federated_only:
self.blockchain = blockchain or Blockchain.connect()
self.miner_agent = MinerAgent(blockchain=blockchain)
else:
self.blockchain = FEDERATED_ONLY
self.miner_agent = FEDERATED_ONLY
#
# Self-Character
#
if is_me is True:
if not self.federated_only:
self.blockchain = blockchain or Blockchain.connect()
self.keyring_dir = keyring_dir # type: str
self.treasure_maps = {} # type: dict
@ -215,7 +227,7 @@ class Character(Learner):
return int.from_bytes(bytes(self.stamp), byteorder="big")
def __repr__(self):
r = "({})⇀{}↽ ({})"
r = self._display_name_template
try:
r = r.format(self.__class__.__name__, self.nickname, self.checksum_public_address)
except NoSigningPower: # TODO: ....yeah?
@ -353,53 +365,68 @@ class Character(Learner):
:param message_kit: the message to be (perhaps decrypted and) verified.
:param signature: The signature to check.
:param decrypt: Whether or not to decrypt the messages.
:param label: A label used for decrypting messages encrypted under its associated policy encrypting key
:return: Whether or not the signature is valid, the decrypted plaintext or NO_DECRYPTION_PERFORMED
"""
sender_pubkey_sig = stranger.stamp.as_umbral_pubkey()
with suppress(AttributeError):
if message_kit.sender_pubkey_sig:
if not message_kit.sender_pubkey_sig == sender_pubkey_sig:
raise ValueError(
"This MessageKit doesn't appear to have come from {}".format(stranger))
#
# Optional Sanity Check
#
# In the spirit of duck-typing, we want to accept a message kit object, or bytes
# If the higher-order object MessageKit is passed, we can perform an additional
# eager sanity check before performing decryption.
with contextlib.suppress(AttributeError):
sender_verifying_key = stranger.stamp.as_umbral_pubkey()
if message_kit.sender_verifying_key:
if not message_kit.sender_verifying_key == sender_verifying_key:
raise ValueError("This MessageKit doesn't appear to have come from {}".format(stranger))
#
# Decrypt
#
signature_from_kit = None
if decrypt:
# We are decrypting the message; let's do that first and see what the sig header says.
cleartext_with_sig_header = self.decrypt(message_kit=message_kit,
label=label)
cleartext_with_sig_header = self.decrypt(message_kit=message_kit, label=label)
sig_header, cleartext = default_constant_splitter(cleartext_with_sig_header, return_remainder=True)
if sig_header == SIGNATURE_IS_ON_CIPHERTEXT:
# THe ciphertext is what is signed - note that for later.
# The ciphertext is what is signed - note that for later.
message = message_kit.ciphertext
if not signature:
raise ValueError("Can't check a signature on the ciphertext if don't provide one.")
elif sig_header == SIGNATURE_TO_FOLLOW:
# The signature follows in this cleartext - split it off.
signature_from_kit, cleartext = signature_splitter(cleartext,
return_remainder=True)
signature_from_kit, cleartext = signature_splitter(cleartext, return_remainder=True)
message = cleartext
else:
# Not decrypting - the message is the object passed in as a message kit. Cast it.
message = bytes(message_kit)
cleartext = NO_DECRYPTION_PERFORMED
#
# Verify Signature
#
if signature and signature_from_kit:
if signature != signature_from_kit:
raise ValueError(
"The MessageKit has a Signature, but it's not the same one you provided. Something's up.")
signature_to_use = signature or signature_from_kit
if signature_to_use:
is_valid = signature_to_use.verify(message, sender_pubkey_sig)
is_valid = signature_to_use.verify(message, sender_verifying_key) # FIXME: Message is undefined here
if not is_valid:
raise stranger.InvalidSignature(
"Signature for message isn't valid: {}".format(signature_to_use))
raise InvalidSignature("Signature for message isn't valid: {}".format(signature_to_use))
else:
raise self.InvalidSignature("No signature provided -- signature presumed invalid.")
raise InvalidSignature("No signature provided -- signature presumed invalid.")
return cleartext

32
nucypher/characters/chaotic.py
View File

@ -27,7 +27,7 @@ from nucypher.blockchain.eth.token import NU
from nucypher.characters.banners import MOE_BANNER, FELIX_BANNER, NU_BANNER
from nucypher.characters.base import Character
from nucypher.config.constants import TEMPLATES_DIR
from nucypher.crypto.powers import SigningPower
from nucypher.crypto.powers import SigningPower, BlockchainPower
from nucypher.keystore.threading import ThreadedSession
from nucypher.network.nodes import FleetStateTracker
@ -129,7 +129,7 @@ class Felix(Character, NucypherTokenActor):
research and the development of production-ready nucypher dApps.
"""
_default_crypto_powerups = [SigningPower] # identity only
_default_crypto_powerups = [SigningPower, BlockchainPower]
TEMPLATE_NAME = 'felix.html'
@ -142,7 +142,7 @@ class Felix(Character, NucypherTokenActor):
BATCH_SIZE = 10 # transactions
MULTIPLIER = 0.95 # 5% reduction of previous stake is 0.95, for example
MINIMUM_DISBURSEMENT = 1e18 # NuNits
# TRANSACTION_GAS = 40000 # gas TODO
ETHER_AIRDROP_AMOUNT = int(2e18) # Wei
# Node Discovery
LEARNING_TIMEOUT = 30 # seconds
@ -163,6 +163,7 @@ class Felix(Character, NucypherTokenActor):
rest_port: int,
crash_on_error: bool = False,
economics: TokenEconomics = None,
distribute_ether: bool = True,
*args, **kwargs):
# Character
@ -203,6 +204,9 @@ class Felix(Character, NucypherTokenActor):
self.MAXIMUM_DISBURSEMENT = economics.maximum_allowed_locked
self.INITIAL_DISBURSEMENT = economics.minimum_allowed_locked
# Optionally send ether with each token transaction
self.distribute_ether = distribute_ether
# Banner
self.log.info(FELIX_BANNER.format(self.checksum_public_address))
@ -332,6 +336,8 @@ class Felix(Character, NucypherTokenActor):
"""Start token distribution"""
self.log.info(NU_BANNER)
self.log.info("Starting NU Token Distribution | START")
if self.token_balance is NU.ZERO():
raise self.ActorError(f"Felix address {self.checksum_public_address} has 0 NU tokens.")
self._distribution_task.start(interval=self.DISTRIBUTION_INTERVAL, now=now)
return True
@ -368,8 +374,22 @@ class Felix(Character, NucypherTokenActor):
target_address=recipient_address,
sender_address=self.checksum_public_address)
self.log.info(f"Disbursement #{self.__disbursement} OK | {txhash.hex()[-6:]} | "
f"({str(NU(disbursement, 'NuNit'))}) -> {recipient_address}")
if self.distribute_ether:
ether = self.ETHER_AIRDROP_AMOUNT
transaction = {'to': recipient_address,
'from': self.checksum_public_address,
'value': ether,
'gasPrice': self.blockchain.interface.w3.eth.gasPrice}
ether_txhash = self.blockchain.interface.w3.eth.sendTransaction(transaction)
self.log.info(f"Disbursement #{self.__disbursement} OK | NU {txhash.hex()[-6:]} | ETH {ether_txhash.hex()[:6]} "
f"({str(NU(disbursement, 'NuNit'))} + {self.ETHER_AIRDROP_AMOUNT} wei) -> {recipient_address}")
else:
self.log.info(
f"Disbursement #{self.__disbursement} OK | {txhash.hex()[-6:]} |"
f"({str(NU(disbursement, 'NuNit'))} -> {recipient_address}")
return txhash
def airdrop_tokens(self):
@ -391,7 +411,7 @@ class Felix(Character, NucypherTokenActor):
since = datetime.now() - timedelta(hours=self.DISBURSEMENT_INTERVAL)
datetime_filter = or_(self.Recipient.last_disbursement_time <= since,
self.Recipient.last_disbursement_time == None)
self.Recipient.last_disbursement_time == None) # This must be `==` not `is`
with ThreadedSession(self.db_engine) as session:
candidates = session.query(self.Recipient).filter(datetime_filter).all()

16
nucypher/characters/control/interfaces.py
View File

@ -83,7 +83,7 @@ class AliceInterface(CharacterPublicInterface, AliceSpecification):
return response_data
def derive_policy_encrypting_key(self, label: bytes) -> dict:
policy_encrypting_key = self.character.get_policy_pubkey_from_label(label)
policy_encrypting_key = self.character.get_policy_encrypting_key_from_label(label)
response_data = {'policy_encrypting_key': policy_encrypting_key, 'label': label}
return response_data
@ -133,11 +133,11 @@ class AliceInterface(CharacterPublicInterface, AliceSpecification):
from nucypher.characters.lawful import Enrico
policy_encrypting_key = self.character.get_policy_pubkey_from_label(label)
policy_encrypting_key = self.character.get_policy_encrypting_key_from_label(label)
message_kit = UmbralMessageKit.from_bytes(message_kit) # TODO #846: May raise UnknownOpenSSLError and InvalidTag.
data_source = Enrico.from_public_keys(
verifying_key=message_kit.sender_pubkey_sig,
verifying_key=message_kit.sender_verifying_key,
policy_encrypting_key=policy_encrypting_key,
label=label
)
@ -169,7 +169,7 @@ class BobInterface(CharacterPublicInterface, BobSpecification):
"""
Character control endpoint for joining a policy on the network.
"""
self.bob.join_policy(label=label, alice_pubkey_sig=alice_verifying_key)
self.bob.join_policy(label=label, alice_verifying_key=alice_verifying_key)
response = dict() # {'policy_encrypting_key': ''} # FIXME
return response
@ -184,17 +184,17 @@ class BobInterface(CharacterPublicInterface, BobSpecification):
from nucypher.characters.lawful import Enrico
policy_encrypting_key = UmbralPublicKey.from_bytes(policy_encrypting_key)
alice_pubkey_sig = UmbralPublicKey.from_bytes(alice_verifying_key)
alice_verifying_key = UmbralPublicKey.from_bytes(alice_verifying_key)
message_kit = UmbralMessageKit.from_bytes(message_kit) # TODO #846: May raise UnknownOpenSSLError and InvalidTag.
data_source = Enrico.from_public_keys(verifying_key=message_kit.sender_pubkey_sig,
data_source = Enrico.from_public_keys(verifying_key=message_kit.sender_verifying_key,
policy_encrypting_key=policy_encrypting_key,
label=label)
self.bob.join_policy(label=label, alice_pubkey_sig=alice_pubkey_sig)
self.bob.join_policy(label=label, alice_verifying_key=alice_verifying_key)
plaintexts = self.bob.retrieve(message_kit=message_kit,
data_source=data_source,
alice_verifying_key=alice_pubkey_sig,
alice_verifying_key=alice_verifying_key,
label=label)
response_data = {'cleartexts': plaintexts}

3
nucypher/characters/control/serializers.py
View File

@ -7,7 +7,6 @@ from typing import Callable
import maya
import nucypher
from nucypher.characters.control.specifications import CharacterSpecification
class CharacterControlSerializer(ABC):
@ -84,7 +83,7 @@ class AliceControlJSONSerializer(CharacterControlJSONSerializer, MessageHandlerM
def load_create_policy_input(request: dict):
parsed_input = dict(bob_encrypting_key=bytes.fromhex(request['bob_encrypting_key']),
bob_verifying_key=bytes.fromhex(request['bob_verifying_key']),
label=b64decode(request['label']),
label=request['label'].encode(),
m=request['m'],
n=request['n'])
return parsed_input

84
nucypher/characters/lawful.py
View File

@ -20,7 +20,7 @@ from base64 import b64encode
from collections import OrderedDict
from functools import partial
from json.decoder import JSONDecodeError
from typing import Dict, Iterable, List, Set, Tuple
from typing import Dict, Iterable, List, Set, Tuple, Union
import maya
import requests
@ -48,7 +48,6 @@ from nucypher.characters.banners import ALICE_BANNER, BOB_BANNER, ENRICO_BANNER,
from nucypher.characters.base import Character, Learner
from nucypher.characters.control.controllers import AliceJSONController, BobJSONController, EnricoJSONController, \
WebController
from nucypher.config.constants import GLOBAL_DOMAIN
from nucypher.config.storages import NodeStorage, ForgetfulNodeStorage
from nucypher.crypto.api import keccak_digest, encrypt_and_sign
from nucypher.crypto.constants import PUBLIC_KEY_LENGTH, PUBLIC_ADDRESS_LENGTH
@ -181,7 +180,8 @@ class Alice(Character, PolicyAuthor):
expiration=None,
value=None,
handpicked_ursulas=None,
timeout=10):
timeout=10,
discover_on_this_thread=False):
if not m:
# TODO: get m from config #176
@ -205,6 +205,11 @@ class Alice(Character, PolicyAuthor):
if handpicked_ursulas is None:
handpicked_ursulas = set()
else:
# This might be the first time alice learns about the handpicked Ursulas.
for handpicked_ursula in handpicked_ursulas:
self.remember_node(node=handpicked_ursula)
policy = self.create_policy(bob,
label,
m, n,
@ -218,11 +223,11 @@ class Alice(Character, PolicyAuthor):
# value and expiration combinations on a limited number of Ursulas;
# Users may decide to inject some market strategies here.
#
# TODO: 289
# TODO: #289
# If we're federated only, we need to block to make sure we have enough nodes.
if self.federated_only and len(self.known_nodes) < n:
good_to_go = self.block_until_number_of_known_nodes_is(n, learn_on_this_thread=True, timeout=timeout)
good_to_go = self.block_until_number_of_known_nodes_is(n, learn_on_this_thread=discover_on_this_thread, timeout=timeout)
if not good_to_go:
raise ValueError(
"To make a Policy in federated mode, you need to know about "
@ -244,7 +249,7 @@ class Alice(Character, PolicyAuthor):
policy.enact(network_middleware=self.network_middleware)
return policy # Now with TreasureMap affixed!
def get_policy_pubkey_from_label(self, label: bytes) -> UmbralPublicKey:
def get_policy_encrypting_key_from_label(self, label: bytes) -> UmbralPublicKey:
alice_delegating_power = self._crypto_power.power_ups(DelegatingPower)
policy_pubkey = alice_delegating_power.get_pubkey_from_label(label)
return policy_pubkey
@ -292,16 +297,13 @@ class Alice(Character, PolicyAuthor):
I/O signatures match Bob's retrieve interface.
"""
cleartexts = []
cleartexts.append(
self.verify_from(
data_source,
message_kit,
signature=message_kit.signature,
decrypt=True,
label=label
)
)
cleartexts = [self.verify_from(
data_source,
message_kit,
signature=message_kit.signature,
decrypt=True,
label=label
)]
return cleartexts
def make_web_controller(drone_alice, crash_on_error: bool = False):
@ -504,8 +506,9 @@ class Bob(Character):
def make_compass_for_alice(self, alice):
return partial(self.verify_from, alice, decrypt=True)
def construct_policy_hrac(self, verifying_key, label):
return keccak_digest(bytes(verifying_key) + self.stamp + label)
def construct_policy_hrac(self, verifying_key: Union[bytes, UmbralPublicKey], label: bytes) -> bytes:
_hrac = keccak_digest(bytes(verifying_key) + self.stamp + label)
return _hrac
def construct_hrac_and_map_id(self, verifying_key, label):
hrac = self.construct_policy_hrac(verifying_key, label)
@ -583,10 +586,10 @@ class Bob(Character):
work_orders_by_ursula[task.capsule] = work_order
return cfrags
def join_policy(self, label, alice_pubkey_sig, node_list=None, block=False):
def join_policy(self, label, alice_verifying_key, node_list=None, block=False):
if node_list:
self._node_ids_to_learn_about_immediately.update(node_list)
treasure_map = self.get_treasure_map(alice_pubkey_sig, label)
treasure_map = self.get_treasure_map(alice_verifying_key, label)
self.follow_treasure_map(treasure_map=treasure_map, block=block)
def retrieve(self, message_kit, data_source, alice_verifying_key, label):
@ -705,7 +708,7 @@ class Ursula(Teacher, Character, Miner):
# Ursula
rest_host: str,
rest_port: int,
domains: Set = (GLOBAL_DOMAIN,), # For now, serving and learning domains will be the same.
domains: Set = None, # For now, serving and learning domains will be the same.
certificate: Certificate = None,
certificate_filepath: str = None,
db_filepath: str = None,
@ -714,7 +717,7 @@ class Ursula(Teacher, Character, Miner):
timestamp=None,
# Blockchain
identity_evidence: bytes = constants.NOT_SIGNED,
decentralized_identity_evidence: bytes = constants.NOT_SIGNED,
checksum_public_address: str = None,
# Character
@ -732,6 +735,12 @@ class Ursula(Teacher, Character, Miner):
#
# Character
#
if domains is None:
# TODO: Clean up imports
from nucypher.config.node import NodeConfiguration
domains = (NodeConfiguration.DEFAULT_DOMAIN,)
self._work_orders = list()
Character.__init__(self,
is_me=is_me,
@ -756,12 +765,12 @@ class Ursula(Teacher, Character, Miner):
if not federated_only:
Miner.__init__(self, is_me=is_me, checksum_address=checksum_public_address)
# Access staking node via node's transacting keys TODO: Better handle ephemeral staking self ursula
# Access staking node via node's transacting keys TODO: Better handling of ephemeral staking self ursula?
blockchain_power = BlockchainPower(blockchain=self.blockchain, account=self.checksum_public_address)
self._crypto_power.consume_power_up(blockchain_power)
# Use blockchain power to substantiate stamp, instead of signing key
self.substantiate_stamp(password=password) # TODO: Derive from keyring
self.substantiate_stamp(client_password=password) # TODO: Derive from keyring
#
# ProxyRESTServer and TLSHostingPower # TODO: Maybe we want _power_ups to be public after all?
@ -826,12 +835,13 @@ class Ursula(Teacher, Character, Miner):
certificate_filepath = self._crypto_power.power_ups(TLSHostingPower).keypair.certificate_filepath
certificate = self._crypto_power.power_ups(TLSHostingPower).keypair.certificate
Teacher.__init__(self,
password=password,
domains=domains,
certificate=certificate,
certificate_filepath=certificate_filepath,
interface_signature=interface_signature,
timestamp=timestamp,
identity_evidence=identity_evidence,
decentralized_identity_evidence=decentralized_identity_evidence,
substantiate_immediately=is_me and not federated_only,
# FIXME: When is_me and not federated_only, the stamp is substantiated twice
# See line 728 above.
@ -870,18 +880,18 @@ class Ursula(Teacher, Character, Miner):
version = self.TEACHER_VERSION.to_bytes(2, "big")
interface_info = VariableLengthBytestring(bytes(self.rest_information()[0]))
identity_evidence = VariableLengthBytestring(self._evidence_of_decentralized_identity)
decentralized_identity_evidence = VariableLengthBytestring(self.decentralized_identity_evidence)
certificate = self.rest_server_certificate()
cert_vbytes = VariableLengthBytestring(certificate.public_bytes(Encoding.PEM))
domains = {bytes(domain) for domain in self.serving_domains}
domains = {domain.encode('utf-8') for domain in self.serving_domains}
as_bytes = bytes().join((version,
self.canonical_public_address,
bytes(VariableLengthBytestring.bundle(domains)),
self.timestamp_bytes(),
bytes(self._interface_signature),
bytes(identity_evidence),
bytes(decentralized_identity_evidence),
bytes(self.public_keys(SigningPower)),
bytes(self.public_keys(DecryptingPower)),
bytes(cert_vbytes),
@ -997,7 +1007,8 @@ class Ursula(Teacher, Character, Miner):
if checksum_address:
# Ensure this is the specific node we expected
if not checksum_address == potential_seed_node.checksum_public_address:
template = "This seed node has a different wallet address: {} (expected {}). Are you sure this is a seednode?"
template = "This seed node has a different wallet address: {} (expected {}). " \
" Are you sure this is a seednode?"
raise potential_seed_node.SuspiciousActivity(
template.format(potential_seed_node.checksum_public_address,
checksum_address))
@ -1030,7 +1041,7 @@ class Ursula(Teacher, Character, Miner):
domains=VariableLengthBytestring,
timestamp=(int, 4, {'byteorder': 'big'}),
interface_signature=Signature,
identity_evidence=VariableLengthBytestring,
decentralized_identity_evidence=VariableLengthBytestring,
verifying_key=(UmbralPublicKey, PUBLIC_KEY_LENGTH),
encrypting_key=(UmbralPublicKey, PUBLIC_KEY_LENGTH),
certificate=(load_pem_x509_certificate, VariableLengthBytestring, {"backend": default_backend()}),
@ -1044,6 +1055,7 @@ class Ursula(Teacher, Character, Miner):
version: int = INCLUDED_IN_BYTESTRING,
federated_only: bool = False,
) -> 'Ursula':
if version is INCLUDED_IN_BYTESTRING:
version, payload = cls.version_splitter(ursula_as_bytes, return_remainder=True)
else:
@ -1051,16 +1063,18 @@ class Ursula(Teacher, Character, Miner):
# Check version and raise IsFromTheFuture if this node is... you guessed it...
if version > cls.LEARNER_VERSION:
# TODO: Some auto-updater logic?
# Try to handle failure, even during failure, graceful degradation
# TODO: #154 - Some auto-updater logic?
try:
canonical_address, _ = BytestringSplitter(PUBLIC_ADDRESS_LENGTH)(payload, return_remainder=True)
checksum_address = to_checksum_address(canonical_address)
nickname, _ = nickname_from_seed(checksum_address)
display_name = "⇀{}↽ ({})".format(nickname, checksum_address)
display_name = cls._display_name_template.format(cls.__name__, nickname, checksum_address)
message = cls.unknown_version_message.format(display_name, version, cls.LEARNER_VERSION)
except BytestringSplittingError:
message = cls.really_unknown_version_message.format(version, cls.LEARNER_VERSION)
raise cls.IsFromTheFuture(message)
# Version stuff checked out. Moving on.
@ -1074,7 +1088,7 @@ class Ursula(Teacher, Character, Miner):
node_info['checksum_public_address'] = to_checksum_address(node_info.pop("public_address"))
domains_vbytes = VariableLengthBytestring.dispense(node_info['domains'])
node_info['domains'] = set(constant_or_bytes(d) for d in domains_vbytes)
node_info['domains'] = set(d.decode('utf-8') for d in domains_vbytes)
ursula = cls.from_public_keys(federated_only=federated_only, **node_info)
return ursula
@ -1199,7 +1213,7 @@ class Enrico(Character):
:param label: The label with which to derive the key.
:return:
"""
policy_pubkey_enc = alice.get_policy_pubkey_from_label(label)
policy_pubkey_enc = alice.get_policy_encrypting_key_from_label(label)
return cls(crypto_power_ups={SigningPower: alice.stamp.as_umbral_pubkey()},
policy_encrypting_key=policy_pubkey_enc)

4
nucypher/characters/unlawful.py
View File

@ -58,10 +58,10 @@ class Vladimir(Ursula):
rest_port=target_ursula.rest_information()[0].port,
certificate=target_ursula.rest_server_certificate(),
network_middleware=cls.network_middleware,
checksum_public_address = cls.fraud_address,
checksum_public_address=cls.fraud_address,
######### Asshole.
timestamp=target_ursula._timestamp,
interface_signature=target_ursula._interface_signature_object,
interface_signature=target_ursula._interface_signature,
#########
)

117
nucypher/cli/actions.py
View File

@ -1,14 +1,37 @@
import os
"""
This file is part of nucypher.
nucypher is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
nucypher 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import click
import os
import requests
import shutil
from twisted.logger import Logger
from typing import List
from nucypher.characters.lawful import Ursula
from nucypher.cli.config import NucypherClickConfig
from nucypher.cli.types import IPV4_ADDRESS
from nucypher.config.constants import DEFAULT_CONFIG_ROOT, USER_LOG_DIR
from nucypher.network.middleware import RestMiddleware
from nucypher.network.teachers import TEACHER_NODES
from nucypher.utilities.sandbox.constants import TEMPORARY_DOMAIN
DESTRUCTION = '''
*Permanently and irreversibly delete all* nucypher files including:
@ -33,22 +56,44 @@ LOG = Logger('cli.actions')
console_emitter = NucypherClickConfig.emit
class UnknownIPAddress(RuntimeError):
pass
def load_seednodes(min_stake: int,
federated_only: bool,
network_domains: set,
network_middleware: RestMiddleware = None,
teacher_uris: list = None
) -> List[Ursula]:
teacher_nodes = list()
# Set domains
if network_domains is None:
from nucypher.config.node import NodeConfiguration
network_domains = {NodeConfiguration.DEFAULT_DOMAIN, }
teacher_nodes = list() # Ursula
if teacher_uris is None:
# Default teacher nodes can be placed here
return teacher_nodes
for uri in teacher_uris:
teacher_node = Ursula.from_teacher_uri(teacher_uri=uri,
min_stake=min_stake,
federated_only=federated_only,
network_middleware=network_middleware)
teacher_nodes.append(teacher_node)
teacher_uris = list()
for domain in network_domains:
try:
teacher_uris = TEACHER_NODES[domain]
except KeyError:
# TODO: If this is a unknown domain, require the caller to pass a teacher URI explicitly?
if not teacher_uris:
console_emitter(message=f"No default teacher nodes exist for the specified network: {domain}")
for uri in teacher_uris:
teacher_node = Ursula.from_teacher_uri(teacher_uri=uri,
min_stake=min_stake,
federated_only=federated_only,
network_middleware=network_middleware)
teacher_nodes.append(teacher_node)
if not teacher_nodes:
console_emitter(message=f'WARNING - No Bootnodes Available')
return teacher_nodes
@ -71,24 +116,48 @@ def destroy_configuration_root(config_root=None, force=False, logs: bool = False
return config_root
def get_external_ip_from_centralized_source():
ip_request = requests.get('https://ifconfig.me/')
if ip_request.status_code == 200:
return ip_request.text
raise UnknownIPAddress(f"There was an error determining the IP address automatically. (status code {ip_request.status_code})")
def determine_external_ip_address(force: bool = False) -> str:
try:
rest_host = get_external_ip_from_centralized_source()
except UnknownIPAddress:
if force:
raise
else:
# Interactive
if not force:
if not click.confirm(f"Is this the public-facing IPv4 address ({rest_host}) you want to use for Ursula?"):
rest_host = click.prompt("Please enter Ursula's public-facing IPv4 address here:", type=IPV4_ADDRESS)
else:
console_emitter(message=f"WARNING: --force is set, using auto-detected IP '{rest_host}'", color='yellow')
return rest_host
def destroy_configuration(character_config, force: bool = False) -> None:
if not force:
click.confirm(CHARACTER_DESTRUCTION.format(name=character_config._NAME,
root=character_config.config_root), abort=True)
if not force:
click.confirm(CHARACTER_DESTRUCTION.format(name=character_config._NAME,
root=character_config.config_root), abort=True)
try:
character_config.destroy()
try:
character_config.destroy()
except FileNotFoundError:
message = 'Failed: No nucypher files found at {}'.format(character_config.config_root)
console_emitter(message=message, color='red')
character_config.log.debug(message)
raise click.Abort()
else:
message = "Deleted configuration files at {}".format(character_config.config_root)
console_emitter(message=message, color='green')
character_config.log.debug(message)
except FileNotFoundError:
message = 'Failed: No nucypher files found at {}'.format(character_config.config_root)
console_emitter(message=message, color='red')
character_config.log.debug(message)
raise click.Abort()
else:
message = "Deleted configuration files at {}".format(character_config.config_root)
console_emitter(message=message, color='green')
character_config.log.debug(message)
def forget(configuration):

28
nucypher/cli/characters/alice.py
View File

@ -1,5 +1,4 @@
import datetime
from base64 import b64encode
import click
import maya
@ -10,12 +9,11 @@ from nucypher.cli import actions, painting
from nucypher.cli.config import nucypher_click_config
from nucypher.cli.types import NETWORK_PORT, EXISTING_READABLE_FILE, EIP55_CHECKSUM_ADDRESS
from nucypher.config.characters import AliceConfiguration
from nucypher.config.constants import GLOBAL_DOMAIN
@click.command()
@click.argument('action')
@click.option('--checksum-address', help="Run with a specified account", type=EIP55_CHECKSUM_ADDRESS)
@click.option('--pay-with', help="Run with a specified account", type=EIP55_CHECKSUM_ADDRESS)
@click.option('--teacher-uri', help="An Ursula URI to start learning from (seednode)", type=click.STRING)
@click.option('--min-stake', help="The minimum stake the teacher must have to be a teacher", type=click.INT, default=0)
@click.option('--discovery-port', help="The host port to run node discovery services on", type=NETWORK_PORT, default=9151) # TODO
@ -39,7 +37,7 @@ from nucypher.config.constants import GLOBAL_DOMAIN
@nucypher_click_config
def alice(click_config,
action,
checksum_address,
pay_with,
teacher_uri,
min_stake,
http_port,
@ -71,9 +69,6 @@ def alice(click_config,
if action == 'init':
"""Create a brand-new persistent Alice"""
if not network:
raise click.BadArgumentUsage('--network is required to initialize a new configuration.')
if dev:
raise click.BadArgumentUsage("Cannot create a persistent development character")
@ -82,11 +77,11 @@ def alice(click_config,
new_alice_config = AliceConfiguration.generate(password=click_config.get_password(confirm=True),
config_root=config_root,
checksum_public_address=checksum_address,
checksum_public_address=pay_with,
rest_host="localhost",
domains={network} if network else None,
federated_only=federated_only,
no_registry=no_registry,
download_registry=no_registry,
registry_filepath=registry_filepath,
provider_uri=provider_uri)
@ -108,23 +103,26 @@ def alice(click_config,
try:
alice_config = AliceConfiguration.from_configuration_file(
filepath=config_file,
domains={network or GLOBAL_DOMAIN},
domains={network} if network else None,
network_middleware=click_config.middleware,
rest_port=discovery_port,
checksum_public_address=checksum_address,
checksum_public_address=pay_with,
provider_uri=provider_uri)
except FileNotFoundError:
return actions.handle_missing_configuration_file(character_config_class=AliceConfiguration,
config_file=config_file)
if not alice_config.federated_only:
click_config.connect_to_blockchain(character_configuration=alice_config)
if not dev:
click_config.unlock_keyring(character_configuration=alice_config)
click_config.unlock_keyring(character_configuration=alice_config,
password=click_config.get_password(confirm=False))
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
teacher_nodes = actions.load_seednodes(teacher_uris=[teacher_uri] if teacher_uri else None,
min_stake=min_stake,
federated_only=federated_only,
federated_only=alice_config.federated_only,
network_domains=alice_config.domains,
network_middleware=click_config.middleware)
# Produce
ALICE = alice_config(known_nodes=teacher_nodes, network_middleware=click_config.middleware)

34
nucypher/cli/characters/bob.py
View File

@ -4,18 +4,20 @@ from nucypher.characters.banners import BOB_BANNER
from nucypher.characters.control.emitters import IPCStdoutEmitter
from nucypher.cli import actions, painting
from nucypher.cli.config import nucypher_click_config
from nucypher.cli.types import NETWORK_PORT, EXISTING_READABLE_FILE
from nucypher.cli.types import NETWORK_PORT, EXISTING_READABLE_FILE, EIP55_CHECKSUM_ADDRESS
from nucypher.config.characters import BobConfiguration
from nucypher.config.constants import GLOBAL_DOMAIN
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
from nucypher.crypto.powers import DecryptingPower
@click.command()
@click.argument('action')
@click.option('--pay-with', help="Run with a specified account", type=EIP55_CHECKSUM_ADDRESS)
@click.option('--teacher-uri', help="An Ursula URI to start learning from (seednode)", type=click.STRING)
@click.option('--quiet', '-Q', help="Disable logging", is_flag=True)
@click.option('--min-stake', help="The minimum stake the teacher must have to be a teacher", type=click.INT, default=0)
@click.option('--discovery-port', help="The host port to run node discovery services on", type=NETWORK_PORT, default=6151) # TODO
@click.option('--discovery-port', help="The host port to run node discovery services on", type=NETWORK_PORT,
default=6151) # TODO
@click.option('--http-port', help="The host port to run Moe HTTP services on", type=NETWORK_PORT, default=11151) # TODO
@click.option('--federated-only', '-F', help="Connect only to federated nodes", is_flag=True)
@click.option('--network', help="Network Domain Name", type=click.STRING)
@ -27,7 +29,8 @@ from nucypher.crypto.powers import DecryptingPower
@click.option('--dev', '-d', help="Enable development mode", is_flag=True)
@click.option('--force', help="Don't ask for confirmation", is_flag=True)
@click.option('--dry-run', '-x', help="Execute normally without actually starting the node", is_flag=True)
@click.option('--policy-encrypting-key', help="Encrypting Public Key for Policy as hexadecimal string", type=click.STRING)
@click.option('--policy-encrypting-key', help="Encrypting Public Key for Policy as hexadecimal string",
type=click.STRING)
@click.option('--alice-verifying-key', help="Alice's verifying key as a hexadecimal string", type=click.STRING)
@click.option('--message-kit', help="The message kit unicode string encoded in base64", type=click.STRING)
@nucypher_click_config
@ -42,6 +45,7 @@ def bob(click_config,
network,
config_root,
config_file,
pay_with,
provider_uri,
registry_filepath,
dev,
@ -64,15 +68,16 @@ def bob(click_config,
if dev:
raise click.BadArgumentUsage("Cannot create a persistent development character")
if not config_root: # Flag
if not config_root: # Flag
config_root = click_config.config_file # Envvar
new_bob_config = BobConfiguration.generate(password=click_config.get_password(confirm=True),
config_root=config_root or click_config,
config_root=config_root or DEFAULT_CONFIG_ROOT,
checksum_public_address=pay_with,
rest_host="localhost",
domains={network} if network else None,
federated_only=federated_only,
no_registry=click_config.no_registry,
download_registry=click_config.no_registry,
registry_filepath=registry_filepath,
provider_uri=provider_uri)
@ -88,13 +93,15 @@ def bob(click_config,
domains={network},
provider_uri=provider_uri,
federated_only=True,
checksum_public_address=pay_with,
network_middleware=click_config.middleware)
else:
try:
bob_config = BobConfiguration.from_configuration_file(
filepath=config_file,
domains={network or GLOBAL_DOMAIN},
domains={network} if network else None,
checksum_public_address=pay_with,
rest_port=discovery_port,
provider_uri=provider_uri,
network_middleware=click_config.middleware)
@ -103,14 +110,17 @@ def bob(click_config,
config_file=config_file)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
teacher_nodes = actions.load_seednodes(teacher_uris=[teacher_uri] if teacher_uri else None,
min_stake=min_stake,
federated_only=federated_only,
federated_only=bob_config.federated_only,
network_domains=bob_config.domains,
network_middleware=click_config.middleware)
if not bob_config.federated_only:
click_config.connect_to_blockchain(character_configuration=bob_config)
if not dev:
click_config.unlock_keyring(character_configuration=bob_config)
click_config.unlock_keyring(character_configuration=bob_config,
password=click_config.get_password(confirm=False))
# Produce
BOB = bob_config(known_nodes=teacher_nodes, network_middleware=click_config.middleware)

121
nucypher/cli/characters/felix.py
View File

@ -1,17 +1,21 @@
import os
import click
from constant_sorrow.constants import NO_BLOCKCHAIN_CONNECTION
from nucypher.blockchain.eth.clients import NuCypherGethDevnetProcess
from nucypher.characters.banners import FELIX_BANNER
from nucypher.cli import actions, painting
from nucypher.cli.config import nucypher_click_config
from nucypher.cli.types import NETWORK_PORT, EXISTING_READABLE_FILE, EIP55_CHECKSUM_ADDRESS
from nucypher.config.characters import FelixConfiguration
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
@click.command()
@click.argument('action')
@click.option('--teacher-uri', help="An Ursula URI to start learning from (seednode)", type=click.STRING)
@click.option('--enode', help="An ethereum bootnode enode address to start learning from", type=click.STRING)
@click.option('--min-stake', help="The minimum stake the teacher must have to be a teacher", type=click.INT, default=0)
@click.option('--network', help="Network Domain Name", type=click.STRING)
@click.option('--host', help="The host to run Felix HTTP services on", type=click.STRING, default='127.0.0.1')
@ -19,18 +23,21 @@ from nucypher.config.characters import FelixConfiguration
@click.option('--discovery-port', help="The host port to run Felix Node Discovery services on", type=NETWORK_PORT, default=FelixConfiguration.DEFAULT_LEARNER_PORT)
@click.option('--dry-run', '-x', help="Execute normally without actually starting the node", is_flag=True, default=False)
@click.option('--provider-uri', help="Blockchain provider's URI", type=click.STRING)
@click.option('--geth', '-G', help="Run using the built-in geth node", is_flag=True)
@click.option('--config-root', help="Custom configuration directory", type=click.Path())
@click.option('--checksum-address', help="Run with a specified account", type=EIP55_CHECKSUM_ADDRESS)
@click.option('--poa', help="Inject POA middleware", is_flag=True, default=None)
@click.option('--config-file', help="Path to configuration file", type=EXISTING_READABLE_FILE)
@click.option('--db-filepath', help="The database filepath to connect to", type=click.STRING)
@click.option('--no-registry', help="Skip importing the default contract registry", is_flag=True)
@click.option('--no-password', help="Assume eth node accounts are already unlocked", is_flag=True)
@click.option('--registry-filepath', help="Custom contract registry filepath", type=EXISTING_READABLE_FILE)
@click.option('--force', help="Don't ask for confirmation", is_flag=True)
@nucypher_click_config
def felix(click_config,
action,
teacher_uri,
enode,
min_stake,
network,
host,
@ -38,6 +45,7 @@ def felix(click_config,
port,
discovery_port,
provider_uri,
geth,
config_root,
checksum_address,
poa,
@ -45,38 +53,49 @@ def felix(click_config,
db_filepath,
no_registry,
registry_filepath,
no_password,
force):
# Intro
click.clear()
if not click_config.quiet:
click.secho(FELIX_BANNER.format(checksum_address or ''))
# Stage integrated ethereum node process
# TODO: Only devnet for now
ETH_NODE = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
if geth:
ETH_NODE = NuCypherGethDevnetProcess(config_root=config_root)
provider_uri = ETH_NODE.provider_uri
if action == "init":
"""Create a brand-new Felix"""
# Validate "Init" Input
if not network:
raise click.BadArgumentUsage('--network is required to initialize a new configuration.')
# Validate "Init" Input
if not checksum_address:
raise click.BadArgumentUsage('--checksum-address is required to initialize a new Felix configuration.')
if not config_root: # Flag
config_root = DEFAULT_CONFIG_ROOT # Envvar or init-only default
# Acquire Keyring Password
if not config_root: # Flag
config_root = click_config.config_file # Envvar
new_password = click_config.get_password(confirm=True)
new_felix_config = FelixConfiguration.generate(password=new_password,
config_root=config_root,
rest_host=host,
rest_port=discovery_port,
db_filepath=db_filepath,
domains={network} if network else None,
checksum_public_address=checksum_address,
no_registry=no_registry,
registry_filepath=registry_filepath,
provider_uri=provider_uri,
poa=poa)
try:
new_felix_config = FelixConfiguration.generate(password=new_password,
config_root=config_root,
rest_host=host,
rest_port=discovery_port,
db_filepath=db_filepath,
domains={network} if network else None,
checksum_public_address=checksum_address,
download_registry=not no_registry,
registry_filepath=registry_filepath,
provider_uri=provider_uri,
provider_process=ETH_NODE,
poa=poa)
except Exception as e:
if click_config.debug:
raise
else:
click.secho(str(e), fg='red', bold=True)
raise click.Abort
# Paint Help
painting.paint_new_installation_help(new_configuration=new_felix_config,
@ -85,42 +104,64 @@ def felix(click_config,
return # <-- do not remove (conditional flow control)
#
# Authenticated Configurations
#
# Domains -> bytes | or default
domains = [bytes(network, encoding='utf-8')] if network else None
domains = [network] if network else None
# Load Felix from Configuration File with overrides
try:
felix_config = FelixConfiguration.from_configuration_file(filepath=config_file,
domains=domains,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
rest_host=host,
rest_port=port,
db_filepath=db_filepath,
poa=poa)
except FileNotFoundError:
click.secho(f"No Felix configuration file found at {config_file}. "
f"Check the filepath or run 'nucypher felix init' to create a new system configuration.")
raise click.Abort
else:
try:
# Connect to Blockchain
felix_config.connect_to_blockchain()
# Authenticate
password = click_config.get_password(confirm=False)
click_config.unlock_keyring(character_configuration=felix_config,
password=password)
# Produce Teacher Ursulas
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
teacher_nodes = actions.load_seednodes(teacher_uris=[teacher_uri] if teacher_uri else None,
min_stake=min_stake,
federated_only=False,
federated_only=felix_config.federated_only,
network_domains=felix_config.domains,
network_middleware=click_config.middleware)
# Add ETH Bootnode or Peer
if enode:
if geth:
felix_config.blockchain.interface.w3.geth.admin.addPeer(enode)
click.secho(f"Added ethereum peer {enode}")
else:
raise NotImplemented # TODO: other backends
# Produce Felix
click_config.unlock_keyring(character_configuration=felix_config)
FELIX = felix_config.produce(domains=network, known_nodes=teacher_nodes)
FELIX.make_web_app() # attach web application, but dont start service
except Exception as e:
if click_config.debug:
raise
else:
click.secho(str(e), fg='red', bold=True)
raise click.Abort
if action == "createdb": # Initialize Database
if os.path.isfile(FELIX.db_filepath):
if not force:
@ -129,7 +170,7 @@ def felix(click_config,
click.secho(f"Destroyed existing database {FELIX.db_filepath}")
FELIX.create_tables()
click.secho(f"Created new database at {FELIX.db_filepath}")
click.secho(f"\nCreated new database at {FELIX.db_filepath}", fg='green')
elif action == 'view':
token_balance = FELIX.token_balance
@ -139,20 +180,28 @@ Address .... {FELIX.checksum_public_address}
NU ......... {str(token_balance)}
ETH ........ {str(eth_balance)}
""")
return
elif action == "accounts":
accounts = FELIX.blockchain.interface.w3.eth.accounts
for account in accounts:
click.secho(account)
return
elif action == "destroy":
"""Delete all configuration files from the disk"""
return actions.destroy_configuration(character_config=felix_config, force=force)
actions.destroy_configuration(character_config=felix_config, force=force)
elif action == 'run': # Start web services
FELIX.start(host=host, port=port, web_services=not dry_run, distribution=True, crash_on_error=click_config.debug)
else: # Error
try:
click.secho("Waiting for blockchain sync...", fg='yellow')
FELIX.blockchain.sync()
FELIX.start(host=host,
port=port,
web_services=not dry_run,
distribution=True,
crash_on_error=click_config.debug)
finally:
FELIX.blockchain.disconnect()
else:
raise click.BadArgumentUsage("No such argument {}".format(action))

3
nucypher/cli/characters/moe.py
View File

@ -28,10 +28,11 @@ def moe(click_config, teacher_uri, min_stake, network, ws_port, dry_run, http_po
click.secho(MOE_BANNER)
# Teacher Ursula
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_uris = [teacher_uri] if teacher_uri else None
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
min_stake=min_stake,
federated_only=True, # TODO: hardcoded for now
network_domains={network} if network else None,
network_middleware=click_config.middleware)
# Deserialize network domain name if override passed

153
nucypher/cli/characters/ursula.py
View File

@ -16,14 +16,18 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import click
from constant_sorrow.constants import TEMPORARY_DOMAIN
from twisted.internet import stdio
from twisted.logger import Logger
import click
import socket
from constant_sorrow.constants import NO_BLOCKCHAIN_CONNECTION
from twisted.internet import stdio
from nucypher.blockchain.eth.clients import NuCypherGethDevnetProcess
from nucypher.blockchain.eth.token import NU
from nucypher.characters.banners import URSULA_BANNER
from nucypher.cli import actions, painting
from nucypher.cli.actions import UnknownIPAddress
from nucypher.cli.config import nucypher_click_config
from nucypher.cli.processes import UrsulaCommandProtocol
from nucypher.cli.types import (
@ -32,8 +36,8 @@ from nucypher.cli.types import (
EXISTING_READABLE_FILE,
STAKE_DURATION,
STAKE_EXTENSION,
STAKE_VALUE
)
STAKE_VALUE,
IPV4_ADDRESS)
from nucypher.config.characters import UrsulaConfiguration
from nucypher.utilities.sandbox.constants import (
TEMPORARY_DOMAIN,
@ -48,6 +52,7 @@ from nucypher.utilities.sandbox.constants import (
@click.option('--force', help="Don't ask for confirmation", is_flag=True)
@click.option('--lonely', help="Do not connect to seednodes", is_flag=True)
@click.option('--network', help="Network Domain Name", type=click.STRING)
@click.option('--enode', help="An ethereum bootnode enode address to start learning from", type=click.STRING)
@click.option('--teacher-uri', help="An Ursula URI to start learning from (seednode)", type=click.STRING)
@click.option('--min-stake', help="The minimum stake the teacher must have to be a teacher", type=click.INT, default=0)
@click.option('--rest-host', help="The host IP address to run Ursula network services on", type=click.STRING)
@ -60,6 +65,7 @@ from nucypher.utilities.sandbox.constants import (
@click.option('--config-root', help="Custom configuration directory", type=click.Path())
@click.option('--config-file', help="Path to configuration file", type=EXISTING_READABLE_FILE)
@click.option('--provider-uri', help="Blockchain provider's URI", type=click.STRING)
@click.option('--geth', '-G', help="Run using the built-in geth node", is_flag=True)
@click.option('--recompile-solidity', help="Compile solidity from source when making a web3 connection", is_flag=True)
@click.option('--no-registry', help="Skip importing the default contract registry", is_flag=True)
@click.option('--registry-filepath', help="Custom contract registry filepath", type=EXISTING_READABLE_FILE)
@ -78,6 +84,7 @@ def ursula(click_config,
lonely,
network,
teacher_uri,
enode,
min_stake,
rest_host,
rest_port,
@ -89,6 +96,7 @@ def ursula(click_config,
config_root,
config_file,
provider_uri,
geth,
recompile_solidity,
no_registry,
registry_filepath,
@ -117,21 +125,30 @@ def ursula(click_config,
"""
#
# Boring Setup Stuff
#
if not quiet:
log = Logger('ursula.cli')
# Validate
if federated_only and geth:
raise click.BadOptionUsage(option_name="--geth", message="Federated only cannot be used with the --geth flag")
if click_config.debug and quiet:
raise click.BadOptionUsage(option_name="quiet", message="--debug and --quiet cannot be used at the same time.")
#
# Boring Setup Stuff
#
# Stage integrated ethereum node process TODO: Only devnet for now
ETH_NODE = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
if geth:
ETH_NODE = NuCypherGethDevnetProcess(config_root=config_root)
provider_uri = ETH_NODE.provider_uri
if not click_config.json_ipc and not click_config.quiet:
click.secho(URSULA_BANNER.format(checksum_address or ''))
#
# Pre-Launch Warnings
#
if not click_config.quiet:
if dev:
click.secho("WARNING: Running in Development mode", fg='yellow')
@ -139,24 +156,26 @@ def ursula(click_config,
click.secho("WARNING: Force is enabled", fg='yellow')
#
# Unauthenticated Configurations & Un-configured Ursula Control
# Unauthenticated & Un-configured Ursula Configuration
#
if action == "init":
"""Create a brand-new persistent Ursula"""
if not network:
raise click.BadArgumentUsage('--network is required to initialize a new configuration.')
if dev:
raise click.BadArgumentUsage("Cannot create a persistent development character")
if not config_root: # Flag
config_root = click_config.config_file # Envvar
# Attempts to automatically get the external IP from ifconfig.me
# If the request fails, it falls back to the standard process.
if not rest_host:
rest_host = click.prompt("Enter Ursula's public-facing IPv4 address") # TODO: Remove this step
rest_host = actions.determine_external_ip_address(force=force)
ursula_config = UrsulaConfiguration.generate(password=click_config.get_password(confirm=True),
new_password = click_config.get_password(confirm=True)
ursula_config = UrsulaConfiguration.generate(password=new_password,
config_root=config_root,
rest_host=rest_host,
rest_port=rest_port,
@ -164,8 +183,9 @@ def ursula(click_config,
domains={network} if network else None,
federated_only=federated_only,
checksum_public_address=checksum_address,
no_registry=federated_only or no_registry,
download_registry=federated_only or no_registry,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
poa=poa)
@ -176,32 +196,42 @@ def ursula(click_config,
return
#
# Configured Ursulas
# Generate Configuration
#
# Development Configuration
if dev:
# TODO: Spawn POA development blockchain with geth --dev
# dev_geth_process = NuCypherGethDevProcess()
# dev_geth_process.deploy()
# dev_geth_process.start()
# ETH_NODE = dev_geth_process
# provider_uri = ETH_NODE.provider_uri
ursula_config = UrsulaConfiguration(dev_mode=True,
domains={TEMPORARY_DOMAIN},
poa=poa,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
checksum_public_address=checksum_address,
federated_only=federated_only,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath)
# Authenticated Configurations
# Production Configurations
else:
# Domains -> bytes | or default
domains = set(bytes(network, encoding='utf-8')) if network else None
domains = {network} if network else None
# Load Ursula from Configuration File
try:
ursula_config = UrsulaConfiguration.from_configuration_file(filepath=config_file,
domains=domains,
registry_filepath=registry_filepath,
provider_process=ETH_NODE,
provider_uri=provider_uri,
rest_host=rest_host,
rest_port=rest_port,
@ -211,19 +241,27 @@ def ursula(click_config,
except FileNotFoundError:
return actions.handle_missing_configuration_file(character_config_class=UrsulaConfiguration,
config_file=config_file)
except Exception as e:
if click_config.debug:
raise
else:
click.secho(str(e), fg='red', bold=True)
raise click.Abort
click_config.unlock_keyring(character_configuration=ursula_config)
#
# Configured Pre-Authentication Actions
#
# Handle destruction *before* network bootstrap and character initialization below
if action == "destroy":
"""Delete all configuration files from the disk"""
if dev:
message = "'nucypher ursula destroy' cannot be used in --dev mode"
message = "'nucypher ursula destroy' cannot be used in --dev mode - There is nothing to destroy."
raise click.BadOptionUsage(option_name='--dev', message=message)
return actions.destroy_configuration(character_config=ursula_config, force=force)
#
# Connect to Blockchain (Non-Federated)
# Connect to Blockchain
#
if not ursula_config.federated_only:
@ -232,6 +270,17 @@ def ursula(click_config,
click_config.ursula_config = ursula_config # Pass Ursula's config onto staking sub-command
#
# Authenticate
#
if dev:
# Development accounts are always unlocked and use one-time random keys.
password = None
else:
password = click_config.get_password()
click_config.unlock_keyring(character_configuration=ursula_config, password=password)
#
# Launch Warnings
#
@ -239,18 +288,33 @@ def ursula(click_config,
if ursula_config.federated_only:
click_config.emit(message="WARNING: Running in Federated mode", color='yellow')
# Seed - Step 1
teacher_uris = [teacher_uri] if teacher_uri else list()
teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris,
#
# Seed
#
teacher_nodes = actions.load_seednodes(teacher_uris=[teacher_uri] if teacher_uri else None,
min_stake=min_stake,
federated_only=ursula_config.federated_only,
network_domains=ursula_config.domains,
network_middleware=click_config.middleware)
# Produce - Step 2
URSULA = ursula_config(known_nodes=teacher_nodes, lonely=lonely)
# Add ETH Bootnode or Peer
if enode:
if geth:
ursula_config.blockchain.interface.w3.geth.admin.addPeer(enode)
click.secho(f"Added ethereum peer {enode}")
else:
raise NotImplemented # TODO: other backends
#
# Action Switch
# Produce
#
URSULA = ursula_config(password=password, known_nodes=teacher_nodes, lonely=lonely)
del password # ... under the rug
#
# Authenticated Action Switch
#
if action == 'run':
@ -266,7 +330,7 @@ def ursula(click_config,
# Ursula Deploy Warnings
click_config.emit(
message="Connecting to {}".format(','.join(str(d, encoding='utf-8') for d in ursula_config.domains)),
message="Connecting to {}".format(','.join(ursula_config.domains)),
color='green',
bold=True)
@ -280,7 +344,7 @@ def ursula(click_config,
stdio.StandardIO(UrsulaCommandProtocol(ursula=URSULA))
if dry_run:
return # <-- ABORT -X (Last Chance)
return # <-- ABORT - (Last Chance)
# Run - Step 3
node_deployer = URSULA.get_deployer()
@ -311,6 +375,20 @@ def ursula(click_config,
elif action == "view":
"""Paint an existing configuration to the console"""
if not URSULA.federated_only:
click.secho("BLOCKCHAIN ----------\n")
painting.paint_contract_status(click_config=click_config, ursula_config=ursula_config)
current_block = URSULA.blockchain.interface.w3.eth.blockNumber
click.secho(f'Block # {current_block}')
click.secho(f'NU Balance: {URSULA.token_balance}')
click.secho(f'ETH Balance: {URSULA.eth_balance}')
click.secho(f'Current Gas Price {URSULA.blockchain.interface.w3.eth.gasPrice}')
# TODO: Verbose status
# click.secho(f'{URSULA.blockchain.interface.w3.eth.getBlock(current_block)}')
click.secho("CONFIGURATION --------")
response = UrsulaConfiguration._read_configuration_file(filepath=config_file or ursula_config.config_file_location)
return click_config.emit(response=response)
@ -323,8 +401,9 @@ def ursula(click_config,
# List Only
if list_:
if not URSULA.stakes:
click.echo(f"There are no existing stakes for {URSULA.checksum_public_address}")
painting.paint_stakes(stakes=URSULA.stakes)
click.echo(f"There are no active stakes for {URSULA.checksum_public_address}")
else:
painting.paint_stakes(stakes=URSULA.stakes)
return
# Divide Only
@ -332,8 +411,8 @@ def ursula(click_config,
"""Divide an existing stake by specifying the new target value and end period"""
# Validate
if len(URSULA.stakes) == 0:
click.secho("There are no active stakes for {}".format(URSULA.checksum_public_address))
if not URSULA.stakes:
click.echo(f"There are no active stakes for {URSULA.checksum_public_address}")
return
# Selection
@ -391,7 +470,7 @@ def ursula(click_config,
# Gather stake value
if not value:
min_locked = NU(URSULA.miner_agent.economics.minimum_allowed_locked, 'NuNit')
min_locked = NU(URSULA.economics.minimum_allowed_locked, 'NuNit')
value = click.prompt(f"Enter stake value", type=STAKE_VALUE, default=min_locked)
else:
value = NU(int(value), 'NU')

46
nucypher/cli/config.py
View File

@ -63,6 +63,9 @@ class NucypherClickConfig:
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# You guessed it
self.debug = False
# Logging
self.quiet = False
self.log = Logger(self.__class__.__name__)
@ -78,10 +81,17 @@ class NucypherClickConfig:
try:
character_configuration.connect_to_blockchain(recompile_contracts=recompile_contracts)
character_configuration.connect_to_contracts()
except EthereumContractRegistry.NoRegistry:
message = "No contract registry found; Did you mean to pass --federated-only?"
raise EthereumContractRegistry.NoRegistry(message)
except EthereumContractRegistry.NoRegistry:
_registry_filepath = EthereumContractRegistry.from_latest_publication()
except Exception as e:
if self.debug:
raise
click.secho(str(e), fg='red', bold=True)
raise click.Abort()
# Success
else:
self.blockchain = character_configuration.blockchain
self.accounts = self.blockchain.interface.w3.eth.accounts
@ -96,14 +106,28 @@ class NucypherClickConfig:
self.__keyring_password = keyring_password
return self.__keyring_password
def unlock_keyring(self, character_configuration: NodeConfiguration):
try: # Unlock Keyring
if not self.quiet:
self.emit(message='Decrypting keyring...', color='blue')
character_configuration.keyring.unlock(password=self.get_password()) # Takes ~3 seconds, ~1GB Ram
def unlock_keyring(self,
password: str,
character_configuration: NodeConfiguration):
if not self.quiet:
self.emit(message='Decrypting NuCypher keyring...', color='yellow')
if character_configuration.dev_mode:
return True # Dev accounts are always unlocked
# NuCypher
try:
character_configuration.keyring.unlock(password=password) # Takes ~3 seconds, ~1GB Ram
except CryptoError:
raise character_configuration.keyring.AuthenticationFailed
# Ethereum Client # TODO : Integrate with Powers API
if not character_configuration.federated_only:
self.emit(message='Decrypting Ethereum Node Keyring...', color='yellow')
character_configuration.blockchain.interface.unlock_account(address=character_configuration.checksum_public_address,
password=password)
@classmethod
def attach_emitter(cls, emitter) -> None:
cls.__emitter = emitter
@ -121,14 +145,14 @@ class NucypherDeployerClickConfig(NucypherClickConfig):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def collect_deployment_secrets(self) -> Secrets:
# Deployment Environment Variables
self.miner_escrow_deployment_secret = os.environ.get("NUCYPHER_MINER_ESCROW_SECRET")
self.miner_escrow_deployment_secret = os.environ.get("NUCYPHER_MINERS_ESCROW_SECRET")
self.policy_manager_deployment_secret = os.environ.get("NUCYPHER_POLICY_MANAGER_SECRET")
self.user_escrow_proxy_deployment_secret = os.environ.get("NUCYPHER_USER_ESCROW_PROXY_SECRET")
self.mining_adjudicator_deployment_secret = os.environ.get("NUCYPHER_MINING_ADJUDICATOR_SECRET")
def collect_deployment_secrets(self) -> Secrets:
if not self.miner_escrow_deployment_secret:
self.miner_escrow_deployment_secret = click.prompt('Enter MinerEscrow Deployment Secret',
hide_input=True,

264
nucypher/cli/deploy.py
View File

@ -14,17 +14,19 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import json
import os
import time
import click
import maya
from web3.exceptions import TimeExhausted
from nucypher.blockchain.eth.actors import Deployer
from nucypher.blockchain.eth.agents import NucypherTokenAgent
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.blockchain.eth.interfaces import BlockchainInterface
from nucypher.blockchain.eth.clients import NuCypherGethDevnetProcess
from nucypher.blockchain.eth.registry import EthereumContractRegistry
from nucypher.characters.banners import NU_BANNER
from nucypher.cli.config import nucypher_deployer_config
from nucypher.cli.types import EIP55_CHECKSUM_ADDRESS, EXISTING_READABLE_FILE
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
@ -36,6 +38,9 @@ from nucypher.config.constants import DEFAULT_CONFIG_ROOT
@click.option('--poa', help="Inject POA middleware", is_flag=True)
@click.option('--no-compile', help="Disables solidity contract compilation", is_flag=True)
@click.option('--provider-uri', help="Blockchain provider's URI", type=click.STRING)
@click.option('--geth', '-G', help="Run using the built-in geth node", is_flag=True)
@click.option('--sync/--no-sync', default=True)
@click.option('--enode', help="An ethereum bootnode enode address to start learning from", type=click.STRING)
@click.option('--config-root', help="Custom configuration directory", type=click.Path())
@click.option('--contract-name', help="Deploy a single contract by name", type=click.STRING)
@click.option('--deployer-address', help="Deployer's checksum address", type=EIP55_CHECKSUM_ADDRESS)
@ -50,6 +55,8 @@ def deploy(click_config,
action,
poa,
provider_uri,
geth,
enode,
deployer_address,
contract_name,
allocation_infile,
@ -60,96 +67,243 @@ def deploy(click_config,
amount,
recipient_address,
config_root,
sync,
force):
"""Manage contract and registry deployment"""
# Ensure config root exists, because we need a default place to put outfiles.
ETH_NODE = None
#
# Validate
#
# Ensure config root exists, because we need a default place to put output files.
config_root = config_root or DEFAULT_CONFIG_ROOT
if not os.path.exists(config_root):
os.makedirs(config_root)
# Establish a contract Registry
#
# Connect to Blockchain
#
# Establish a contract registry from disk if specified
registry, registry_filepath = None, (registry_outfile or registry_infile)
if registry_filepath is not None:
registry = EthereumContractRegistry(registry_filepath=registry_filepath)
# Connect to Blockchain
if geth:
# Spawn geth child process
ETH_NODE = NuCypherGethDevnetProcess(config_root=config_root)
ETH_NODE.ensure_account_exists(password=click_config.get_password(confirm=True))
if not ETH_NODE.initialized:
ETH_NODE.initialize_blockchain()
ETH_NODE.start() # TODO: Graceful shutdown
provider_uri = ETH_NODE.provider_uri
# Deployment-tuned blockchain connection
blockchain = Blockchain.connect(provider_uri=provider_uri,
poa=poa,
registry=registry,
deployer=True,
compile=not no_compile,
poa=poa)
deployer=True,
fetch_registry=False,
sync=sync)
#
# Deployment Actor
#
# OK - Let's init a Deployment actor
if not deployer_address:
etherbase = blockchain.interface.w3.eth.accounts[0]
deployer_address = etherbase # TODO: Make this required instead, perhaps interactive
for index, address in enumerate(blockchain.interface.w3.eth.accounts):
click.secho(f"{index} --- {address}")
choices = click.IntRange(0, len(blockchain.interface.w3.eth.accounts))
deployer_address_index = click.prompt("Select deployer address", default=0, type=choices)
deployer_address = blockchain.interface.w3.eth.accounts[deployer_address_index]
click.confirm("Deployer Address is {} - Continue?".format(deployer_address), abort=True)
# Verify Address
if not force:
click.confirm("Selected {} - Continue?".format(deployer_address), abort=True)
deployer = Deployer(blockchain=blockchain, deployer_address=deployer_address)
# The Big Three
if action == "contracts":
secrets = click_config.collect_deployment_secrets()
# Verify ETH Balance
click.secho(f"\n\nDeployer ETH balance: {deployer.eth_balance}")
if deployer.eth_balance == 0:
click.secho("Deployer address has no ETH.", fg='red', bold=True)
raise click.Abort()
if not blockchain.interface.is_local:
# (~ dev mode; Assume accounts are already unlocked)
password = click.prompt("Enter ETH node password", hide_input=True)
blockchain.interface.w3.geth.personal.unlockAccount(deployer_address, password)
# Add ETH Bootnode or Peer
if enode:
if geth:
blockchain.interface.w3.geth.admin.addPeer(enode)
click.secho(f"Added ethereum peer {enode}")
else:
raise NotImplemented # TODO: other backends
#
# Action switch
#
if action == 'upgrade':
if not contract_name:
raise click.BadArgumentUsage(message="--contract-name is required when using --upgrade")
existing_secret = click.prompt('Enter existing contract upgrade secret', hide_input=True)
new_secret = click.prompt('Enter new contract upgrade secret', hide_input=True, confirmation_prompt=True)
deployer.upgrade_contract(contract_name=contract_name,
existing_plaintext_secret=existing_secret,
new_plaintext_secret=new_secret)
elif action == 'rollback':
existing_secret = click.prompt('Enter existing contract upgrade secret', hide_input=True)
new_secret = click.prompt('Enter new contract upgrade secret', hide_input=True, confirmation_prompt=True)
deployer.rollback_contract(contract_name=contract_name,
existing_plaintext_secret=existing_secret,
new_plaintext_secret=new_secret)
elif action == "contracts":
registry_filepath = deployer.blockchain.interface.registry.filepath
if os.path.isfile(registry_filepath):
click.secho(f"\nThere is an existing contract registry at {registry_filepath}.\n"
f"Did you mean 'nucypher-deploy upgrade'?\n", fg='yellow')
click.confirm("Optionally, destroy existing local registry and continue?", abort=True)
click.confirm(f"Confirm deletion of contract registry '{registry_filepath}'?", abort=True)
os.remove(registry_filepath)
#
# Deploy Single Contract
#
if contract_name:
# TODO: Handle secret collection for single contract deployment
try:
deployer_func = deployer.deployers[contract_name]
except KeyError:
message = f"No such contract {contract_name}. Available contracts are {deployer.deployers.keys()}"
click.secho(message, fg='red', bold=True)
raise click.Abort()
else:
# Deploy single contract
_txs, _agent = deployer_func()
# TODO: Painting for single contract deployment
if ETH_NODE:
ETH_NODE.stop()
return
#
# Stage Deployment
#
# Track tx hashes, and new agents
__deployment_transactions = dict()
__deployment_agents = dict()
if force:
deployer.blockchain.interface.registry._destroy()
secrets = click_config.collect_deployment_secrets()
click.clear()
click.secho(NU_BANNER)
try:
txhashes, agents = deployer.deploy_network_contracts(miner_secret=bytes(secrets.miner_secret, encoding='utf-8'),
policy_secret=bytes(secrets.policy_secret, encoding='utf-8'),
adjudicator_secret=bytes(secrets.mining_adjudicator_secret, encoding='utf-8'))
except BlockchainInterface.InterfaceError:
raise # TODO: Handle registry management here (contract may already exist)
else:
__deployment_transactions.update(txhashes)
w3 = deployer.blockchain.interface.w3
click.secho(f"Current Time ........ {maya.now().iso8601()}")
click.secho(f"Web3 Provider ....... {deployer.blockchain.interface.provider_uri}")
click.secho(f"Block ............... {w3.eth.blockNumber}")
click.secho(f"Gas Price ........... {w3.eth.gasPrice}")
# User Escrow Proxy
deployer.deploy_escrow_proxy(secret=bytes(secrets.escrow_proxy_secret, encoding='utf-8'))
click.secho("Deployed!", fg='green', bold=True)
click.secho(f"Deployer Address .... {deployer.checksum_public_address}")
click.secho(f"ETH ................. {deployer.eth_balance}")
click.secho(f"CHAIN ID............. {deployer.blockchain.interface.chain_id}")
click.secho(f"CHAIN................ {deployer.blockchain.interface.chain_name}")
#
# Deploy Single Contract
#
if contract_name:
try:
deployer_func = deployer.deployers[contract_name]
except KeyError:
message = "No such contract {}. Available contracts are {}".format(contract_name, deployer.deployers.keys())
click.secho(message, fg='red', bold=True)
# Ask - Last chance to gracefully abort
if not force:
click.secho("\nDeployment successfully staged. Take a deep breath. \n", fg='green')
if click.prompt("Type 'DEPLOY' to continue") != 'DEPLOY':
raise click.Abort()
else:
_txs, _agent = deployer_func()
registry_outfile = deployer.blockchain.interface.registry.filepath
click.secho('\nDeployment Transaction Hashes for {}'.format(registry_outfile), bold=True, fg='blue')
# Delay - Last chance to crash and abort
click.secho(f"Starting deployment in 3 seconds...", fg='red')
time.sleep(1)
click.secho(f"2...", fg='yellow')
time.sleep(1)
click.secho(f"1...", fg='green')
time.sleep(1)
click.secho(f"Deploying...", bold=True)
#
# DEPLOY < -------
#
txhashes, deployers = deployer.deploy_network_contracts(miner_secret=secrets.miner_secret,
policy_secret=secrets.policy_secret,
adjudicator_secret=secrets.mining_adjudicator_secret,
user_escrow_proxy_secret=secrets.escrow_proxy_secret)
# Success
__deployment_transactions.update(txhashes)
#
# Paint
#
total_gas_used = 0 # TODO: may be faulty
for contract_name, transactions in __deployment_transactions.items():
heading = '\n{} ({})'.format(contract_name, agents[contract_name].contract_address)
# Paint heading
heading = '\n{} ({})'.format(contract_name, deployers[contract_name].contract_address)
click.secho(heading, bold=True)
click.echo('*'*(42+3+len(contract_name)))
total_gas_used = 0
for tx_name, txhash in transactions.items():
receipt = deployer.blockchain.wait_for_receipt(txhash=txhash)
total_gas_used += int(receipt['gasUsed'])
# Wait for inclusion in the blockchain
try:
receipt = deployer.blockchain.wait_for_receipt(txhash=txhash)
except TimeExhausted:
raise # TODO: Option to wait longer or retry
# Examine Receipt # TODO: This currently cannot receive failed transactions
if receipt['status'] == 1:
click.secho("OK", fg='green', nl=False, bold=True)
else:
click.secho("Failed", fg='red', nl=False, bold=True)
# Accumulate gas
total_gas_used += int(receipt['gasUsed'])
# Paint
click.secho(" | {}".format(tx_name), fg='yellow', nl=False)
click.secho(" | {}".format(txhash.hex()), fg='yellow', nl=False)
click.secho(" ({} gas)".format(receipt['cumulativeGasUsed']))
click.secho("Block #{} | {}\n".format(receipt['blockNumber'], receipt['blockHash'].hex()))
click.secho("Cumulative Gas Consumption: {} gas\n".format(total_gas_used), bold=True, fg='blue')
# Paint outfile paths
click.secho("Cumulative Gas Consumption: {} gas".format(total_gas_used), bold=True, fg='blue')
registry_outfile = deployer.blockchain.interface.registry.filepath
click.secho('Generated registry {}'.format(registry_outfile), bold=True, fg='blue')
# Save transaction metadata
receipts_filepath = deployer.save_deployment_receipts(transactions=__deployment_transactions)
click.secho(f"Saved deployment receipts to {receipts_filepath}", fg='blue', bold=True)
#
# Publish Contract Registry
#
if not deployer.blockchain.interface.is_local:
if click.confirm("Publish new contract registry?"):
try:
response = registry.publish() # TODO: Handle non-200 response and dehydrate
except EthereumContractRegistry.RegistryError as e:
click.secho("Registry publication failed.", fg='red', bold=True)
click.secho(str(e))
raise click.Abort()
click.secho(f"Published new contract registry.", fg='green')
elif action == "allocations":
if not allocation_infile:
@ -163,7 +317,16 @@ def deploy(click_config,
click.confirm(f"Transfer {amount} from {token_agent.contract_address} to {recipient_address}?", abort=True)
txhash = token_agent.transfer(amount=amount, sender_address=token_agent.contract_address, target_address=recipient_address)
click.secho(f"OK | {txhash}")
return
elif action == "publish-registry":
registry = deployer.blockchain.interface.registry
click.confirm(f"Publish {registry.filepath} to GitHub (Authentication Required)?", abort=True)
try:
response = registry.publish() # TODO: Handle non-200 response and dehydrate
except EthereumContractRegistry.RegistryError as e:
click.secho(str(e))
raise click.Abort()
click.secho(f"Published new contract registry.", fg='green')
elif action == "destroy-registry":
registry_filepath = deployer.blockchain.interface.registry.filepath
@ -173,3 +336,6 @@ def deploy(click_config,
else:
raise click.BadArgumentUsage(message=f"Unknown action '{action}'")
if ETH_NODE:
ETH_NODE.stop()

2
nucypher/cli/main.py
View File

@ -98,7 +98,7 @@ def nucypher_cli(click_config,
# Global Warnings
if click_config.verbose:
click_config.emit("Verbose mode is enabled", color='blue')
click_config.emit(message="Verbose mode is enabled", color='blue')
@click.command()

26
nucypher/cli/painting.py
View File

@ -177,14 +177,14 @@ def paint_known_nodes(ursula) -> None:
def paint_contract_status(ursula_config, click_config):
contract_payload = """
| NuCypher ETH Contracts |
| NuCypher ETH Contracts |
Provider URI ............. {provider_uri}
Registry Path ............ {registry_filepath}
Provider URI ............. {provider_uri}
Registry Path ............ {registry_filepath}
NucypherToken ............ {token}
MinerEscrow .............. {escrow}
PolicyManager ............ {manager}
NucypherToken ............ {token}
MinerEscrow .............. {escrow}
PolicyManager ............ {manager}
""".format(provider_uri=ursula_config.blockchain.interface.provider_uri,
registry_filepath=ursula_config.blockchain.interface.registry.filepath,
@ -195,15 +195,15 @@ def paint_contract_status(ursula_config, click_config):
click.secho(contract_payload)
network_payload = """
| Blockchain Network |
| Blockchain Network |
Current Period ........... {period}
Gas Price ................ {gas_price}
Active Staking Ursulas ... {ursulas}
Current Period ........... {period}
Gas Price ................ {gas_price}
Active Staking Ursulas ... {ursulas}
""".format(period=click_config.miner_agent.get_current_period(),
gas_price=click_config.blockchain.interface.w3.eth.gasPrice,
ursulas=click_config.miner_agent.get_miner_population())
""".format(period=ursula_config.miner_agent.get_current_period(),
gas_price=ursula_config.blockchain.interface.w3.eth.gasPrice,
ursulas=ursula_config.miner_agent.get_miner_population())
click.secho(network_payload)

8
nucypher/cli/types.py
View File

@ -18,7 +18,7 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
from ipaddress import ip_address
import click
from eth_utils import is_checksum_address
from eth_utils import is_checksum_address, to_checksum_address
from nucypher.blockchain.economics import TokenEconomics
from nucypher.blockchain.eth.token import NU
@ -28,9 +28,7 @@ class ChecksumAddress(click.ParamType):
name = 'checksum_public_address'
def convert(self, value, param, ctx):
if is_checksum_address(value):
return value
self.fail('{} is not a valid EIP-55 checksum address'.format(value, param, ctx))
return to_checksum_address(value=value) # TODO: More robust validation here?
class IPv4Address(click.ParamType):
@ -48,7 +46,7 @@ class IPv4Address(click.ParamType):
token_economics = TokenEconomics()
# Staking
STAKE_DURATION = click.IntRange(min=token_economics.minimum_locked_periods, max=token_economics.maximum_locked_periods, clamp=False)
STAKE_DURATION = click.IntRange(min=token_economics.minimum_locked_periods, clamp=False)
STAKE_EXTENSION = click.IntRange(min=1, max=token_economics.maximum_allowed_locked, clamp=False)
STAKE_VALUE = click.IntRange(min=NU(token_economics.minimum_allowed_locked, 'NuNit').to_tokens(),
max=NU(token_economics.maximum_allowed_locked, 'NuNit').to_tokens(), clamp=False)

12
nucypher/config/constants.py
View File

@ -29,6 +29,7 @@ from nucypher.blockchain.eth import sol
# Base Filepaths
BASE_DIR = abspath(dirname(dirname(nucypher.__file__)))
DEPLOY_DIR = os.path.join(BASE_DIR, 'deploy')
PROJECT_ROOT = abspath(dirname(nucypher.__file__))
CONTRACT_ROOT = os.path.join(abspath(dirname(sol.__file__)), 'source', 'contracts')
@ -44,17 +45,6 @@ SeednodeMetadata = namedtuple('seednode', ['checksum_public_address', 'rest_host
SEEDNODES = tuple()
"""
=======
DOMAINS
=======
If this domain is among those being learned or served, then domain checking is skipped.
A Learner learning about the GLOBAL_DOMAIN will learn about all nodes.
A Teacher serving the GLOBAL_DOMAIN will teach about all nodes.
"""
GLOBAL_DOMAIN = b'GLOBAL_DOMAIN'
# Sentry
NUCYPHER_SENTRY_PUBLIC_KEY = "d8af7c4d692e4692a455328a280d845e"
NUCYPHER_SENTRY_USER_ID = '1310685'

26
nucypher/config/keyring.py
View File

@ -18,10 +18,11 @@ import base64
import contextlib
import json
import os
import shutil
import stat
from json import JSONDecodeError
from typing import ClassVar, Tuple, Callable, Union, Dict, List
from constant_sorrow.constants import KEYRING_LOCKED
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.backends.openssl.ec import _EllipticCurvePrivateKey
@ -37,14 +38,19 @@ from eth_utils import to_checksum_address, is_checksum_address
from nacl.exceptions import CryptoError
from nacl.secret import SecretBox
from twisted.logger import Logger
from typing import ClassVar, Tuple, Callable, Union, Dict, List
from umbral.keys import UmbralPrivateKey, UmbralPublicKey, UmbralKeyingMaterial, derive_key_from_password
from constant_sorrow.constants import KEYRING_LOCKED
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
from nucypher.crypto.api import generate_self_signed_certificate
from nucypher.crypto.constants import BLAKE2B
from nucypher.crypto.powers import SigningPower, DecryptingPower, KeyPairBasedPower, DerivedKeyBasedPower
from nucypher.crypto.powers import (
SigningPower,
DecryptingPower,
KeyPairBasedPower,
DerivedKeyBasedPower,
BlockchainPower
)
from nucypher.network.server import TLSHostingPower
FILE_ENCODING = 'utf-8'
@ -66,6 +72,10 @@ __WRAPPING_KEY_INFO = b'NuCypher-KeyWrap'
__HKDF_HASH_ALGORITHM = BLAKE2B
class PrivateKeyExistsError(RuntimeError):
pass
def unlock_required(func):
"""Method decorator"""
@ -123,6 +133,8 @@ def _write_private_keyfile(keypath: str,
---------------------------------------------------------------------
"""
if os.path.isfile(keypath):
raise PrivateKeyExistsError(f"Private keyfile {keypath} already exists.")
try:
keyfile_descriptor = os.open(keypath, flags=__PRIVATE_FLAGS, mode=__PRIVATE_MODE)
finally:
@ -494,6 +506,9 @@ class NucypherKeyring:
keying_material = SecretBox(wrap_key).decrypt(key_data['key'])
new_cryptopower = power_class(keying_material=keying_material)
elif power_class is BlockchainPower:
new_cryptopower = power_class(blockchain=Blockchain.connect(), account=self.checksum_address)
else:
failure_message = "{} is an invalid type for deriving a CryptoPower.".format(power_class.__name__)
raise ValueError(failure_message)
@ -530,7 +545,7 @@ class NucypherKeyring:
if curve is None:
curve = cls.__DEFAULT_TLS_CURVE
if checksum_address is not None and not is_checksum_address(checksum_address):
if checksum_address and not is_checksum_address(checksum_address):
raise ValueError(f"{checksum_address} is not a valid ethereum checksum address")
_base_filepaths = cls._generate_base_filepaths(keyring_root=keyring_root)
@ -595,6 +610,7 @@ class NucypherKeyring:
rootkey_path = _write_private_keyfile(keypath=__key_filepaths['root'],
key_data=encrypting_key_metadata,
serializer=cls._private_key_serializer)
sigkey_path = _write_private_keyfile(keypath=__key_filepaths['signing'],
key_data=signing_key_metadata,
serializer=cls._private_key_serializer)

195
nucypher/config/node.py
View File

@ -16,6 +16,7 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import binascii
import json
import os
import secrets
@ -25,7 +26,6 @@ from json import JSONDecodeError
from tempfile import TemporaryDirectory
from typing import List, Set
import binascii
import eth_utils
from constant_sorrow.constants import (
UNINITIALIZED_CONFIGURATION,
@ -37,12 +37,14 @@ from constant_sorrow.constants import (
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurve
from cryptography.x509 import Certificate
from eth_utils import to_checksum_address, is_checksum_address
from twisted.logger import Logger
from umbral.signing import Signature
from nucypher.blockchain.eth.agents import PolicyAgent, MinerAgent, NucypherTokenAgent
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.config.constants import DEFAULT_CONFIG_ROOT, BASE_DIR, GLOBAL_DOMAIN
from nucypher.blockchain.eth.registry import EthereumContractRegistry
from nucypher.config.constants import DEFAULT_CONFIG_ROOT, BASE_DIR
from nucypher.config.keyring import NucypherKeyring
from nucypher.config.storages import NodeStorage, ForgetfulNodeStorage, LocalFileBasedNodeStorage
from nucypher.crypto.powers import CryptoPowerUp, CryptoPower
@ -65,7 +67,7 @@ class NodeConfiguration(ABC):
DEFAULT_OPERATING_MODE = 'decentralized'
# Domains
DEFAULT_DOMAIN = GLOBAL_DOMAIN
DEFAULT_DOMAIN = b'goerli'
# Serializers
NODE_SERIALIZER = binascii.hexlify
@ -77,7 +79,7 @@ class NodeConfiguration(ABC):
TEMP_CONFIGURATION_DIR_PREFIX = "nucypher-tmp-"
# Blockchain
DEFAULT_PROVIDER_URI = 'tester://pyevm'
DEFAULT_PROVIDER_URI = 'http://localhost:8545'
# Registry
__REGISTRY_NAME = 'contract_registry.json'
@ -96,6 +98,9 @@ class NodeConfiguration(ABC):
class InvalidConfiguration(ConfigurationError):
pass
class NoConfigurationRoot(InvalidConfiguration):
pass
def __init__(self,
# Base
@ -142,11 +147,12 @@ class NodeConfiguration(ABC):
# Blockchain
poa: bool = False,
provider_uri: str = None,
provider_process = None,
# Registry
registry_source: str = None,
registry_filepath: str = None,
import_seed_registry: bool = False # TODO: needs cleanup
download_registry: bool = True
) -> None:
@ -172,12 +178,7 @@ class NodeConfiguration(ABC):
self.keyring_dir = keyring_dir or UNINITIALIZED_CONFIGURATION
# Contract Registry
if import_seed_registry is True:
registry_source = self.REGISTRY_SOURCE
if not os.path.isfile(registry_source):
message = "Seed contract registry does not exist at path {}.".format(registry_filepath)
self.log.debug(message)
raise RuntimeError(message)
self.download_registry = download_registry
self.__registry_source = registry_source or self.REGISTRY_SOURCE
self.registry_filepath = registry_filepath or UNINITIALIZED_CONFIGURATION
@ -247,8 +248,9 @@ class NodeConfiguration(ABC):
#
self.poa = poa
self.provider_uri = provider_uri or self.DEFAULT_PROVIDER_URI
self.provider_process = provider_process or NO_BLOCKCHAIN_CONNECTION
self.blockchain = NO_BLOCKCHAIN_CONNECTION
self.blockchain = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
self.accounts = NO_BLOCKCHAIN_CONNECTION
self.token_agent = NO_BLOCKCHAIN_CONNECTION
self.miner_agent = NO_BLOCKCHAIN_CONNECTION
@ -257,6 +259,7 @@ class NodeConfiguration(ABC):
#
# Development Mode
#
if dev_mode:
# Ephemeral dev settings
@ -269,29 +272,27 @@ class NodeConfiguration(ABC):
password = ''.join(secrets.choice(alphabet) for _ in range(32))
# Auto-initialize
self.initialize(password=password, import_registry=import_seed_registry)
self.initialize(password=password, download_registry=download_registry)
def __call__(self, *args, **kwargs):
return self.produce(*args, **kwargs)
@classmethod
def generate(cls, password: str, no_registry: bool, *args, **kwargs):
def generate(cls, password: str, *args, **kwargs):
"""Shortcut: Hook-up a new initial installation and write configuration file to the disk"""
node_config = cls(dev_mode=False, is_me=True, *args, **kwargs)
node_config.__write(password=password, no_registry=no_registry)
node_config.__write(password=password)
return node_config
def __write(self, password: str, no_registry: bool):
if not self.federated_only:
self.connect_to_blockchain()
_new_installation_path = self.initialize(password=password, import_registry=no_registry)
def __write(self, password: str):
_new_installation_path = self.initialize(password=password, download_registry=self.download_registry)
_configuration_filepath = self.to_configuration_file(filepath=self.config_file_location)
def cleanup(self) -> None:
if self.__dev_mode:
self.__temp_dir.cleanup()
if self.blockchain:
self.blockchain.disconnect()
@property
def dev_mode(self):
@ -301,16 +302,37 @@ class NodeConfiguration(ABC):
def known_nodes(self):
return self.__fleet_state
def connect_to_blockchain(self, recompile_contracts: bool = False):
def connect_to_blockchain(self,
enode: str = None,
recompile_contracts: bool = False,
full_sync: bool = False) -> None:
"""
:param enode: ETH seednode or bootnode enode address to start learning from,
i.e. 'enode://e54eebad24dc...e1f6d246bea455@52.71.255.237:30303'
:param recompile_contracts: Recompile all contracts on connection.
:return: None
"""
if self.federated_only:
raise NodeConfiguration.ConfigurationError("Cannot connect to blockchain in federated mode")
self.blockchain = Blockchain.connect(provider_uri=self.provider_uri,
compile=recompile_contracts,
poa=self.poa)
poa=self.poa,
fetch_registry=True,
provider_process=self.provider_process,
sync=full_sync)
# Read Ethereum Node Keyring
self.accounts = self.blockchain.interface.w3.eth.accounts
self.log.debug("Established connection to provider {}".format(self.blockchain.interface.provider_uri))
# Add Ethereum Peer
if enode:
if self.blockchain.interface.client_version == 'geth':
self.blockchain.interface.w3.geth.admin.addPeer(enode)
else:
raise NotImplementedError
def connect_to_contracts(self) -> None:
"""Initialize contract agency and set them on config"""
@ -359,7 +381,11 @@ class NodeConfiguration(ABC):
return payload
@classmethod
def from_configuration_file(cls, filepath: str = None, **overrides) -> 'NodeConfiguration':
def from_configuration_file(cls,
filepath: str = None,
provider_process=None,
**overrides) -> 'NodeConfiguration':
"""Initialize a NodeConfiguration from a JSON file."""
from nucypher.config.storages import NodeStorage
@ -389,22 +415,23 @@ class NodeConfiguration(ABC):
serializer=cls.NODE_SERIALIZER,
deserializer=cls.NODE_DESERIALIZER)
# Deserialize domains to UTF-8 bytestrings
domains = set(domain.encode() for domain in payload['domains'])
domains = set(payload['domains'])
payload.update(dict(node_storage=node_storage, domains=domains))
# Filter out Nones from overrides to detect, well, overrides
overrides = {k: v for k, v in overrides.items() if v is not None}
# Instantiate from merged params
node_configuration = cls(config_file_location=filepath, **{**payload, **overrides})
node_configuration = cls(config_file_location=filepath,
provider_process=provider_process,
**{**payload, **overrides})
return node_configuration
def to_configuration_file(self, filepath: str = None) -> str:
"""Write the static_payload to a JSON file."""
if not filepath:
filename = f'{self._NAME.lower()}{self._NAME.lower(), }'
filename = f'{self._NAME.lower()}{self._NAME.lower(), }' # FIXME
filepath = os.path.join(self.config_root, filename)
if os.path.isfile(filepath):
@ -415,11 +442,8 @@ class NodeConfiguration(ABC):
payload = self.static_payload
del payload['is_me']
# Serialize domains
domains = list(str(domain) for domain in self.domains)
# Save node connection data
payload.update(dict(node_storage=self.node_storage.payload(), domains=domains))
payload.update(dict(node_storage=self.node_storage.payload(), domains=list(self.domains)))
with open(filepath, 'w') as config_file:
config_file.write(json.dumps(payload, indent=4))
@ -525,19 +549,19 @@ class NodeConfiguration(ABC):
power_ups.append(power_up)
return power_ups
def initialize(self,
password: str,
import_registry: bool = True,
) -> str:
"""Initialize a new configuration."""
def initialize(self, password: str, download_registry: bool = True) -> str:
"""Initialize a new configuration and write installation files to disk."""
#
# Create Config Root
# Create Base System Filepaths
#
if self.__dev_mode:
self.__temp_dir = TemporaryDirectory(prefix=self.TEMP_CONFIGURATION_DIR_PREFIX)
self.config_root = self.__temp_dir.name
else:
# Production Configuration
try:
os.mkdir(self.config_root, mode=0o755)
@ -549,38 +573,52 @@ class NodeConfiguration(ABC):
except FileNotFoundError:
os.makedirs(self.config_root, mode=0o755)
#
# Create Config Subdirectories
#
# Generate Installation Subdirectories
self._cache_runtime_filepaths()
try:
# Node Storage
self.node_storage.initialize()
#
# Blockchain
#
if not self.federated_only:
if self.provider_process:
self.provider_process.initialize_blockchain()
# Keyring
if not self.dev_mode:
if not os.path.isdir(self.keyring_dir):
os.mkdir(self.keyring_dir, mode=0o700) # keyring TODO: Keyring backend entry point: COS
self.write_keyring(password=password)
#
# Node Storage
#
# Registry
if import_registry and not self.federated_only:
self.write_registry(output_filepath=self.registry_filepath, # type: str
source=self.__registry_source, # type: str
blank=import_registry) # type: bool
self.node_storage.initialize()
except FileExistsError:
existing_paths = [os.path.join(self.config_root, f) for f in os.listdir(self.config_root)]
message = "There are pre-existing files at {}: {}".format(self.config_root, existing_paths)
self.log.info(message)
#
# Keyring
#
if not self.dev_mode:
if not os.path.isdir(self.keyring_dir):
os.mkdir(self.keyring_dir, mode=0o700) # TODO: Keyring backend entry point - COS
self.write_keyring(password=password)
#
# Registry
#
if download_registry and not self.federated_only:
self.registry_filepath = EthereumContractRegistry.download_latest_publication()
#
# Verify
#
if not self.__dev_mode:
self.validate(config_root=self.config_root, no_registry=import_registry or self.federated_only)
self.validate(config_root=self.config_root, no_registry=(not download_registry) or self.federated_only)
#
# Success
#
message = "Created nucypher installation files at {}".format(self.config_root)
self.log.debug(message)
return self.config_root
def attach_keyring(self, checksum_address: str = None, *args, **kwargs) -> None:
@ -598,16 +636,45 @@ class NodeConfiguration(ABC):
def write_keyring(self, password: str, **generation_kwargs) -> NucypherKeyring:
#
# Decentralized
#
# Note: It is assumed the blockchain is not yet available.
if not self.federated_only and not self.checksum_public_address:
checksum_address = self.blockchain.interface.w3.eth.accounts[0] # etherbase
else:
# "Casual Geth"
if self.provider_process:
if not os.path.exists(self.provider_process.data_dir):
os.mkdir(self.provider_process.data_dir)
# Get or create wallet address (geth etherbase)
checksum_address = self.provider_process.ensure_account_exists(password=password)
# "Formal Geth" - Manual Web3 Provider, We assume is already running and available
else:
self.connect_to_blockchain()
if not self.blockchain.interface.w3.eth.accounts:
raise self.ConfigurationError(f'Web3 provider "{self.provider_uri}" does not have any accounts')
checksum_address = self.blockchain.interface.w3.eth.accounts[0] # TODO: Make this a configurable default in config files
# Addresses read from some node keyrings (clients) are *not* returned in checksum format.
checksum_address = to_checksum_address(checksum_address)
# Use explicit address
elif self.checksum_public_address:
checksum_address = self.checksum_public_address
# Generate a federated checksum address
else:
checksum_address = None
self.keyring = NucypherKeyring.generate(password=password,
keyring_root=self.keyring_dir,
checksum_address=checksum_address,
**generation_kwargs)
# Operating mode switch TODO: #466
# Operating mode switch
if self.federated_only:
self.checksum_public_address = self.keyring.federated_address
else:

40
nucypher/crypto/api.py
View File

@ -30,6 +30,9 @@ from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurve
from cryptography.x509 import Certificate
from cryptography.x509.oid import NameOID
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_utils import to_checksum_address
from umbral import pre
from umbral.keys import UmbralPrivateKey, UmbralPublicKey
from umbral.signing import Signature
@ -81,31 +84,43 @@ def keccak_digest(*messages: bytes) -> bytes:
:rtype: bytes
:return: bytestring of digested data
"""
hash = sha3.keccak_256()
_hash = sha3.keccak_256()
for message in messages:
hash.update(message)
return hash.digest()
_hash.update(message)
return _hash.digest()
def ecdsa_sign(message: bytes,
privkey: UmbralPrivateKey
private_key: UmbralPrivateKey
) -> bytes:
"""
Accepts a hashed message and signs it with the private key given.
:param message: Message to hash and sign
:param privkey: Private key to sign with
:param private_key: Private key to sign with
:return: signature
"""
cryptography_priv_key = privkey.to_cryptography_privkey()
signature_der_bytes = cryptography_priv_key.sign(message, ec.ECDSA(SHA256))
signing_key = private_key.to_cryptography_privkey()
signature_der_bytes = signing_key.sign(message, ec.ECDSA(SHA256))
return signature_der_bytes
def ecdsa_verify(message: bytes,
def verify_eip_191(address: str, message: bytes, signature: bytes) -> bool:
"""
EIP-191 Compatible signature verification for usage with w3.eth.sign.
"""
signable_message = encode_defunct(primitive=message)
recovery = Account.recover_message(signable_message=signable_message, signature=signature)
recovered_address = to_checksum_address(recovery)
signature_is_valid = recovered_address == to_checksum_address(address)
return signature_is_valid
def verify_ecdsa(message: bytes,
signature: bytes,
pubkey: UmbralPublicKey
public_key: UmbralPublicKey
) -> bool:
"""
Accepts a message and signature and verifies it with the
@ -113,11 +128,11 @@ def ecdsa_verify(message: bytes,
:param message: Message to verify
:param signature: Signature to verify
:param pubkey: UmbralPublicKey to verify signature with
:param public_key: UmbralPublicKey to verify signature with
:return: True if valid, False if invalid.
"""
cryptography_pub_key = pubkey.to_cryptography_pubkey()
cryptography_pub_key = public_key.to_cryptography_pubkey()
try:
cryptography_pub_key.verify(
@ -152,7 +167,6 @@ def generate_self_signed_certificate(host: str,
cert = cert.serial_number(x509.random_serial_number())
cert = cert.not_valid_before(now)
cert = cert.not_valid_after(now + datetime.timedelta(days=days_valid))
# TODO: What are we going to do about domain name here? 179
cert = cert.add_extension(x509.SubjectAlternativeName([x509.IPAddress(IPv4Address(host))]), critical=False)
cert = cert.sign(private_key, hashes.SHA512(), default_backend())
@ -177,7 +191,7 @@ def encrypt_and_sign(recipient_pubkey_enc: UmbralPublicKey,
ciphertext, capsule = pre.encrypt(recipient_pubkey_enc, sig_header + plaintext)
signature = signer(ciphertext)
message_kit = UmbralMessageKit(ciphertext=ciphertext, capsule=capsule,
sender_pubkey_sig=signer.as_umbral_pubkey(),
sender_verifying_key=signer.as_umbral_pubkey(),
signature=signature)
else:
# Don't sign.

18
nucypher/crypto/kits.py
View File

@ -41,10 +41,15 @@ class CryptoKit:
class MessageKit(CryptoKit):
def __init__(self, capsule, sender_pubkey_sig=None, ciphertext=None, signature=constants.NOT_SIGNED) -> None:
def __init__(self,
capsule,
sender_verifying_key=None,
ciphertext=None,
signature=constants.NOT_SIGNED) -> None:
self.ciphertext = ciphertext
self.capsule = capsule
self.sender_pubkey_sig = sender_pubkey_sig
self.sender_verifying_key = sender_verifying_key
self._signature = signature
def to_bytes(self, include_alice_pubkey=True):
@ -53,8 +58,8 @@ class MessageKit(CryptoKit):
# Then, before the ciphertext, we see if we're including alice's public key.
# We want to put that first because it's typically of known length.
if include_alice_pubkey and self.sender_pubkey_sig:
as_bytes += bytes(self.sender_pubkey_sig)
if include_alice_pubkey and self.sender_verifying_key:
as_bytes += bytes(self.sender_verifying_key)
as_bytes += self.ciphertext
return as_bytes
@ -68,6 +73,7 @@ class MessageKit(CryptoKit):
class UmbralMessageKit(MessageKit):
return_remainder_when_splitting = True
splitter = capsule_splitter + key_splitter
@ -77,8 +83,8 @@ class UmbralMessageKit(MessageKit):
@classmethod
def from_bytes(cls, some_bytes):
capsule, sender_pubkey_sig, ciphertext = cls.split_bytes(some_bytes)
return cls(capsule=capsule, sender_pubkey_sig=sender_pubkey_sig, ciphertext=ciphertext)
capsule, sender_verifying_key, ciphertext = cls.split_bytes(some_bytes)
return cls(capsule=capsule, sender_verifying_key=sender_verifying_key, ciphertext=ciphertext)
class RevocationKit:

35
nucypher/crypto/powers.py
View File

@ -17,11 +17,13 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import inspect
from eth_keys.datatypes import PublicKey, Signature as EthSignature
from eth_keys.exceptions import BadSignature
from eth_utils import keccak
from typing import List, Tuple, Optional
from umbral import pre
from umbral.keys import UmbralPublicKey, UmbralPrivateKey, UmbralKeyingMaterial
from nucypher.crypto.signing import InvalidSignature
from nucypher.keystore import keypairs
from nucypher.keystore.keypairs import SigningKeypair, DecryptingKeypair
@ -98,50 +100,29 @@ class BlockchainPower(CryptoPowerUp):
self.account = account
self.is_unlocked = False
def unlock_account(self, password: str, duration: int = None):
def unlock_account(self, password: str):
"""
Unlocks the account for the specified duration. If no duration is
provided, it will remain unlocked indefinitely.
"""
self.is_unlocked = self.blockchain.interface.unlock_account(self.account, password, duration=duration)
self.is_unlocked = self.blockchain.interface.unlock_account(self.account, password)
if not self.is_unlocked:
raise PowerUpError("Failed to unlock account {}".format(self.account))
def sign_message(self, message: bytes):
def sign_message(self, message: bytes) -> bytes:
"""
Signs the message with the private key of the BlockchainPower.
"""
if not self.is_unlocked:
raise PowerUpError("Account is not unlocked.")
signature = self.blockchain.interface.call_backend_sign(self.account, message)
return bytes(signature)
def verify_message(self, address: str, pubkey: bytes, message: bytes, signature_bytes: bytes):
"""
Verifies that the message was signed by the keypair.
"""
# Check that address and pubkey match
eth_pubkey = PublicKey(pubkey)
signature = EthSignature(signature_bytes=signature_bytes)
if not eth_pubkey.to_checksum_address() == address:
raise ValueError("Pubkey address ({}) doesn't match the provided address ({})".format(eth_pubkey.to_checksum_address, address))
hashed_message = keccak(message)
if not self.blockchain.interface.call_backend_verify(
eth_pubkey, signature, hashed_message):
raise PowerUpError("Signature is not valid for this message or pubkey.")
else:
return True
signature = self.blockchain.interface.client.sign_message(self.account, message)
return signature
def __del__(self):
"""
Deletes the blockchain power and locks the account.
"""
# self.blockchain.interface.w3.personal.lockAccount(self.account) # TODO: Implement client support
self.blockchain.interface.client.lockAccount(self.account)
class KeyPairBasedPower(CryptoPowerUp):

2
nucypher/crypto/signing.py
View File

@ -14,6 +14,8 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from bytestring_splitter import BytestringSplitter
from umbral.signing import Signature, Signer

29
nucypher/keystore/db/models.py
View File

@ -54,24 +54,25 @@ class PolicyArrangement(Base):
id = Column(LargeBinary, unique=True, primary_key=True)
expiration = Column(DateTime)
kfrag = Column(LargeBinary, unique=True, nullable=True)
alice_pubkey_sig_id = Column(Integer, ForeignKey('keys.id'))
alice_pubkey_sig = relationship(Key, backref="policies", lazy='joined')
# alice_pubkey_enc_id = Column(Integer, ForeignKey('keys.id'))
# bob_pubkey_sig_id = Column(Integer, ForeignKey('keys.id'))
alice_verifying_key_id = Column(Integer, ForeignKey('keys.id'))
alice_verifying_key = relationship(Key, backref="policies", lazy='joined')
# TODO: Maybe this will be two signatures - one for the offer, one for the KFrag.
alice_signature = Column(LargeBinary, unique=True, nullable=True)
created_at = Column(DateTime, default=datetime.utcnow)
def __init__(self, expiration, id,
kfrag=None, alice_pubkey_sig=None,
# alice_pubkey_enc_id, bob_pubkey_sig_id,
alice_signature=None) -> None:
def __init__(self,
expiration,
id,
kfrag=None,
alice_verifying_key=None,
alice_signature=None
) -> None:
self.expiration = expiration
self.id = id
self.kfrag = kfrag
self.alice_pubkey_sig = alice_pubkey_sig
# self.alice_pubkey_enc_id = alice_pubkey_enc_id
# self.bob_pubkey_sig_id = bob_pubkey_sig_id
self.alice_verifying_key = alice_verifying_key
self.alice_signature = alice_signature
def __repr__(self):
@ -82,13 +83,13 @@ class Workorder(Base):
__tablename__ = 'workorders'
id = Column(Integer, primary_key=True)
bob_pubkey_sig_id = Column(Integer, ForeignKey('keys.id'))
bob_verifying_key_id = Column(Integer, ForeignKey('keys.id'))
bob_signature = Column(LargeBinary, unique=True)
arrangement_id = Column(LargeBinary, unique=False)
created_at = Column(DateTime, default=datetime.utcnow)
def __init__(self, bob_pubkey_sig_id, bob_signature, arrangement_id) -> None:
self.bob_pubkey_sig_id = bob_pubkey_sig_id
def __init__(self, bob_verifying_key_id, bob_signature, arrangement_id) -> None:
self.bob_verifying_key_id = bob_verifying_key_id
self.bob_signature = bob_signature
self.arrangement_id = arrangement_id

18
nucypher/keystore/keystore.py
View File

@ -99,7 +99,7 @@ class KeyStore(object):
session.commit()
def add_policy_arrangement(self, expiration, id, kfrag=None,
alice_pubkey_sig=None,
alice_verifying_key=None,
alice_signature=None,
session=None) -> PolicyArrangement:
"""
@ -109,13 +109,13 @@ class KeyStore(object):
"""
session = session or self._session_on_init_thread
alice_key_instance = session.query(Key).filter_by(key_data=bytes(alice_pubkey_sig)).first()
alice_key_instance = session.query(Key).filter_by(key_data=bytes(alice_verifying_key)).first()
if not alice_key_instance:
alice_key_instance = Key.from_umbral_key(alice_pubkey_sig, is_signing=True)
alice_key_instance = Key.from_umbral_key(alice_verifying_key, is_signing=True)
new_policy_arrangement = PolicyArrangement(
expiration, id, kfrag, alice_pubkey_sig=alice_key_instance,
alice_signature=None, # bob_pubkey_sig.id
expiration, id, kfrag, alice_verifying_key=alice_key_instance,
alice_signature=None, # bob_verifying_key.id
)
session.add(new_policy_arrangement)
@ -154,19 +154,19 @@ class KeyStore(object):
if policy_arrangement is None:
raise NotFound("Can't attach a kfrag to non-existent Arrangement {}".format(id_as_hex))
if policy_arrangement.alice_pubkey_sig.key_data != alice.stamp:
if policy_arrangement.alice_verifying_key.key_data != alice.stamp:
raise alice.SuspiciousActivity
policy_arrangement.kfrag = bytes(kfrag)
session.commit()
def add_workorder(self, bob_pubkey_sig, bob_signature, arrangement_id, session=None) -> Workorder:
def add_workorder(self, bob_verifying_key, bob_signature, arrangement_id, session=None) -> Workorder:
"""
Adds a Workorder to the keystore.
"""
session = session or self._session_on_init_thread
bob_pubkey_sig = self.add_key(bob_pubkey_sig)
new_workorder = Workorder(bob_pubkey_sig.id, bob_signature, arrangement_id)
bob_verifying_key = self.add_key(bob_verifying_key)
new_workorder = Workorder(bob_verifying_key.id, bob_signature, arrangement_id)
session.add(new_workorder)
session.commit()

345
nucypher/network/nodes.py
View File

@ -17,31 +17,37 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import binascii
import random
import time
from collections import defaultdict, OrderedDict
from collections import deque
from collections import namedtuple
from contextlib import suppress
from typing import Set, Tuple
import maya
import requests
import time
from bytestring_splitter import BytestringSplitter
from bytestring_splitter import VariableLengthBytestring, BytestringSplittingError
from constant_sorrow import constant_or_bytes
from constant_sorrow.constants import (
NO_KNOWN_NODES,
NOT_SIGNED,
NEVER_SEEN,
NO_STORAGE_AVAILIBLE,
FLEET_STATES_MATCH,
CERTIFICATE_NOT_SAVED,
UNKNOWN_FLEET_STATE
)
from cryptography.x509 import Certificate
from eth_keys.datatypes import Signature as EthSignature
from requests.exceptions import SSLError
from twisted.internet import reactor, defer
from twisted.internet import task
from twisted.internet.threads import deferToThread
from twisted.logger import Logger
from bytestring_splitter import BytestringSplitter
from bytestring_splitter import VariableLengthBytestring, BytestringSplittingError
from constant_sorrow import constant_or_bytes
from constant_sorrow.constants import NO_KNOWN_NODES, NOT_SIGNED, NEVER_SEEN, NO_STORAGE_AVAILIBLE, FLEET_STATES_MATCH
from nucypher.config.constants import SeednodeMetadata, GLOBAL_DOMAIN
from nucypher.config.constants import SeednodeMetadata
from nucypher.config.storages import ForgetfulNodeStorage
from nucypher.crypto.api import keccak_digest
from nucypher.crypto.api import keccak_digest, verify_eip_191, verify_ecdsa
from nucypher.crypto.powers import BlockchainPower, SigningPower, DecryptingPower, NoSigningPower
from nucypher.crypto.signing import signature_splitter
from nucypher.network import LEARNING_LOOP_VERSION
@ -262,7 +268,7 @@ class Learner:
version_splitter = BytestringSplitter((int, 2, {"byteorder": "big"}))
tracker_class = FleetStateTracker
invalid_metadata_message = "{} has invalid metadata. Maybe its stake is over? Or maybe it is transitioning to a new interface. Ignoring."
invalid_metadata_message = "{} has invalid metadata. The node's stake may have ended, or it is transitioning to a new interface. Ignoring."
unknown_version_message = "{} purported to be of version {}, but we're only version {}. Is there a new version of NuCypher?"
really_unknown_version_message = "Unable to glean address from node that perhaps purported to be version {}. We're only version {}."
fleet_state_icon = ""
@ -323,11 +329,10 @@ class Learner:
raise ValueError("Cannot save nodes without a configured node storage")
known_nodes = known_nodes or tuple()
self.unresponsive_startup_nodes = list() # TODO: Attempt to use these again later
self.unresponsive_startup_nodes = list() # TODO: Buckets - Attempt to use these again later
for node in known_nodes:
try:
self.remember_node(
node) # TODO: Need to test this better - do we ever init an Ursula-Learner with Node Storage?
self.remember_node(node)
except self.UnresponsiveTeacher:
self.unresponsive_startup_nodes.append(node)
@ -385,8 +390,8 @@ class Learner:
self.log.warn("No seednodes were available after {} attempts".format(retry_attempts))
# TODO: Need some actual logic here for situation with no seed nodes (ie, maybe try again much later)
def read_nodes_from_storage(self) -> set:
stored_nodes = self.node_storage.all(federated_only=self.federated_only) # TODO: 466
def read_nodes_from_storage(self) -> None:
stored_nodes = self.node_storage.all(federated_only=self.federated_only) # TODO: #466
for node in stored_nodes:
self.remember_node(node)
@ -420,8 +425,7 @@ class Learner:
try:
node.verify_node(force=force_verification_check,
network_middleware=self.network_middleware,
accept_federated_only=self.federated_only,
# TODO: 466 - move federated-only up to Learner?
accept_federated_only=self.federated_only, # TODO: 466 - move federated-only up to Learner?
)
except SSLError:
return False # TODO: Bucket this node as having bad TLS info - maybe it's an update that hasn't fully propagated?
@ -701,10 +705,13 @@ class Learner:
announce_nodes = None
unresponsive_nodes = set()
#
# Request
#
try:
# TODO: Streamline path generation
certificate_filepath = self.node_storage.generate_certificate_filepath(
checksum_address=current_teacher.checksum_public_address)
response = self.network_middleware.get_nodes_via_rest(node=current_teacher,
nodes_i_need=self._node_ids_to_learn_about_immediately,
announce_nodes=announce_nodes,
@ -713,10 +720,10 @@ class Learner:
unresponsive_nodes.add(current_teacher)
self.log.info("Bad Response from teacher: {}:{}.".format(current_teacher, e))
return
finally:
self.cycle_teacher_node()
#
# Before we parse the response, let's handle some edge cases.
if response.status_code == 204:
# In this case, this node knows about no other nodes. Hopefully we've taught it something.
@ -729,6 +736,11 @@ class Learner:
self.log.info("Bad response from teacher {}: {} - {}".format(current_teacher, response, response.content))
return
#
# Deserialize
#
# TODO #1039 - Causes protocol versioning checks to fail in-test when using an unsigned Response
try:
signature, node_payload = signature_splitter(response.content, return_remainder=True)
except BytestringSplittingError as e:
@ -740,12 +752,12 @@ class Learner:
except current_teacher.InvalidSignature:
# TODO: What to do if the teacher improperly signed the node payload?
raise
# End edge case handling.
#
# End edge case handling.
fleet_state_checksum_bytes, fleet_state_updated_bytes, node_payload = FleetStateTracker.snapshot_splitter(
node_payload,
return_remainder=True)
current_teacher.last_seen = maya.now()
# TODO: This is weird - let's get a stranger FleetState going.
checksum = fleet_state_checksum_bytes.hex()
@ -754,25 +766,20 @@ class Learner:
from nucypher.characters.lawful import Ursula
if constant_or_bytes(node_payload) is FLEET_STATES_MATCH:
current_teacher.update_snapshot(checksum=checksum,
updated=maya.MayaDT(
int.from_bytes(fleet_state_updated_bytes, byteorder="big")),
number_of_known_nodes=len(self.known_nodes)
)
updated=maya.MayaDT(int.from_bytes(fleet_state_updated_bytes, byteorder="big")),
number_of_known_nodes=len(self.known_nodes))
return FLEET_STATES_MATCH
node_list = Ursula.batch_from_bytes(node_payload, federated_only=self.federated_only) # TODO: 466
current_teacher.update_snapshot(checksum=checksum,
updated=maya.MayaDT(
int.from_bytes(fleet_state_updated_bytes, byteorder="big")),
number_of_known_nodes=len(node_list)
)
updated=maya.MayaDT(int.from_bytes(fleet_state_updated_bytes, byteorder="big")),
number_of_known_nodes=len(node_list))
new_nodes = []
for node in node_list:
if GLOBAL_DOMAIN not in self.learning_domains:
if not set(self.learning_domains).intersection(set(node.serving_domains)):
continue # This node is not serving any of our domains.
if not set(self.learning_domains).intersection(set(node.serving_domains)):
continue # This node is not serving any of our domains.
# First, determine if this is an outdated representation of an already known node.
with suppress(KeyError):
@ -782,8 +789,11 @@ class Learner:
# This node is already known. We can safely continue to the next.
continue
certificate_filepath = self.node_storage.store_node_certificate(certificate=node.certificate)
#
# Verify Node
#
certificate_filepath = self.node_storage.store_node_certificate(certificate=node.certificate)
try:
if eager:
node.verify_node(self.network_middleware,
@ -793,28 +803,54 @@ class Learner:
else:
node.validate_metadata(accept_federated_only=self.federated_only) # TODO: 466
# This block is a mess of eagerness. This can all be done better lazily.
#
# Report Failure
#
except NodeSeemsToBeDown as e:
self.log.info(f"Can't connect to {node} to verify it right now.")
self.log.info(f"Verification Failed - "
f"Cannot establish connection to {node}.")
except node.StampNotSigned:
self.log.warn(f'Verification Failed - '
f'{node} stamp is unsigned.')
except node.NotStaking:
self.log.warn(f'Verification Failed - '
f'{node} has no active stakes in the current period ({self.miner_agent.get_current_period()}')
except node.InvalidWalletSignature:
self.log.warn(f'Verification Failed - '
f'{node} has an invalid wallet signature for {node.checksum_public_address}')
except node.InvalidNode:
# TODO: Account for possibility that stamp, rather than interface, was bad.
self.log.warn(node.invalid_metadata_message.format(node))
except node.SuspiciousActivity:
message = "Suspicious Activity: Discovered node with bad signature: {}. " \
"Propagated by: {}".format(current_teacher.checksum_public_address, teacher_uri)
message = f"Suspicious Activity: Discovered node with bad signature: {node}." \
f"Propagated by: {current_teacher}"
self.log.warn(message)
#
# Success
#
else:
new = self.remember_node(node, record_fleet_state=False)
if new:
new_nodes.append(node)
self._adjust_learning(new_nodes)
#
# Continue
#
self._adjust_learning(new_nodes)
learning_round_log_message = "Learning round {}. Teacher: {} knew about {} nodes, {} were new."
self.log.info(learning_round_log_message.format(self._learning_round,
current_teacher,
len(node_list),
len(new_nodes)), )
len(new_nodes)))
if new_nodes:
self.known_nodes.record_fleet_state()
for node in new_nodes:
@ -823,10 +859,8 @@ class Learner:
class Teacher:
TEACHER_VERSION = LEARNING_LOOP_VERSION
verified_stamp = False
verified_interface = False
_verified_node = False
_interface_info_splitter = (int, 4, {'byteorder': 'big'})
log = Logger("teacher")
__DEFAULT_MIN_SEED_STAKE = 0
@ -837,38 +871,63 @@ class Teacher:
certificate_filepath: str,
interface_signature=NOT_SIGNED.bool_value(False),
timestamp=NOT_SIGNED,
identity_evidence=NOT_SIGNED,
decentralized_identity_evidence=NOT_SIGNED,
substantiate_immediately=False,
passphrase=None,
password=None,
) -> None:
#
# Fleet
#
self.serving_domains = domains
self.certificate = certificate
self.certificate_filepath = certificate_filepath
self._interface_signature_object = interface_signature
self._timestamp = timestamp
self.last_seen = NEVER_SEEN("Haven't connected to this node yet.")
self.fleet_state_checksum = None
self.fleet_state_updated = None
self._evidence_of_decentralized_identity = constant_or_bytes(identity_evidence)
self.last_seen = NEVER_SEEN("No Connection to Node")
self.fleet_state_icon = UNKNOWN_FLEET_STATE
self.fleet_state_nickname = UNKNOWN_FLEET_STATE
self.fleet_state_nickname_metadata = UNKNOWN_FLEET_STATE
#
# Identity
#
self._timestamp = timestamp
self.certificate = certificate
self.certificate_filepath = certificate_filepath
self.__interface_signature = interface_signature
self.__decentralized_identity_evidence = constant_or_bytes(decentralized_identity_evidence)
# Assume unverified
self.verified_stamp = False
self.verified_worker = False
self.verified_interface = False
self.verified_node = False
if substantiate_immediately:
self.substantiate_stamp(password=passphrase) # TODO: Derive from keyring
self.substantiate_stamp(client_password=password)
class InvalidNode(SuspiciousActivity):
"""
Raised when a node has an invalid characteristic - stamp, interface, or address.
"""
"""Raised when a node has an invalid characteristic - stamp, interface, or address."""
class InvalidStamp(InvalidNode):
"""Base exception class for invalid character stamps"""
class StampNotSigned(InvalidStamp):
"""Raised when a node does not have a stamp signature when one is required for verification"""
class InvalidWalletSignature(InvalidStamp):
"""Raised when a stamp fails signature verification or recovers an unexpected wallet address"""
class NotStaking(InvalidStamp):
"""Raised when a node fails verification because it is not currently staking"""
class WrongMode(TypeError):
"""
Raised when a Character tries to use another Character as decentralized when the latter is federated_only.
"""
"""Raised when a Character tries to use another Character as decentralized when the latter is federated_only."""
class IsFromTheFuture(TypeError):
"""
Raised when deserializing a Character from a future version.
"""
"""Raised when deserializing a Character from a future version."""
@classmethod
def from_tls_hosting_power(cls, tls_hosting_power: TLSHostingPower, *args, **kwargs) -> 'Teacher':
@ -893,8 +952,17 @@ class Teacher:
return sorted(nodes_to_consider, key=lambda n: n.checksum_public_address)
def update_snapshot(self, checksum, updated, number_of_known_nodes):
# We update the simple snapshot here, but of course if we're dealing with an instance that is also a Learner, it has
# its own notion of its FleetState, so we probably need a reckoning of sorts here to manage that. In time.
"""
TODO: We update the simple snapshot here, but of course if we're dealing
with an instance that is also a Learner, it has
its own notion of its FleetState, so we probably
need a reckoning of sorts here to manage that. In time.
:param checksum:
:param updated:
:param number_of_known_nodes:
:return:
"""
self.fleet_state_nickname, self.fleet_state_nickname_metadata = nickname_from_seed(checksum, number_of_pairs=1)
self.fleet_state_checksum = checksum
self.fleet_state_updated = updated
@ -906,46 +974,71 @@ class Teacher:
# Stamp
#
def _stamp_has_valid_wallet_signature(self):
signature_bytes = self._evidence_of_decentralized_identity
if signature_bytes is NOT_SIGNED:
def _stamp_has_valid_wallet_signature(self) -> bool:
"""Off-chain Signature Verification of ethereum client signature of stamp"""
if self.__decentralized_identity_evidence is NOT_SIGNED:
return False
signature_is_valid = verify_eip_191(message=bytes(self.stamp),
signature=self.__decentralized_identity_evidence,
address=self.checksum_public_address)
return signature_is_valid
signature = EthSignature(signature_bytes)
proper_pubkey = signature.recover_public_key_from_msg(bytes(self.stamp))
proper_address = proper_pubkey.to_checksum_address()
return proper_address == self.checksum_public_address
def _is_valid_worker(self) -> bool:
"""
This method assumes the stamp's signature is valid and accurate.
As a follow-up, validate the Staker and Worker on-chain.
def stamp_is_valid(self):
TODO: #1033 - Verify Staker <-> Worker relationship on-chain
"""
:return:
"""
signature = self._evidence_of_decentralized_identity
if self._stamp_has_valid_wallet_signature():
self.verified_stamp = True
return True
elif self.federated_only and signature is NOT_SIGNED:
message = "This node can't be verified in this manner, " \
"but is OK to use in federated mode if you" \
" have reason to believe it is trustworthy."
locked_tokens = self.miner_agent.get_locked_tokens(miner_address=self.checksum_public_address)
return locked_tokens > 0
def validate_stamp(self, verify_staking: bool = True) -> None:
# Federated
if self.federated_only:
message = "This node cannot be verified in this manner, " \
"but is OK to use in federated mode if you " \
"have reason to believe it is trustworthy."
raise self.WrongMode(message)
# Decentralized
else:
raise self.InvalidNode
def verify_id(self, ursula_id, digest_factory=bytes):
self.verify()
if not ursula_id == digest_factory(self.canonical_public_address):
raise self.InvalidNode
if self.__decentralized_identity_evidence is NOT_SIGNED:
raise self.StampNotSigned
def validate_metadata(self, accept_federated_only=False):
# Off-chain signature verification
if not self._stamp_has_valid_wallet_signature():
raise self.InvalidWalletSignature
# On-chain staking check
if verify_staking:
if self._is_valid_worker(): # <-- Blockchain CALL
self.verified_worker = True
else:
raise self.NotStaking
self.verified_stamp = True
def validate_metadata(self,
accept_federated_only: bool = False,
verify_staking: bool = True):
# Verify the interface signature
if not self.verified_interface:
self.interface_is_valid()
if not self.verified_stamp:
try:
self.stamp_is_valid()
except self.WrongMode:
if not accept_federated_only:
raise
self.validate_interface()
# Verify the identity evidence
if self.verified_stamp:
return
# Offline check of valid stamp signature by worker
try:
self.validate_stamp(verify_staking=verify_staking)
except self.WrongMode:
if not accept_federated_only:
raise
def verify_node(self,
network_middleware,
@ -956,59 +1049,73 @@ class Teacher:
"""
Three things happening here:
* Verify that the stamp matches the address (raises InvalidNode is it's not valid, or WrongMode if it's a federated mode and being verified as a decentralized node)
* Verify that the stamp matches the address (raises InvalidNode is it's not valid,
or WrongMode if it's a federated mode and being verified as a decentralized node)
* Verify the interface signature (raises InvalidNode if not valid)
* Connect to the node, make sure that it's up, and that the signature and address we checked are the same ones this node is using now. (raises InvalidNode if not valid; also emits a specific warning depending on which check failed).
* Connect to the node, make sure that it's up, and that the signature and address we
checked are the same ones this node is using now. (raises InvalidNode if not valid;
also emits a specific warning depending on which check failed).
"""
if not force:
if self._verified_node:
return True
self.validate_metadata(accept_federated_only) # This is both the stamp and interface check.
# Only perform this check once per object
if not force and self.verified_node:
return True
# This is both the stamp's client signature and interface metadata check; May raise InvalidNode
self.validate_metadata(accept_federated_only=accept_federated_only)
# The node's metadata is valid; let's be sure the interface is in order.
if not certificate_filepath:
if not self.certificate_filepath:
if self.certificate_filepath is CERTIFICATE_NOT_SAVED:
raise TypeError("We haven't saved a certificate for this node yet.")
else:
certificate_filepath = self.certificate_filepath
# The node's metadata is valid; let's be sure the interface is in order.
response_data = network_middleware.node_information(host=self.rest_information()[0].host,
port=self.rest_information()[0].port,
certificate_filepath=certificate_filepath)
version, node_bytes = self.version_splitter(response_data, return_remainder=True)
node_details = self.internal_splitter(node_bytes)
# TODO check timestamp here. 589
# TODO: #589 - check timestamp here.
verifying_keys_match = node_details['verifying_key'] == self.public_keys(SigningPower)
encrypting_keys_match = node_details['encrypting_key'] == self.public_keys(DecryptingPower)
addresses_match = node_details['public_address'] == self.canonical_public_address
evidence_matches = node_details['identity_evidence'] == self._evidence_of_decentralized_identity
evidence_matches = node_details['decentralized_identity_evidence'] == self.__decentralized_identity_evidence
if not all((encrypting_keys_match, verifying_keys_match, addresses_match, evidence_matches)):
# TODO: Optional reporting. 355
# Failure
if not addresses_match:
self.log.warn("Wallet address swapped out. It appears that someone is trying to defraud this node.")
if not verifying_keys_match:
self.log.warn("Verifying key swapped out. It appears that someone is impersonating this node.")
raise self.InvalidNode("Wrong cryptographic material for this node - something fishy going on.")
else:
self._verified_node = True
def substantiate_stamp(self, password: str):
# TODO: #355 - Optional reporting.
raise self.InvalidNode("Wrong cryptographic material for this node - something fishy going on.")
else:
# Success
self.verified_node = True
@property
def decentralized_identity_evidence(self):
return self.__decentralized_identity_evidence
def substantiate_stamp(self, client_password: str):
blockchain_power = self._crypto_power.power_ups(BlockchainPower)
blockchain_power.unlock_account(password=password) # TODO: 349
blockchain_power.unlock_account(password=client_password) # TODO: #349
signature = blockchain_power.sign_message(bytes(self.stamp))
self._evidence_of_decentralized_identity = signature
self.__decentralized_identity_evidence = signature
#
# Interface
#
def interface_is_valid(self):
def validate_interface(self) -> bool:
"""
Checks that the interface info is valid for this node's canonical address.
"""
@ -1028,16 +1135,16 @@ class Teacher:
def _sign_and_date_interface_info(self):
message = self._signable_interface_info_message()
self._timestamp = maya.now()
self._interface_signature_object = self.stamp(self.timestamp_bytes() + message)
self.__interface_signature = self.stamp(self.timestamp_bytes() + message)
@property
def _interface_signature(self):
if not self._interface_signature_object:
if not self.__interface_signature:
try:
self._sign_and_date_interface_info()
except NoSigningPower:
raise NoSigningPower("This Ursula is a stranger and cannot be used to verify.")
return self._interface_signature_object
return self.__interface_signature
@property
def timestamp(self):

37
nucypher/network/server.py
View File

@ -16,9 +16,8 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import binascii
import json
import os
from typing import Callable, Tuple
from typing import Tuple
from flask import Flask, Response
from flask import request
@ -30,23 +29,18 @@ from umbral.kfrags import KFrag
from bytestring_splitter import VariableLengthBytestring
from constant_sorrow import constants
from constant_sorrow.constants import (FLEET_STATES_MATCH,
GLOBAL_DOMAIN,
NO_KNOWN_NODES)
from constant_sorrow.constants import FLEET_STATES_MATCH, NO_KNOWN_NODES
from hendrix.experience import crosstown_traffic
from nucypher.config.constants import GLOBAL_DOMAIN
from nucypher.config.storages import ForgetfulNodeStorage
from nucypher.crypto.api import keccak_digest
from nucypher.crypto.kits import UmbralMessageKit
from nucypher.crypto.powers import KeyPairBasedPower, PowerUpError
from nucypher.crypto.signing import InvalidSignature, SignatureStamp
from nucypher.crypto.signing import InvalidSignature
from nucypher.crypto.utils import canonical_address_from_umbral_key
from nucypher.keystore.keypairs import HostingKeypair
from nucypher.keystore.keystore import NotFound
from nucypher.keystore.threading import ThreadedSession
from nucypher.network import LEARNING_LOOP_VERSION
from nucypher.network.middleware import RestMiddleware
from nucypher.network.protocols import InterfaceInfo
HERE = BASE_DIR = os.path.abspath(os.path.dirname(__file__))
@ -161,9 +155,8 @@ def make_rest_app(
# TODO: This logic is basically repeated in learn_from_teacher_node and remember_node.
# Let's find a better way. #555
for node in nodes:
if GLOBAL_DOMAIN not in serving_domains:
if not set(serving_domains).intersection(set(node.serving_domains)):
continue # This node is not serving any of our domains.
if not set(serving_domains).intersection(set(node.serving_domains)):
continue # This node is not serving any of our domains.
if node in this_node.known_nodes:
if node.timestamp <= this_node.known_nodes[node.checksum_public_address].timestamp:
@ -216,7 +209,7 @@ def make_rest_app(
new_policy_arrangement = datastore.add_policy_arrangement(
arrangement.expiration.datetime(),
id=arrangement.id.hex().encode(),
alice_pubkey_sig=arrangement.alice.stamp,
alice_verifying_key=arrangement.alice.stamp,
session=session,
)
# TODO: Make the rest of this logic actually work - do something here
@ -237,7 +230,7 @@ def make_rest_app(
"""
policy_message_kit = UmbralMessageKit.from_bytes(request.data)
alices_verifying_key = policy_message_kit.sender_pubkey_sig
alices_verifying_key = policy_message_kit.sender_verifying_key
alice = _alice_class.from_public_keys(verifying_key=alices_verifying_key)
try:
@ -276,7 +269,7 @@ def make_rest_app(
policy_arrangement = datastore.get_policy_arrangement(
id_as_hex.encode(), session=session)
alice_pubkey = UmbralPublicKey.from_bytes(
policy_arrangement.alice_pubkey_sig.key_data)
policy_arrangement.alice_verifying_key.key_data)
# Check that the request is the same for the provided revocation
if id_as_hex != revocation.arrangement_id.hex():
@ -305,7 +298,7 @@ def make_rest_app(
policy_arrangement = datastore.get_policy_arrangement(arrangement_id=id_as_hex.encode(),
session=session)
kfrag_bytes = policy_arrangement.kfrag # Careful! :-)
verifying_key_bytes = policy_arrangement.alice_pubkey_sig.key_data
verifying_key_bytes = policy_arrangement.alice_verifying_key.key_data
# TODO: Push this to a lower level. Perhaps to Ursula character? #619
kfrag = KFrag.from_bytes(kfrag_bytes)
@ -346,11 +339,11 @@ def make_rest_app(
def provide_treasure_map(treasure_map_id):
headers = {'Content-Type': 'application/octet-stream'}
treasure_map_bytes = keccak_digest(binascii.unhexlify(treasure_map_id))
treasure_map_index = bytes.fromhex(treasure_map_id)
try:
treasure_map = this_node.treasure_maps[treasure_map_bytes]
treasure_map = this_node.treasure_maps[treasure_map_index]
response = Response(bytes(treasure_map), headers=headers)
log.info("{} providing TreasureMap {}".format(this_node.nickname, treasure_map_id))
@ -366,9 +359,7 @@ def make_rest_app(
from nucypher.policy.models import TreasureMap
try:
treasure_map = TreasureMap.from_bytes(
bytes_representation=request.data,
verify=True)
treasure_map = TreasureMap.from_bytes(bytes_representation=request.data, verify=True)
except TreasureMap.InvalidSignature:
do_store = False
else:
@ -376,8 +367,10 @@ def make_rest_app(
if do_store:
log.info("{} storing TreasureMap {}".format(this_node.stamp, treasure_map_id))
# TODO 341 - what if we already have this TreasureMap?
this_node.treasure_maps[keccak_digest(binascii.unhexlify(treasure_map_id))] = treasure_map
treasure_map_index = bytes.fromhex(treasure_map_id)
this_node.treasure_maps[treasure_map_index] = treasure_map
return Response(bytes(treasure_map), status=202)
else:
# TODO: Make this a proper 500 or whatever.

24
nucypher/network/teachers.py Normal file
View File

@ -0,0 +1,24 @@
"""
This file is part of nucypher.
nucypher is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
nucypher 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
# Hardcoded teacher nodes for, both, our testnet and mainnet.
# Stored as a dict with the domain as the key.
TEACHER_NODES = {
'goerli': [],
'mainnet': [],
}

17
nucypher/policy/models.py
View File

@ -88,9 +88,9 @@ class Arrangement:
@classmethod
def from_bytes(cls, arrangement_as_bytes):
# Still unclear how to arrive at the correct number of bytes to represent a deposit. See #148.
alice_pubkey_sig, arrangement_id, expiration_bytes = cls.splitter(arrangement_as_bytes)
alice_verifying_key, arrangement_id, expiration_bytes = cls.splitter(arrangement_as_bytes)
expiration = maya.parse(expiration_bytes.decode())
alice = Alice.from_public_keys(verifying_key=alice_pubkey_sig)
alice = Alice.from_public_keys(verifying_key=alice_verifying_key)
return cls(alice=alice, arrangement_id=arrangement_id, expiration=expiration)
def encrypt_payload_for_ursula(self):
@ -456,7 +456,7 @@ class TreasureMap:
@property
def _verifying_key(self):
return self.message_kit.sender_pubkey_sig
return self.message_kit.sender_verifying_key
@property
def m(self):
@ -490,7 +490,8 @@ class TreasureMap:
Ursula will refuse to propagate this if it she can't prove the payload is signed by Alice's public key,
which is included in it,
"""
return keccak_digest(bytes(self._verifying_key) + bytes(self._hrac)).hex()
_id = keccak_digest(bytes(self._verifying_key) + bytes(self._hrac)).hex()
return _id
@classmethod
def from_bytes(cls, bytes_representation, verify=True):
@ -642,13 +643,13 @@ class WorkOrder:
payload_splitter = BytestringSplitter(Signature) + key_splitter
payload_elements = payload_splitter(rest_payload, msgpack_remainder=True)
signature, bob_pubkey_sig, (tasks_bytes, blockhash) = payload_elements
signature, bob_verifying_key, (tasks_bytes, blockhash) = payload_elements
# TODO: check freshness of blockhash?
# Check receipt
receipt_bytes = b"wo:" + ursula_pubkey_bytes + msgpack.dumps(tasks_bytes)
if not signature.verify(receipt_bytes, bob_pubkey_sig):
if not signature.verify(receipt_bytes, bob_verifying_key):
raise InvalidSignature()
tasks = []
@ -658,10 +659,10 @@ class WorkOrder:
# Each task signature has to match the original specification
specification = task.get_specification(ursula_pubkey_bytes, alice_address, blockhash)
if not task.signature.verify(specification, bob_pubkey_sig):
if not task.signature.verify(specification, bob_verifying_key):
raise InvalidSignature()
bob = Bob.from_public_keys(verifying_key=bob_pubkey_sig)
bob = Bob.from_public_keys(verifying_key=bob_verifying_key)
return cls(bob=bob,
arrangement_id=arrangement_id,
tasks=tasks,

70
nucypher/utilities/sandbox/blockchain.py
View File

@ -17,10 +17,9 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import os
from functools import partial
from typing import List, Tuple, Dict
from constant_sorrow.constants import NO_BLOCKCHAIN_AVAILABLE
from constant_sorrow.constants import NO_BLOCKCHAIN_AVAILABLE, TEST_PROVIDER_ON_MAIN_PROCESS
from twisted.logger import Logger
from web3 import Web3
from web3.middleware import geth_poa_middleware
@ -29,7 +28,6 @@ from nucypher.blockchain.economics import TokenEconomics
from nucypher.blockchain.eth.actors import Deployer
from nucypher.blockchain.eth.agents import EthereumContractAgent
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.blockchain.eth.deployers import DispatcherDeployer
from nucypher.blockchain.eth.interfaces import BlockchainDeployerInterface
from nucypher.blockchain.eth.registry import InMemoryEthereumContractRegistry
from nucypher.blockchain.eth.sol.compile import SolidityCompiler
@ -38,8 +36,10 @@ from nucypher.config.constants import CONTRACT_ROOT
from nucypher.utilities.sandbox.constants import (
NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS,
NUMBER_OF_ETH_TEST_ACCOUNTS,
DEVELOPMENT_ETH_AIRDROP_AMOUNT
)
DEVELOPMENT_ETH_AIRDROP_AMOUNT,
INSECURE_DEVELOPMENT_PASSWORD,
MINERS_ESCROW_DEPLOYMENT_SECRET, POLICY_MANAGER_DEPLOYMENT_SECRET, MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
def token_airdrop(token_agent, amount: NU, origin: str, addresses: List[str]):
@ -76,13 +76,19 @@ class TesterBlockchain(Blockchain):
_FIRST_URSULA = 5
_ursulas_range = range(NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS)
def __init__(self, test_accounts=None, poa=True, airdrop=False, *args, **kwargs):
def __init__(self,
test_accounts=None,
poa=True,
eth_airdrop=False,
free_transactions=False,
*args, **kwargs):
if test_accounts is None:
test_accounts = self._default_test_accounts
super().__init__(*args, **kwargs)
super().__init__(provider_process=TEST_PROVIDER_ON_MAIN_PROCESS, *args, **kwargs)
self.log = Logger("test-blockchain")
self.attach_middleware(w3=self.interface.w3, poa=poa)
self.attach_middleware(w3=self.interface.w3, poa=poa, free_transactions=free_transactions)
# Generate additional ethereum accounts for testing
population = test_accounts
@ -92,14 +98,14 @@ class TesterBlockchain(Blockchain):
self.__generate_insecure_unlocked_accounts(quantity=accounts_to_make)
assert test_accounts == len(self.interface.w3.eth.accounts)
if airdrop is True: # ETH for everyone!
if eth_airdrop is True: # ETH for everyone!
self.ether_airdrop(amount=DEVELOPMENT_ETH_AIRDROP_AMOUNT)
@staticmethod
def free_gas_price_strategy(w3, transaction_params=None):
return 0
def attach_middleware(self, w3, poa: bool = True, free_transactions: bool = True):
def attach_middleware(self, w3, poa: bool = True, free_transactions: bool = False):
# For use with Proof-Of-Authority test-blockchains
if poa:
@ -111,17 +117,38 @@ class TesterBlockchain(Blockchain):
w3.eth.setGasPriceStrategy(self.free_gas_price_strategy)
@classmethod
def sever_connection(cls) -> None:
cls._instance = NO_BLOCKCHAIN_AVAILABLE
def sever_connection(self) -> None:
Blockchain._instance = NO_BLOCKCHAIN_AVAILABLE
def __generate_insecure_unlocked_accounts(self, quantity: int) -> List[str]:
"""
Generate additional unlocked accounts transferring a balance to each account on creation.
Not for use in production - For testing only.
"""
addresses = list()
for _ in range(quantity):
privkey = '0x' + os.urandom(32).hex()
address = self.interface.provider.ethereum_tester.add_account(privkey)
# Detect provider platform - TODO: move this to interface?
client_version = self.interface.w3.clientVersion
if 'Geth' in client_version:
geth = self.interface.w3.geth
address = geth.personal.importRawKey(privkey, INSECURE_DEVELOPMENT_PASSWORD)
assert geth.personal.unlockAccount(address, INSECURE_DEVELOPMENT_PASSWORD)
elif "Parity" in client_version:
raise NotImplementedError("Parity providers are not implemented.") # TODO: Implement Parity Support
elif "TestRPC" in client_version:
pass # TODO: Mmm - nothing?
else:
# TODO: Do not fallback on tester
address = self.interface.provider.ethereum_tester.add_account(privkey)
# OK - keep this insecure account
addresses.append(address)
self._test_account_cache.append(address)
self.log.info('Generated new insecure account {}'.format(address))
@ -136,7 +163,11 @@ class TesterBlockchain(Blockchain):
tx_hashes = list()
for address in addresses:
tx = {'to': address, 'from': coinbase, 'value': amount}
tx = {'to': address,
'from': coinbase,
'value': amount,
}
txhash = self.interface.w3.eth.sendTransaction(tx)
_receipt = self.wait_for_receipt(txhash)
@ -175,6 +206,9 @@ class TesterBlockchain(Blockchain):
self.interface.w3.eth.web3.testing.mine(1)
self.log.info("Time traveled to {}".format(end_timestamp))
def sync(self, timeout: int = 0):
return True
@classmethod
def connect(cls, *args, **kwargs) -> 'TesterBlockchain':
interface = BlockchainDeployerInterface(provider_uri=cls._PROVIDER_URI,
@ -191,10 +225,10 @@ class TesterBlockchain(Blockchain):
origin = testerchain.interface.w3.eth.accounts[0]
deployer = Deployer(blockchain=testerchain, deployer_address=origin, bare=True)
random_deployment_secret = partial(os.urandom, DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
_txhashes, agents = deployer.deploy_network_contracts(miner_secret=random_deployment_secret(),
policy_secret=random_deployment_secret(),
adjudicator_secret=random_deployment_secret())
_txhashes, agents = deployer.deploy_network_contracts(miner_secret=MINERS_ESCROW_DEPLOYMENT_SECRET,
policy_secret=POLICY_MANAGER_DEPLOYMENT_SECRET,
adjudicator_secret=MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
user_escrow_proxy_secret=USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
return testerchain, agents
@property

46
nucypher/utilities/sandbox/constants.py
View File

@ -51,12 +51,20 @@ def select_test_port() -> int:
return port
MOCK_POLICY_DEFAULT_M = 3
#
# Ursula
#
MOCK_URSULA_STARTING_PORT = select_test_port()
MOCK_KNOWN_URSULAS_CACHE = dict()
NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS = 10
NUMBER_OF_ETH_TEST_ACCOUNTS = NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS + 10
NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK = NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS
#
# Testerchain
@ -64,29 +72,31 @@ MOCK_KNOWN_URSULAS_CACHE = dict()
TEST_CONTRACTS_DIR = os.path.join(BASE_DIR, 'tests', 'blockchain', 'eth', 'contracts', 'contracts')
NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS = 10
MAX_TEST_SEEDER_ENTRIES = 20
NUMBER_OF_ETH_TEST_ACCOUNTS = NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS + 10
NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK = NUMBER_OF_URSULAS_IN_BLOCKCHAIN_TESTS
ONE_YEAR_IN_SECONDS = ((60 * 60) * 24) * 365
DEVELOPMENT_TOKEN_AIRDROP_AMOUNT = NU(1_000_000, 'NU')
DEVELOPMENT_ETH_AIRDROP_AMOUNT = int(Web3().toWei(100, 'ether'))
MINERS_ESCROW_DEPLOYMENT_SECRET = os.urandom(32)
NUMBER_OF_ALLOCATIONS_IN_TESTS = 100 # TODO: Move to constants
POLICY_MANAGER_DEPLOYMENT_SECRET = os.urandom(32)
MINING_ADJUDICATOR_DEPLOYMENT_SECRET = os.urandom(32)
USER_ESCROW_PROXY_DEPLOYMENT_SECRET = os.urandom(32)
#
# Insecure Secrets
#
INSECURE_DEVELOPMENT_PASSWORD = ''.join(SystemRandom().choice(ascii_uppercase + digits) for _ in range(16))
MAX_TEST_SEEDER_ENTRIES = 20
MINERS_ESCROW_DEPLOYMENT_SECRET = INSECURE_DEVELOPMENT_PASSWORD + str(os.urandom(16))
POLICY_MANAGER_DEPLOYMENT_SECRET = INSECURE_DEVELOPMENT_PASSWORD + str(os.urandom(16))
USER_ESCROW_PROXY_DEPLOYMENT_SECRET = INSECURE_DEVELOPMENT_PASSWORD + str(os.urandom(16))
MINING_ADJUDICATOR_DEPLOYMENT_SECRET = INSECURE_DEVELOPMENT_PASSWORD + str(os.urandom(16))
ONE_YEAR_IN_SECONDS = ((60 * 60) * 24) * 365
#
# Temporary Directories and Files
@ -106,7 +116,7 @@ MOCK_CUSTOM_INSTALLATION_PATH_2 = '/tmp/nucypher-tmp-test-custom-2-{}'.format(ti
MOCK_REGISTRY_FILEPATH = os.path.join(BASE_TEMP_DIR, f'{BASE_TEMP_PREFIX}mock-registry-{str(datetime.now())}.json')
TEMPORARY_DOMAIN = b':TEMPORARY_DOMAIN:' # for use with `--dev` node runtimes
TEMPORARY_DOMAIN = ':TEMPORARY_DOMAIN:' # for use with `--dev` node runtimes
GETH_DEV_URI = f'ipc://{BASE_TEMP_DIR}/geth.ipc' # Standard IPC path for `geth --dev`
@ -119,10 +129,18 @@ TEST_PROVIDER_URI = PYEVM_DEV_URI # TODO: Pytest flag entry point?
# Node Configuration
#
MOCK_POLICY_DEFAULT_M = 3
MOCK_IP_ADDRESS = '0.0.0.0'
MOCK_IP_ADDRESS_2 = '10.10.10.10'
MOCK_URSULA_DB_FILEPATH = ':memory:'
PYEVM_GAS_LIMIT = 8_000_000 # TODO: move elsewhere (used to set pyevm gas limit in tests)?
#
# Gas
#
TEST_GAS_LIMIT = 8_000_000
PYEVM_GAS_LIMIT = TEST_GAS_LIMIT # TODO: move elsewhere (used to set pyevm gas limit in tests)?

5
nucypher/utilities/sandbox/policy.py
View File

@ -64,15 +64,16 @@ class MockPolicyCreation:
Simple mock logic to avoid repeated hammering of blockchain policies.
"""
waited_for_receipt = False
_ether_address = None
tx_hash = "THIS HAS BEEN A TRANSACTION!"
def __init__(self, *args, **kwargs):
# TODO: Test that proper arguments are passed here once 316 is closed.
pass
def transact(self, alice, payload):
def transact(self, payload):
# TODO: Make a meaningful assertion regarding the value.
assert payload['from'] == alice._ether_address
assert payload['from'] == self._ether_address
return self.tx_hash
@classmethod

7
nucypher/utilities/sandbox/ursula.py
View File

@ -108,13 +108,6 @@ def make_decentralized_ursulas(ursula_config: UrsulaConfiguration,
port = ursula.rest_information()[0].port
MOCK_KNOWN_URSULAS_CACHE[port] = ursula
if know_each_other:
for ursula_to_teach in ursulas:
# Add other Ursulas as known nodes.
for ursula_to_learn_about in ursulas:
ursula_to_teach.remember_node(ursula_to_learn_about)
return ursulas

4
scripts/local_fleet/run_local_fleet.sh
View File

@ -1,5 +1,6 @@
#!/usr/bin/env bash
set -e
echo "Starting Local Development Fleet..."
# Boring Setup Stuff
@ -17,7 +18,7 @@ export NUCYPHER_FILE_LOGS=0
# Run Node #1 (Lonely Ursula)
echo "Starting Lonely Ursula..."
python3 "${0%/*}"/../local_fleet/run_lonely_ursula.py > /tmp/ursulas-logs/ursula-11500.txt 2>&1 &
sleep 1
sleep 2
# Connect Node #2 to Lonely Ursula
echo "Starting Ursula #2..."
@ -27,4 +28,3 @@ sleep 1
# Connect Node #3 to the local Fleet
echo "Starting Ursula #3..."
nucypher --debug ursula run --dev --federated-only --teacher-uri localhost:11500 --rest-port 11502 > /tmp/ursulas-logs/ursula-11502.txt 2>&1 &
sleep 1

2
scripts/local_fleet/run_single_ursula.py
View File

@ -30,7 +30,7 @@ from nucypher.utilities.sandbox.constants import select_test_port
click_runner = CliRunner()
DEMO_NODE_PORT = select_test_port()
DEMO_FLEET_STARTING_PORT = 11501
DEMO_FLEET_STARTING_PORT = 11500
args = ['--debug',
'ursula', 'run',

26
tests/blockchain/eth/clients/test_geth_integration.py Normal file
View File

@ -0,0 +1,26 @@
import os
import pytest
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.crypto.api import verify_eip_191
#
# NOTE: This module is skipped on CI
#
def test_geth_EIP_191_client_signature_integration(geth_dev_node):
if 'CIRCLECI' in os.environ:
pytest.skip("Do not run Geth nodes in CI")
# Start a geth process
blockchain = Blockchain.connect(provider_process=geth_dev_node, sync=False)
# Sign a message (RPC) and verify it.
etherbase = blockchain.interface.accounts[0]
stamp = b'STAMP-' + os.urandom(64)
signature = blockchain.interface.client.sign_message(account=etherbase, message=stamp)
is_valid = verify_eip_191(address=etherbase,
signature=signature,
message=stamp)
assert is_valid

108
tests/blockchain/eth/clients/test_mocked_clients.py Normal file
View File

@ -0,0 +1,108 @@
from nucypher.blockchain.eth.clients import (
GethClient,
ParityClient,
GanacheClient,
PUBLIC_CHAINS
)
from nucypher.blockchain.eth.interfaces import BlockchainInterface
class MockGethProvider:
clientVersion = 'Geth/v1.4.11-stable-fed692f6/darwin/go1.7'
class MockParityProvider:
clientVersion = 'Parity-Ethereum/v2.5.1-beta-e0141f8-20190510/x86_64-linux-gnu/rustc1.34.1'
class MockGanacheProvider:
clientVersion = 'EthereumJS TestRPC/v2.1.5/ethereum-js'
class ChainIdReporter:
# Support older and newer versions of web3 py in-test
version = 5
chainID = 5
class MockWeb3:
net = ChainIdReporter
def __init__(self, provider):
self.provider = provider
@property
def clientVersion(self):
return self.provider.clientVersion
class BlockChainInterfaceTestBase(BlockchainInterface):
Web3 = MockWeb3
def _configure_registry(self, *args, **kwargs):
pass
def _setup_solidity(self, *args, **kwargs):
pass
class GethClientTestInterface(BlockChainInterfaceTestBase):
def _get_IPC_provider(self):
return MockGethProvider()
@property
def is_local(self):
return int(self.w3.net.version) not in PUBLIC_CHAINS
class ParityClientTestInterface(BlockChainInterfaceTestBase):
def _get_IPC_provider(self):
return MockParityProvider()
class GanacheClientTestInterface(BlockChainInterfaceTestBase):
def _get_HTTP_provider(self):
return MockGanacheProvider()
def test_geth_web3_client():
interface = GethClientTestInterface(
provider_uri='file:///ipc.geth'
)
assert isinstance(interface.client, GethClient)
assert interface.node_technology == 'Geth'
assert interface.node_version == 'v1.4.11-stable-fed692f6'
assert interface.platform == 'darwin'
assert interface.backend == 'go1.7'
assert interface.is_local is False
assert interface.chain_id == 5
def test_parity_web3_client():
interface = ParityClientTestInterface(
provider_uri='file:///ipc.parity'
)
assert isinstance(interface.client, ParityClient)
assert interface.node_technology == 'Parity-Ethereum'
assert interface.node_version == 'v2.5.1-beta-e0141f8-20190510'
assert interface.platform == 'x86_64-linux-gnu'
assert interface.backend == 'rustc1.34.1'
def test_ganache_web3_client():
interface = GanacheClientTestInterface(provider_uri='http://ganache:8445')
assert isinstance(interface.client, GanacheClient)
assert interface.node_technology == 'EthereumJS TestRPC'
assert interface.node_version == 'v2.1.5'
assert interface.platform is None
assert interface.backend == 'ethereum-js'
assert interface.is_local

4
tests/blockchain/eth/contracts/base/test_dispatcher.py
View File

@ -23,7 +23,7 @@ from web3.exceptions import BadFunctionCallOutput
from nucypher.blockchain.eth.chains import Blockchain
SECRET_LENGTH = 32
SECRET_LENGTH = 16
@pytest.mark.slow
@ -275,7 +275,7 @@ def test_dispatcher(testerchain):
testerchain.wait_for_receipt(tx)
assert 5 == contract_instance.functions.storageValue().call()
events = rollbacks.get_all_entries()
events = rollbacks.get_all_entries() # FIXME
assert 1 == len(events)
event_args = events[0]['args']
assert contract2_lib.address == event_args['from']

8
tests/blockchain/eth/contracts/integration/test_intercontract_integration.py
View File

@ -189,13 +189,13 @@ def multisig(testerchain, escrow, policy_manager, adjudicator, user_escrow_proxy
testerchain.interface.w3.eth.accounts
contract_owners = sorted(contract_owners)
contract, _ = testerchain.interface.deploy_contract('MultiSig', 2, contract_owners)
tx = escrow.functions.transferOwnership(contract.address).transact()
tx = escrow.functions.transferOwnership(contract.address).transact({'from': creator})
testerchain.wait_for_receipt(tx)
tx = policy_manager.functions.transferOwnership(contract.address).transact()
tx = policy_manager.functions.transferOwnership(contract.address).transact({'from': creator})
testerchain.wait_for_receipt(tx)
tx = adjudicator.functions.transferOwnership(contract.address).transact()
tx = adjudicator.functions.transferOwnership(contract.address).transact({'from': creator})
testerchain.wait_for_receipt(tx)
tx = user_escrow_linker.functions.transferOwnership(contract.address).transact()
tx = user_escrow_linker.functions.transferOwnership(contract.address).transact({'from': creator})
testerchain.wait_for_receipt(tx)
return contract

28
tests/blockchain/eth/entities/actors/test_deployer.py
View File

@ -15,8 +15,6 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import os
import random
import string
@ -28,11 +26,14 @@ from nucypher.blockchain.eth.interfaces import BlockchainDeployerInterface
from nucypher.blockchain.eth.registry import InMemoryEthereumContractRegistry, InMemoryAllocationRegistry
from nucypher.blockchain.eth.sol.compile import SolidityCompiler
from nucypher.utilities.sandbox.blockchain import TesterBlockchain
from nucypher.utilities.sandbox.constants import DEVELOPMENT_ETH_AIRDROP_AMOUNT, ONE_YEAR_IN_SECONDS, \
MINERS_ESCROW_DEPLOYMENT_SECRET, POLICY_MANAGER_DEPLOYMENT_SECRET, MINING_ADJUDICATOR_DEPLOYMENT_SECRET, \
USER_ESCROW_PROXY_DEPLOYMENT_SECRET
NUMBER_OF_ALLOCATIONS_IN_TESTS = 100 # TODO: Move to constants
from nucypher.utilities.sandbox.constants import (
ONE_YEAR_IN_SECONDS,
USER_ESCROW_PROXY_DEPLOYMENT_SECRET,
MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
POLICY_MANAGER_DEPLOYMENT_SECRET,
MINERS_ESCROW_DEPLOYMENT_SECRET,
NUMBER_OF_ALLOCATIONS_IN_TESTS
)
@pytest.mark.slow()
@ -44,20 +45,17 @@ def test_rapid_deployment(token_economics):
registry=registry,
provider_uri='tester://pyevm')
blockchain = TesterBlockchain(interface=interface, airdrop=False, test_accounts=4)
blockchain = TesterBlockchain(interface=interface, eth_airdrop=False, test_accounts=4)
deployer_address = blockchain.etherbase_account
deployer = Deployer(blockchain=blockchain, deployer_address=deployer_address)
# The Big Three (+ Dispatchers)
# Deploy User Escrow, too (+ Linker)
deployer.deploy_network_contracts(miner_secret=MINERS_ESCROW_DEPLOYMENT_SECRET,
policy_secret=POLICY_MANAGER_DEPLOYMENT_SECRET,
adjudicator_secret=MINING_ADJUDICATOR_DEPLOYMENT_SECRET)
# Deploy User Escrow, too (+ Linker)
deployer.deploy_escrow_proxy(secret=USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
total_allocations = NUMBER_OF_ALLOCATIONS_IN_TESTS
adjudicator_secret=MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
user_escrow_proxy_secret=USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
all_yall = blockchain.unassigned_accounts
# Start with some hard-coded cases...
@ -75,7 +73,7 @@ def test_rapid_deployment(token_economics):
]
# Pile on the rest
for _ in range(total_allocations - len(allocation_data)):
for _ in range(NUMBER_OF_ALLOCATIONS_IN_TESTS - len(allocation_data)):
random_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase+string.digits) for _ in range(16))
acct = w3.eth.account.create(random_password)
beneficiary_address = acct.address

4
tests/blockchain/eth/entities/actors/test_miner.py
View File

@ -100,8 +100,8 @@ def test_miner_collects_staking_reward(testerchain, miner, three_agents, token_e
initial_balance = miner.token_balance
assert token_agent.get_balance(miner.checksum_public_address) == initial_balance
miner.initialize_stake(amount=NU(token_economics.minimum_allowed_locked, 'NuNit'), # Lock the minimum amount of tokens
lock_periods=int(token_economics.minimum_locked_periods)) # ... for the fewest number of periods
miner.initialize_stake(amount=token_economics.minimum_allowed_locked, # Lock the minimum amount of tokens
lock_periods=token_economics.minimum_locked_periods) # ... for the fewest number of periods
# ...wait out the lock period...
for _ in range(token_economics.minimum_locked_periods):

4
tests/blockchain/eth/entities/agents/test_user_escrow_agent.py
View File

@ -42,9 +42,9 @@ def proxy_deployer(testerchain) -> UserEscrowAgent:
# Proxy
proxy_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer_address, secret_hash=proxy_secret)
proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer_address)
proxy_deployer.deploy()
proxy_deployer.deploy( secret_hash=proxy_secret)
yield proxy_deployer

4
tests/blockchain/eth/entities/deployers/test_deploy_preallocations.py
View File

@ -29,9 +29,9 @@ def user_escrow_proxy(three_agents):
testerchain = policy_agent.blockchain
deployer = testerchain.etherbase_account
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer, secret_hash=os.urandom(32))
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer)
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy()
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy(secret_hash=os.urandom(32))
testerchain.time_travel(seconds=120)
yield escrow_proxy_deployer.contract_address
testerchain.interface.registry.clear()

10
tests/blockchain/eth/entities/deployers/test_interdeployer_integration.py
View File

@ -59,8 +59,7 @@ def test_deploy_ethereum_contracts(testerchain):
miners_escrow_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
miner_escrow_deployer = MinerEscrowDeployer(
blockchain=testerchain,
deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret))
deployer_address=origin)
assert miner_escrow_deployer.deployer_address == origin
@ -68,7 +67,7 @@ def test_deploy_ethereum_contracts(testerchain):
assert miner_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not miner_escrow_deployer.is_deployed
miner_escrow_deployer.deploy()
miner_escrow_deployer.deploy(secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret))
assert miner_escrow_deployer.is_deployed
assert len(miner_escrow_deployer.contract_address) == 42
@ -87,8 +86,7 @@ def test_deploy_ethereum_contracts(testerchain):
policy_manager_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
policy_manager_deployer = PolicyManagerDeployer(
blockchain=testerchain,
deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(policy_manager_secret))
deployer_address=origin)
assert policy_manager_deployer.deployer_address == origin
@ -96,7 +94,7 @@ def test_deploy_ethereum_contracts(testerchain):
assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not policy_manager_deployer.is_deployed
policy_manager_deployer.deploy()
policy_manager_deployer.deploy(secret_hash=testerchain.interface.w3.keccak(policy_manager_secret))
assert policy_manager_deployer.is_deployed
assert len(policy_manager_deployer.contract_address) == 42

5
tests/blockchain/eth/entities/deployers/test_miner_escrow_deployer.py
View File

@ -30,10 +30,9 @@ def test_token_deployer_and_agent(testerchain):
secret_hash = os.urandom(32)
deployer = MinerEscrowDeployer(blockchain=testerchain,
deployer_address=origin,
secret_hash=secret_hash)
deployer_address=origin)
deployment_txhashes = deployer.deploy()
deployment_txhashes = deployer.deploy(secret_hash=secret_hash)
for title, txhash in deployment_txhashes.items():
receipt = testerchain.wait_for_receipt(txhash=txhash)

11
tests/blockchain/eth/entities/deployers/test_policy_manager_deployer.py
View File

@ -37,19 +37,16 @@ def test_policy_manager_deployer(testerchain):
token_agent = token_deployer.make_agent() # 1: Token
miners_escrow_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
miner_escrow_deployer = MinerEscrowDeployer(
deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret))
miner_escrow_deployer = MinerEscrowDeployer(deployer_address=origin)
miner_escrow_deployer.deploy()
miner_escrow_deployer.deploy(secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret))
miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow
policy_manager_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
deployer = PolicyManagerDeployer(deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(policy_manager_secret))
deployer = PolicyManagerDeployer(deployer_address=origin)
deployment_txhashes = deployer.deploy()
deployment_txhashes = deployer.deploy(secret_hash=testerchain.interface.w3.keccak(policy_manager_secret))
assert len(deployment_txhashes) == 3
for title, txhash in deployment_txhashes.items():

9
tests/blockchain/eth/entities/deployers/test_user_escrow_deployer.py
View File

@ -27,10 +27,9 @@ def user_escrow_proxy(three_agents):
testerchain = policy_agent.blockchain
deployer = testerchain.etherbase_account
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer,
secret_hash=os.urandom(32))
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer)
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy()
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy(secret_hash=os.urandom(32))
testerchain.time_travel(seconds=120)
yield escrow_proxy_deployer.contract_address
testerchain.interface.registry.clear()
@ -41,9 +40,9 @@ def user_escrow_proxy(three_agents):
def test_user_escrow_deployer(three_agents, testerchain):
deployer = testerchain.etherbase_account
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer, secret_hash=os.urandom(32))
escrow_proxy_deployer = UserEscrowProxyDeployer(deployer_address=deployer)
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy()
_escrow_proxy_deployments_txhashes = escrow_proxy_deployer.deploy(secret_hash=os.urandom(32))
deployer = UserEscrowDeployer(deployer_address=deployer)

2
tests/blockchain/eth/interfaces/test_chains.py
View File

@ -33,7 +33,7 @@ def another_testerchain(solidity_compiler):
provider_uri='tester://pyevm')
testerchain = TesterBlockchain(interface=deployer_interface,
test_accounts=2*NUMBER_OF_ETH_TEST_ACCOUNTS,
airdrop=True)
eth_airdrop=True)
deployer_interface.deployer_address = testerchain.etherbase_account
yield testerchain
testerchain.sever_connection()

10
tests/characters/test_alice_can_grant_and_revoke.py
View File

@ -34,14 +34,14 @@ from nucypher.utilities.sandbox.middleware import MockRestMiddleware
from nucypher.utilities.sandbox.policy import MockPolicyCreation
@pytest.mark.skip(reason="to be implemented") # TODO
@pytest.mark.usefixtures('blockchain_ursulas')
def test_mocked_decentralized_grant(blockchain_alice, blockchain_bob, three_agents):
# Monkey patch Policy Creation
_token_agent, _miner_agent, policy_agent = three_agents
policy_agent.blockchain.wait_for_receipt = MockPolicyCreation.wait_for_receipt
policy_agent.contract.functions.createPolicy = MockPolicyCreation
_token_agent, _miner_agent, _policy_agent = three_agents
blockchain_alice.blockchain.wait_for_receipt = MockPolicyCreation.wait_for_receipt
blockchain_alice.policy_agent.contract.functions.createPolicy = MockPolicyCreation
MockPolicyCreation._ether_address = blockchain_alice.checksum_public_address
# Setup the policy details
n = 3
@ -214,7 +214,7 @@ def test_alices_powers_are_persistent(federated_ursulas, tmpdir):
# Even before creating the policies, we can know what will be its public key.
# This can be used by Enrico (i.e., a Data Source) to encrypt messages
# before Alice grants access to Bobs.
policy_pubkey = alice.get_policy_pubkey_from_label(label)
policy_pubkey = alice.get_policy_encrypting_key_from_label(label)
# Now, let's create a policy for some Bob.
m, n = 3, 4

2
tests/characters/test_bob_joins_policy_and_retrieves.py
View File

@ -77,7 +77,7 @@ def test_bob_joins_policy_and_retrieves(federated_alice,
# Now, Bob joins the policy
bob.join_policy(label=label,
alice_pubkey_sig=federated_alice.stamp,
alice_verifying_key=federated_alice.stamp,
block=True)
# In the end, Bob should know all the Ursulas

6
tests/characters/test_character_control.py
View File

@ -17,7 +17,7 @@ def test_alice_character_control_create_policy(alice_control_test_client, federa
request_data = {
'bob_encrypting_key': bytes(bob_pubkey_enc).hex(),
'bob_verifying_key': bytes(federated_bob.stamp).hex(),
'label': b64encode(bytes(b'test')).decode(),
'label': 'test',
'm': 2,
'n': 3,
}
@ -261,7 +261,7 @@ def test_character_control_lifecycle(alice_control_test_client,
# This is sidechannel policy metadata. It should be given to Bob by the
# application developer at some point.
policy_pubkey_enc_hex = alice_response_data['result']['policy_encrypting_key']
alice_pubkey_sig_hex = alice_response_data['result']['alice_verifying_key']
alice_verifying_key_hex = alice_response_data['result']['alice_verifying_key']
# Encrypt some data via Enrico control
# Alice will also be Enrico via Enrico.from_alice
@ -288,7 +288,7 @@ def test_character_control_lifecycle(alice_control_test_client,
bob_request_data = {
'label': random_label,
'policy_encrypting_key': policy_pubkey_enc_hex,
'alice_verifying_key': alice_pubkey_sig_hex,
'alice_verifying_key': alice_verifying_key_hex,
'message_kit': encoded_message_kit,
}

28
tests/characters/test_crypto_characters_and_their_powers.py
View File

@ -18,15 +18,17 @@ import eth_utils
import pytest
from constant_sorrow import constants
from cryptography.exceptions import InvalidSignature
from nucypher.characters.lawful import Alice, Character, Bob
from nucypher.characters.lawful import Enrico
from nucypher.crypto import api
from nucypher.crypto.api import verify_eip_191
from nucypher.crypto.powers import (CryptoPower,
SigningPower,
NoSigningPower,
BlockchainPower,
PowerUpError)
from nucypher.crypto.signing import InvalidSignature
"""
Chapter 1: SIGNING
@ -69,7 +71,7 @@ def test_actor_with_signing_power_can_sign():
# ...or to get the signer's public key for verification purposes.
# (note: we use the private _der_encoded_bytes here to test directly against the API, instead of Character)
verification = api.ecdsa_verify(message, signature._der_encoded_bytes(),
verification = api.verify_ecdsa(message, signature._der_encoded_bytes(),
stamp_of_the_signer.as_umbral_pubkey())
assert verification is True
@ -114,7 +116,7 @@ def test_anybody_can_verify():
assert cleartext is constants.NO_DECRYPTION_PERFORMED
def test_character_blockchain_power(testerchain):
def test_character_blockchain_power(testerchain, three_agents):
# TODO: Handle multiple providers
eth_address = testerchain.interface.w3.eth.accounts[0]
sig_privkey = testerchain.interface.provider.ethereum_tester.backend._key_lookup[
@ -132,20 +134,14 @@ def test_character_blockchain_power(testerchain):
data_to_sign = b'What does Ursula look like?!?'
sig = power.sign_message(data_to_sign)
is_verified = power.verify_message(eth_address, sig_pubkey.to_bytes(), data_to_sign, sig)
is_verified = verify_eip_191(address=eth_address, message=data_to_sign, signature=sig)
assert is_verified is True
# Test a bad message:
with pytest.raises(PowerUpError):
power.verify_message(eth_address, sig_pubkey.to_bytes(), data_to_sign + b'bad', sig)
# Test a bad address/pubkey pair
with pytest.raises(ValueError):
power.verify_message(
testerchain.interface.w3.eth.accounts[1],
sig_pubkey.to_bytes(),
data_to_sign,
sig)
is_verified = verify_eip_191(address=testerchain.interface.w3.eth.accounts[1],
message=data_to_sign,
signature=sig)
assert is_verified is False
# Test a signature without unlocking the account
power.is_unlocked = False
@ -256,14 +252,14 @@ def test_encrypt_but_do_not_sign(federated_alice, federated_bob):
assert not_signature == constants.NOT_SIGNED
# ...and thus, the message is not verified.
with pytest.raises(Character.InvalidSignature):
with pytest.raises(InvalidSignature):
federated_bob.verify_from(federated_alice, message_kit, decrypt=True)
def test_alice_can_decrypt(federated_alice):
label = b"boring test label"
policy_pubkey = federated_alice.get_policy_pubkey_from_label(label)
policy_pubkey = federated_alice.get_policy_encrypting_key_from_label(label)
enrico = Enrico(policy_encrypting_key=policy_pubkey)

38
tests/characters/test_ursula_prepares_to_act_as_mining_node.py
View File

@ -16,21 +16,19 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from eth_account._utils.signing import to_standard_signature_bytes
from eth_keys.datatypes import Signature as EthSignature
from nucypher.blockchain.eth.clients import Web3Client
from nucypher.characters.lawful import Ursula
from nucypher.characters.unlawful import Vladimir
from nucypher.crypto.api import verify_eip_191
from nucypher.crypto.powers import SigningPower, CryptoPower
from nucypher.utilities.sandbox.constants import INSECURE_DEVELOPMENT_PASSWORD
from nucypher.utilities.sandbox.middleware import MockRestMiddleware
from nucypher.utilities.sandbox.ursula import make_federated_ursulas
@pytest.mark.skip("To be implemented.")
def test_federated_ursula_substantiates_stamp():
assert False
def test_new_federated_ursula_announces_herself(ursula_federated_test_config):
ursula_in_a_house, ursula_with_a_mouse = make_federated_ursulas(ursula_config=ursula_federated_test_config,
quantity=2,
@ -55,11 +53,11 @@ def test_new_federated_ursula_announces_herself(ursula_federated_test_config):
def test_blockchain_ursula_substantiates_stamp(blockchain_ursulas):
first_ursula = list(blockchain_ursulas)[0]
signature_as_bytes = first_ursula._evidence_of_decentralized_identity
signature = EthSignature(signature_bytes=signature_as_bytes)
proper_public_key_for_first_ursula = signature.recover_public_key_from_msg(bytes(first_ursula.stamp))
proper_address_for_first_ursula = proper_public_key_for_first_ursula.to_checksum_address()
assert proper_address_for_first_ursula == first_ursula.checksum_public_address
signature_as_bytes = first_ursula.decentralized_identity_evidence
signature_as_bytes = to_standard_signature_bytes(signature_as_bytes)
assert verify_eip_191(address=first_ursula.checksum_public_address,
message=bytes(first_ursula.stamp),
signature=signature_as_bytes)
# This method is a shortcut for the above.
assert first_ursula._stamp_has_valid_wallet_signature
@ -70,7 +68,7 @@ def test_blockchain_ursula_verifies_stamp(blockchain_ursulas):
# This Ursula does not yet have a verified stamp
first_ursula.verified_stamp = False
first_ursula.stamp_is_valid()
first_ursula.validate_stamp()
# ...but now it's verified.
assert first_ursula.verified_stamp
@ -83,14 +81,15 @@ def test_vladimir_cannot_verify_interface_with_ursulas_signing_key(blockchain_ur
# so that Alice (or whomever) pays him instead of Ursula, even though Ursula is providing the service.
# He finds a target and verifies that its interface is valid.
assert his_target.interface_is_valid()
assert his_target.validate_interface()
# Now Vladimir imitates Ursula - copying her public keys and interface info, but inserting his ether address.
vladimir = Vladimir.from_target_ursula(his_target, claim_signing_key=True)
# Vladimir can substantiate the stamp using his own ether address...
vladimir.substantiate_stamp(password=INSECURE_DEVELOPMENT_PASSWORD)
vladimir.stamp_is_valid()
vladimir.substantiate_stamp(client_password=INSECURE_DEVELOPMENT_PASSWORD)
vladimir._is_valid_worker = lambda: True
vladimir.validate_stamp()
# Now, even though his public signing key matches Ursulas...
assert vladimir.stamp == his_target.stamp
@ -98,7 +97,7 @@ def test_vladimir_cannot_verify_interface_with_ursulas_signing_key(blockchain_ur
# ...he is unable to pretend that his interface is valid
# because the interface validity check contains the canonical public address as part of its message.
with pytest.raises(vladimir.InvalidNode):
vladimir.interface_is_valid()
vladimir.validate_interface()
# Consequently, the metadata as a whole is also invalid.
with pytest.raises(vladimir.InvalidNode):
@ -111,18 +110,15 @@ def test_vladimir_uses_his_own_signing_key(blockchain_alice, blockchain_ursulas)
using his own signing key, which he claims is Ursula's.
"""
his_target = list(blockchain_ursulas)[4]
fraudulent_keys = CryptoPower(power_ups=Ursula._default_crypto_powerups) # TODO: Why is this unused?
vladimir = Vladimir.from_target_ursula(target_ursula=his_target)
message = vladimir._signable_interface_info_message()
signature = vladimir._crypto_power.power_ups(SigningPower).sign(vladimir.timestamp_bytes() + message)
vladimir._interface_signature_object = signature
vladimir.substantiate_stamp(password=INSECURE_DEVELOPMENT_PASSWORD)
vladimir._Teacher__interface_signature = signature
vladimir.substantiate_stamp(client_password=INSECURE_DEVELOPMENT_PASSWORD)
# With this slightly more sophisticated attack, his metadata does appear valid.
vladimir._is_valid_worker = lambda: True # bypass staking verification TODO: Split into two tests
vladimir.validate_metadata()
# However, the actual handshake proves him wrong.

65
tests/cli/conftest.py
View File

@ -19,9 +19,9 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import contextlib
import json
import os
import shutil
import pytest
import shutil
from click.testing import CliRunner
from nucypher.blockchain.eth.registry import AllocationRegistry
@ -30,9 +30,12 @@ from nucypher.utilities.sandbox.constants import (
MOCK_CUSTOM_INSTALLATION_PATH,
MOCK_ALLOCATION_INFILE,
MOCK_REGISTRY_FILEPATH,
ONE_YEAR_IN_SECONDS
)
from nucypher.utilities.sandbox.constants import MOCK_CUSTOM_INSTALLATION_PATH_2
ONE_YEAR_IN_SECONDS,
MINERS_ESCROW_DEPLOYMENT_SECRET,
POLICY_MANAGER_DEPLOYMENT_SECRET,
MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
from nucypher.utilities.sandbox.constants import MOCK_CUSTOM_INSTALLATION_PATH_2, INSECURE_DEVELOPMENT_PASSWORD
@pytest.fixture(scope='module')
@ -41,6 +44,15 @@ def click_runner():
yield runner
@pytest.fixture(scope='session')
def deploy_user_input():
account_index = '0\n'
yes = 'Y\n'
deployment_secret = f'{INSECURE_DEVELOPMENT_PASSWORD}\n'
user_input = account_index + yes + (deployment_secret * 8) + 'DEPLOY'
return user_input
@pytest.fixture(scope='module')
def nominal_federated_configuration_fields():
config = UrsulaConfiguration(dev_mode=True, federated_only=True)
@ -52,11 +64,15 @@ def nominal_federated_configuration_fields():
@pytest.fixture(scope='module')
def mock_allocation_infile(testerchain, token_economics):
accounts = testerchain.interface.w3.eth.accounts[5::]
allocation_data = [{'address': addr, 'amount': token_economics.maximum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS} for addr in accounts]
accounts = testerchain.unassigned_accounts
allocation_data = [{'address': addr,
'amount': token_economics.minimum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS}
for addr in accounts]
with open(MOCK_ALLOCATION_INFILE, 'w') as file:
file.write(json.dumps(allocation_data))
registry = AllocationRegistry(registry_filepath=MOCK_ALLOCATION_INFILE)
yield registry
os.remove(MOCK_ALLOCATION_INFILE)
@ -93,6 +109,41 @@ def custom_filepath_2():
shutil.rmtree(_custom_filepath, ignore_errors=True)
@pytest.fixture(scope='session')
def deployed_blockchain(token_economics):
# Interface
compiler = SolidityCompiler()
registry = InMemoryEthereumContractRegistry()
allocation_registry = InMemoryAllocationRegistry()
interface = BlockchainDeployerInterface(compiler=compiler,
registry=registry,
provider_uri=TEST_PROVIDER_URI)
# Blockchain
blockchain = TesterBlockchain(interface=interface, eth_airdrop=True, test_accounts=5, poa=True)
deployer_address = blockchain.etherbase_account
# Deployer
deployer = Deployer(blockchain=blockchain, deployer_address=deployer_address)
# The Big Three (+ Dispatchers)
deployer.deploy_network_contracts(miner_secret=MINERS_ESCROW_DEPLOYMENT_SECRET,
policy_secret=POLICY_MANAGER_DEPLOYMENT_SECRET,
adjudicator_secret=MINING_ADJUDICATOR_DEPLOYMENT_SECRET,
user_escrow_proxy_secret=USER_ESCROW_PROXY_DEPLOYMENT_SECRET)
# Start with some hard-coded cases...
all_yall = blockchain.unassigned_accounts
allocation_data = [{'address': all_yall[1],
'amount': token_economics.maximum_allowed_locked,
'duration': ONE_YEAR_IN_SECONDS}]
deployer.deploy_beneficiary_contracts(allocations=allocation_data, allocation_registry=allocation_registry)
yield blockchain, deployer_address, registry
@pytest.fixture(scope='module')
def custom_filepath_2():
_custom_filepath = MOCK_CUSTOM_INSTALLATION_PATH_2

1
tests/cli/test_alice.py
View File

@ -44,7 +44,6 @@ def test_alice_control_starts_mocked(click_runner, mocker):
user_input = '{password}\n{password}\n'.format(password=INSECURE_DEVELOPMENT_PASSWORD)
result = click_runner.invoke(nucypher_cli, init_args, input=user_input)
assert result.exit_code == 0
assert MockKeyring.is_unlocked
def test_initialize_alice_with_custom_configuration_root(custom_filepath, click_runner):

6
tests/cli/test_cli_lifecycle.py
View File

@ -65,7 +65,6 @@ class MockSideChannel:
return policy
# @pytest.mark.slow
@pt.inlineCallbacks
def test_cli_lifecycle(click_runner,
random_policy_label,
@ -242,11 +241,12 @@ def test_cli_lifecycle(click_runner,
grant_args = ('--mock-networking',
'--json-ipc',
'alice', 'grant',
'--network', TEMPORARY_DOMAIN,
'--federated-only',
'--teacher-uri', teacher_uri,
'--config-file', alice_configuration_file_location,
'--m', 2,
'--n', 3,
'--m', 1, # TODO: Use more than 1 of 1
'--n', 1,
'--label', random_label,
'--bob-encrypting-key', bob_encrypting_key,
'--bob-verifying-key', bob_verifying_key)

325
tests/cli/test_deploy.py
View File

@ -1,5 +1,9 @@
import json
import os
from random import SystemRandom
from string import ascii_uppercase, digits
import pytest
from nucypher.blockchain.eth.actors import Deployer
from nucypher.blockchain.eth.agents import (
@ -9,27 +13,86 @@ from nucypher.blockchain.eth.agents import (
PolicyAgent,
MiningAdjudicatorAgent
)
from nucypher.blockchain.eth.registry import AllocationRegistry
from nucypher.blockchain.eth.chains import Blockchain
from nucypher.blockchain.eth.interfaces import BlockchainDeployerInterface, BlockchainInterface
from nucypher.blockchain.eth.registry import AllocationRegistry, EthereumContractRegistry
from nucypher.blockchain.eth.sol.compile import SolidityCompiler
from nucypher.cli.deploy import deploy
from nucypher.config.constants import DEFAULT_CONFIG_ROOT
from nucypher.utilities.sandbox.blockchain import TesterBlockchain
from nucypher.utilities.sandbox.constants import (
INSECURE_DEVELOPMENT_PASSWORD,
TEST_PROVIDER_URI,
MOCK_ALLOCATION_INFILE,
MOCK_REGISTRY_FILEPATH, MOCK_ALLOCATION_REGISTRY_FILEPATH)
MOCK_REGISTRY_FILEPATH,
MOCK_ALLOCATION_REGISTRY_FILEPATH,
INSECURE_DEVELOPMENT_PASSWORD
)
def test_nucypher_deploy_contracts(testerchain, click_runner, mock_primary_registry_filepath):
def generate_insecure_secret() -> str:
insecure_secret = ''.join(SystemRandom().choice(ascii_uppercase + digits) for _ in range(16))
formatted_secret = insecure_secret + '\n'
return formatted_secret
PLANNED_UPGRADES = 4
INSECURE_SECRETS = {v: generate_insecure_secret() for v in range(1, PLANNED_UPGRADES+1)}
def make_testerchain(provider_uri, solidity_compiler):
# Destroy existing blockchain
BlockchainInterface.disconnect()
TesterBlockchain.sever_connection()
registry = EthereumContractRegistry(registry_filepath=MOCK_REGISTRY_FILEPATH)
deployer_interface = BlockchainDeployerInterface(compiler=solidity_compiler,
registry=registry,
provider_uri=provider_uri)
# Create new blockchain
testerchain = TesterBlockchain(interface=deployer_interface,
eth_airdrop=True,
free_transactions=False,
poa=True)
# Set the deployer address from a freshly created test account
deployer_interface.deployer_address = testerchain.etherbase_account
return testerchain
def pyevm_testerchain():
return 'tester://pyevm'
def geth_poa_devchain():
_testerchain = make_testerchain(provider_uri='tester://geth', solidity_compiler=SolidityCompiler())
return f'ipc://{_testerchain.interface.provider.ipc_path}'
def test_nucypher_deploy_contracts(click_runner,
mock_primary_registry_filepath,
mock_allocation_infile,
token_economics):
#
# Setup
#
# We start with a blockchain node, and nothing else...
if os.path.isfile(mock_primary_registry_filepath):
os.remove(mock_primary_registry_filepath)
assert not os.path.isfile(mock_primary_registry_filepath)
command = ('contracts',
#
# Main
#
command = ['contracts',
'--registry-outfile', mock_primary_registry_filepath,
'--provider-uri', TEST_PROVIDER_URI,
'--poa')
'--poa']
user_input = 'Y\n'+f'{INSECURE_DEVELOPMENT_PASSWORD}\n'*8
user_input = '0\n' + 'Y\n' + (f'{INSECURE_SECRETS[1]}\n' * 8) + 'DEPLOY'
result = click_runner.invoke(deploy, command, input=user_input, catch_exceptions=False)
assert result.exit_code == 0
@ -69,21 +132,233 @@ def test_nucypher_deploy_contracts(testerchain, click_runner, mock_primary_regis
# and at least the others can be instantiated
assert PolicyAgent()
assert MiningAdjudicatorAgent()
testerchain.sever_connection()
def test_nucypher_deploy_allocations(testerchain, click_runner, mock_allocation_infile, token_economics):
def test_upgrade_contracts(click_runner):
#
# Setup
#
# Connect to the blockchain with a blank temporary file-based registry
mock_temporary_registry = EthereumContractRegistry(registry_filepath=MOCK_REGISTRY_FILEPATH)
blockchain = Blockchain.connect(registry=mock_temporary_registry)
# Check the existing state of the registry before the meat and potatoes
expected_registrations = 9
with open(MOCK_REGISTRY_FILEPATH, 'r') as file:
raw_registry_data = file.read()
registry_data = json.loads(raw_registry_data)
assert len(registry_data) == expected_registrations
#
# Input Components
#
cli_action = 'upgrade'
base_command = ('--registry-infile', MOCK_REGISTRY_FILEPATH, '--provider-uri', TEST_PROVIDER_URI, '--poa')
# Generate user inputs
yes = 'Y\n' # :-)
upgrade_inputs = dict()
for version, insecure_secret in INSECURE_SECRETS.items():
next_version = version + 1
old_secret = INSECURE_SECRETS[version]
try:
new_secret = INSECURE_SECRETS[next_version]
except KeyError:
continue
# addr-----secret----new deploy secret (2x for confirmation)
user_input = '0\n' + yes + old_secret + (new_secret * 2)
upgrade_inputs[next_version] = user_input
#
# Stage Upgrades
#
contracts_to_upgrade = ('MinersEscrow', # v1 -> v2
'PolicyManager', # v1 -> v2
'MiningAdjudicator', # v1 -> v2
'UserEscrowProxy', # v1 -> v2
'MinersEscrow', # v2 -> v3
'MinersEscrow', # v3 -> v4
'MiningAdjudicator', # v2 -> v3
'PolicyManager', # v2 -> v3
'UserEscrowProxy', # v2 -> v3
'UserEscrowProxy', # v3 -> v4
'PolicyManager', # v3 -> v4
'MiningAdjudicator', # v3 -> v4
) # NOTE: Keep all versions the same in this test (all version 4, for example)
# Each contract starts at version 1
version_tracker = {name: 1 for name in contracts_to_upgrade}
#
# Upgrade Contracts
#
for contract_name in contracts_to_upgrade:
# Assemble CLI command
command = (cli_action, '--contract-name', contract_name, *base_command)
# Select upgrade interactive input scenario
current_version = version_tracker[contract_name]
new_version = current_version + 1
user_input = upgrade_inputs[new_version]
# Execute upgrade (Meat)
result = click_runner.invoke(deploy, command, input=user_input, catch_exceptions=False)
assert result.exit_code == 0 # TODO: Console painting
# Mutate the version tracking
version_tracker[contract_name] += 1
expected_registrations += 1
# Verify the registry is updated (Potatoes)
with open(MOCK_REGISTRY_FILEPATH, 'r') as file:
# Read the registry file directly, bypassing its interfaces
raw_registry_data = file.read()
registry_data = json.loads(raw_registry_data)
assert len(registry_data) == expected_registrations
# Check that there is more than one entry, since we've deployed a "version 2"
expected_enrollments = current_version + 1
registered_names = [r[0] for r in registry_data]
enrollments = registered_names.count(contract_name)
assert enrollments > 1, f"New contract is not enrolled in {MOCK_REGISTRY_FILEPATH}"
assert enrollments == expected_enrollments, f"Incorrect number of records enrolled for {contract_name}. " \
f"Expected {expected_enrollments} got {enrollments}."
# Ensure deployments are different addresses
records = blockchain.interface.registry.search(contract_name=contract_name)
assert len(records) == expected_enrollments
old, new = records[-2:] # Get the last two entries
old_name, old_address, *abi = old # Previous version
new_name, new_address, *abi = new # New version
assert old_name == new_name # TODO: Inspect ABI?
assert old_address != new_address
# Select proxy (Dispatcher vs Linker)
if contract_name == "UserEscrowProxy":
proxy_name = "UserEscrowLibraryLinker"
else:
proxy_name = 'Dispatcher'
# Ensure the proxy targets the new deployment
proxy = blockchain.interface.get_proxy(target_address=new_address, proxy_name=proxy_name)
targeted_address = proxy.functions.target().call()
assert targeted_address != old_address
assert targeted_address == new_address
def test_rollback(click_runner):
"""Roll 'em all back!"""
mock_temporary_registry = EthereumContractRegistry(registry_filepath=MOCK_REGISTRY_FILEPATH)
blockchain = Blockchain.connect(registry=mock_temporary_registry)
# Input Components
yes = 'Y\n'
# Stage Rollbacks
old_secret = INSECURE_SECRETS[PLANNED_UPGRADES]
rollback_secret = generate_insecure_secret()
user_input = '0\n' + yes + old_secret + rollback_secret + rollback_secret
contracts_to_rollback = ('MinersEscrow', # v4 -> v3
'PolicyManager', # v4 -> v3
'MiningAdjudicator', # v4 -> v3
)
# Execute Rollbacks
for contract_name in contracts_to_rollback:
command = ('rollback',
'--contract-name', contract_name,
'--registry-infile', MOCK_REGISTRY_FILEPATH,
'--provider-uri', TEST_PROVIDER_URI,
'--poa')
result = click_runner.invoke(deploy, command, input=user_input, catch_exceptions=False)
assert result.exit_code == 0
records = blockchain.interface.registry.search(contract_name=contract_name)
assert len(records) == 4
*old_records, v3, v4 = records
current_target, rollback_target = v4, v3
_name, current_target_address, *abi = current_target
_name, rollback_target_address, *abi = rollback_target
assert current_target_address != rollback_target_address
# Ensure the proxy targets the rollback target (previous version)
with pytest.raises(BlockchainInterface.UnknownContract):
blockchain.interface.get_proxy(target_address=current_target_address, proxy_name='Dispatcher')
proxy = blockchain.interface.get_proxy(target_address=rollback_target_address, proxy_name='Dispatcher')
# Deeper - Ensure the proxy targets the old deployment on-chain
targeted_address = proxy.functions.target().call()
assert targeted_address != current_target
assert targeted_address == rollback_target_address
def test_nucypher_deploy_allocation_contracts(click_runner,
testerchain,
deploy_user_input,
mock_primary_registry_filepath,
mock_allocation_infile,
token_economics):
TesterBlockchain.sever_connection()
if os.path.isfile(MOCK_ALLOCATION_REGISTRY_FILEPATH):
os.remove(MOCK_ALLOCATION_REGISTRY_FILEPATH)
assert not os.path.isfile(MOCK_ALLOCATION_REGISTRY_FILEPATH)
# We start with a blockchain node, and nothing else...
if os.path.isfile(mock_primary_registry_filepath):
os.remove(mock_primary_registry_filepath)
assert not os.path.isfile(mock_primary_registry_filepath)
command = ['contracts',
'--registry-outfile', mock_primary_registry_filepath,
'--provider-uri', 'tester://pyevm',
'--poa',
'--no-sync']
user_input = deploy_user_input
result = click_runner.invoke(deploy, command, input=user_input, catch_exceptions=False)
assert result.exit_code == 0
#
# Main
#
deploy_command = ('allocations',
'--registry-infile', MOCK_REGISTRY_FILEPATH,
'--allocation-infile', MOCK_ALLOCATION_INFILE,
'--allocation-infile', mock_allocation_infile.filepath,
'--allocation-outfile', MOCK_ALLOCATION_REGISTRY_FILEPATH,
'--provider-uri', TEST_PROVIDER_URI,
'--poa',
)
'--provider-uri', 'tester://pyevm',
'--poa')
user_input = 'Y\n'*2
result = click_runner.invoke(deploy, deploy_command,
account_index = '0\n'
yes = 'Y\n'
node_password = f'{INSECURE_DEVELOPMENT_PASSWORD}\n'
user_input = account_index + yes + node_password + yes
result = click_runner.invoke(deploy,
deploy_command,
input=user_input,
catch_exceptions=False)
assert result.exit_code == 0
@ -92,7 +367,14 @@ def test_nucypher_deploy_allocations(testerchain, click_runner, mock_allocation_
beneficiary = testerchain.interface.w3.eth.accounts[-1]
allocation_registry = AllocationRegistry(registry_filepath=MOCK_ALLOCATION_REGISTRY_FILEPATH)
user_escrow_agent = UserEscrowAgent(beneficiary=beneficiary, allocation_registry=allocation_registry)
assert user_escrow_agent.unvested_tokens == token_economics.maximum_allowed_locked
assert user_escrow_agent.unvested_tokens == token_economics.minimum_allowed_locked
#
# Tear Down
#
# Destroy existing blockchain
BlockchainInterface.disconnect()
def test_destroy_registry(click_runner, mock_primary_registry_filepath):
@ -101,10 +383,13 @@ def test_destroy_registry(click_runner, mock_primary_registry_filepath):
destroy_command = ('destroy-registry',
'--registry-infile', mock_primary_registry_filepath,
'--provider-uri', TEST_PROVIDER_URI,
'--poa',
)
'--poa')
# TODO: #1036 - Providers and unlocking are not needed for this command
account_index = '0\n'
yes = 'Y\n'
user_input = account_index + yes + yes
user_input = 'Y\n'*2
result = click_runner.invoke(deploy, destroy_command, input=user_input, catch_exceptions=False)
assert result.exit_code == 0
assert mock_primary_registry_filepath in result.output

18
tests/cli/test_felix.py
View File

@ -19,7 +19,10 @@ from nucypher.utilities.sandbox.constants import (
@pytest_twisted.inlineCallbacks
def test_run_felix(click_runner, testerchain, federated_ursulas, mock_primary_registry_filepath):
def test_run_felix(click_runner,
testerchain,
deploy_user_input,
mock_primary_registry_filepath):
clock = Clock()
Felix._CLOCK = clock
@ -41,8 +44,7 @@ def test_run_felix(click_runner, testerchain, federated_ursulas, mock_primary_re
'--provider-uri', TEST_PROVIDER_URI,
'--poa')
user_input = 'Y\n'+f'{INSECURE_DEVELOPMENT_PASSWORD}\n'*8 # TODO: Use Env Vars
result = click_runner.invoke(deploy.deploy, deploy_args, input=user_input, catch_exceptions=False, env=envvars)
result = click_runner.invoke(deploy.deploy, deploy_args, input=deploy_user_input, catch_exceptions=False, env=envvars)
assert result.exit_code == 0
# Felix creates a system configuration
@ -104,6 +106,13 @@ def test_run_felix(click_runner, testerchain, federated_ursulas, mock_primary_re
def time_travel(_result):
clock.advance(amount=60)
# Record starting ether balance
recipient = testerchain.interface.w3.eth.accounts[-1]
miner = Miner(checksum_address=recipient,
blockchain=testerchain,
is_me=True)
original_eth_balance = miner.eth_balance
# Run the callbacks
d = threads.deferToThread(run_felix)
d.addCallback(request_felix_landing_page)
@ -119,6 +128,9 @@ def test_run_felix(click_runner, testerchain, federated_ursulas, mock_primary_re
assert miner.token_balance == NU(15000, 'NU')
new_eth_balance = original_eth_balance + testerchain.interface.w3.fromWei(Felix.ETHER_AIRDROP_AMOUNT, 'ether')
assert miner.eth_balance == new_eth_balance
staged_airdrops = Felix._AIRDROP_QUEUE
next_airdrop = staged_airdrops[0]
next_airdrop.addCallback(confirm_airdrop)

14
tests/cli/test_mixed_configurations.py
View File

@ -17,7 +17,8 @@ from nucypher.utilities.sandbox.constants import (
def test_coexisting_configurations(click_runner,
custom_filepath,
mock_primary_registry_filepath,
testerchain):
testerchain,
deploy_user_input):
# Parse node addresses
deployer, alice, ursula, another_ursula, *all_yall = testerchain.interface.w3.eth.accounts
@ -25,7 +26,7 @@ def test_coexisting_configurations(click_runner,
envvars = {'NUCYPHER_KEYRING_PASSWORD': INSECURE_DEVELOPMENT_PASSWORD,
# Upgradeable Contracts
'NUCYPHER_MINER_ESCROW_SECRET': INSECURE_DEVELOPMENT_PASSWORD,
'NUCYPHER_MINERS_ESCROW_SECRET': INSECURE_DEVELOPMENT_PASSWORD,
'NUCYPHER_POLICY_MANAGER_SECRET': INSECURE_DEVELOPMENT_PASSWORD,
'NUCYPHER_MINING_ADJUDICATOR_SECRET': INSECURE_DEVELOPMENT_PASSWORD,
'NUCYPHER_USER_ESCROW_PROXY_SECRET': INSECURE_DEVELOPMENT_PASSWORD,
@ -45,11 +46,13 @@ def test_coexisting_configurations(click_runner,
deploy_args = ('contracts',
'--registry-outfile', mock_primary_registry_filepath,
'--provider-uri', TEST_PROVIDER_URI,
'--deployer-address', deployer,
'--config-root', custom_filepath,
'--poa')
result = click_runner.invoke(deploy.deploy, deploy_args, input='Y', catch_exceptions=False, env=envvars)
result = click_runner.invoke(deploy.deploy,
deploy_args,
input=f'0\nY\nDEPLOY', # TODO: Centralized location for intractive inputs
catch_exceptions=False, env=envvars)
assert result.exit_code == 0
# No keys have been generated...
@ -94,7 +97,7 @@ def test_coexisting_configurations(click_runner,
alice_init_args = ('alice', 'init',
'--network', TEMPORARY_DOMAIN,
'--provider-uri', TEST_PROVIDER_URI,
'--checksum-address', alice,
'--pay-with', alice,
'--registry-filepath', mock_primary_registry_filepath,
'--config-root', custom_filepath)
@ -193,6 +196,7 @@ def test_corrupted_configuration(click_runner, custom_filepath, testerchain, moc
deployer, alice, ursula, another_ursula, *all_yall = testerchain.interface.w3.eth.accounts
init_args = ('ursula', 'init',
'--provider-uri', TEST_PROVIDER_URI,
'--network', TEMPORARY_DOMAIN,
'--rest-host', MOCK_IP_ADDRESS,
'--config-root', custom_filepath)

31
tests/cli/ursula/test_blockchain_ursula.py
View File

@ -11,7 +11,7 @@ from nucypher.blockchain.eth.agents import MinerAgent
from nucypher.blockchain.eth.token import NU
from nucypher.characters.lawful import Enrico
from nucypher.cli.main import nucypher_cli
from nucypher.config.characters import UrsulaConfiguration
from nucypher.config.characters import UrsulaConfiguration, BobConfiguration
from nucypher.utilities.sandbox.constants import (
MOCK_CUSTOM_INSTALLATION_PATH,
MOCK_IP_ADDRESS,
@ -30,6 +30,26 @@ def configuration_file_location(custom_filepath):
return _configuration_file_location
@pytest.fixture(scope="module")
def charlie_blockchain_test_config(blockchain_ursulas, three_agents):
token_agent, miner_agent, policy_agent = three_agents
etherbase, alice_address, bob_address, *everyone_else = token_agent.blockchain.interface.w3.eth.accounts
config = BobConfiguration(dev_mode=True,
provider_uri=TEST_PROVIDER_URI,
checksum_public_address=bob_address,
network_middleware=MockRestMiddleware(),
known_nodes=blockchain_ursulas,
start_learning_now=False,
abort_on_learning_error=True,
federated_only=False,
download_registry=False,
save_metadata=False,
reload_metadata=False)
yield config
config.cleanup()
@pytest.fixture(scope='module')
def mock_registry_filepath(testerchain):
@ -52,7 +72,7 @@ def test_initialize_system_blockchain_configuration(click_runner,
init_args = ('ursula', 'init',
'--poa',
'--network', str(TEMPORARY_DOMAIN, encoding='utf-8'),
'--network', TEMPORARY_DOMAIN,
'--checksum-address', staking_participant.checksum_public_address,
'--config-root', custom_filepath,
'--provider-uri', TEST_PROVIDER_URI,
@ -80,7 +100,7 @@ def test_initialize_system_blockchain_configuration(click_runner,
config_data = json.loads(raw_config_data)
assert config_data['provider_uri'] == TEST_PROVIDER_URI
assert config_data['checksum_public_address'] == staking_participant.checksum_public_address
assert str(TEMPORARY_DOMAIN, encoding='utf-8') in config_data['domains']
assert TEMPORARY_DOMAIN in config_data['domains']
def test_init_ursula_stake(click_runner,
@ -209,7 +229,9 @@ def test_collect_rewards_integration(click_runner,
expiration=expiration,
handpicked_ursulas={staking_participant})
# Bob joins the policy
# Bob learns about the new staker and joins the policy
blockchain_bob.start_learning_loop()
blockchain_bob.remember_node(node=staking_participant)
blockchain_bob.join_policy(random_policy_label, bytes(blockchain_alice.stamp))
# Enrico Encrypts (of course)
@ -256,6 +278,7 @@ def test_collect_rewards_integration(click_runner,
collection_args = ('--mock-networking',
'ursula', 'collect-reward',
'--rest-host', MOCK_IP_ADDRESS,
'--teacher-uri', random_teacher.rest_interface,
'--config-file', configuration_file_location,
'--withdraw-address', burner_wallet.address,

12
tests/cli/ursula/test_federated_ursula.py
View File

@ -43,12 +43,12 @@ def test_initialize_ursula_defaults(click_runner, mocker):
'--network', TEMPORARY_DOMAIN,
'--federated-only')
user_input = '{ip}\n{password}\n{password}\n'.format(password=INSECURE_DEVELOPMENT_PASSWORD, ip=MOCK_IP_ADDRESS)
user_input = 'Y\n{password}\n{password}\n'.format(password=INSECURE_DEVELOPMENT_PASSWORD, ip=MOCK_IP_ADDRESS)
result = click_runner.invoke(nucypher_cli, init_args, input=user_input, catch_exceptions=False)
assert result.exit_code == 0
# REST Host
assert 'Enter Ursula\'s public-facing IPv4 address' in result.output
assert 'Is this the public-facing IPv4 address' in result.output
# Auth
assert 'Enter keyring password:' in result.output, 'WARNING: User was not prompted for password'
@ -117,7 +117,7 @@ def test_password_prompt(click_runner, custom_filepath):
custom_config_filepath = os.path.join(custom_filepath, UrsulaConfiguration.CONFIG_FILENAME)
assert os.path.isfile(custom_config_filepath), 'Configuration file does not exist'
view_args = ('ursula', 'view', '--config-file', custom_config_filepath)
view_args = ('ursula', 'view', '--config-file', custom_config_filepath, '--federated-only')
user_input = '{}\n'.format(INSECURE_DEVELOPMENT_PASSWORD)
result = click_runner.invoke(nucypher_cli, view_args, input=user_input, catch_exceptions=False, env=dict())
@ -206,12 +206,12 @@ def test_ursula_destroy_configuration(custom_filepath, click_runner):
# Run the destroy command
destruction_args = ('ursula', 'destroy', '--config-file', custom_config_filepath)
result = click_runner.invoke(nucypher_cli, destruction_args,
input='{}\nY\n'.format(INSECURE_DEVELOPMENT_PASSWORD),
catch_exceptions=False)
input='Y\n'.format(INSECURE_DEVELOPMENT_PASSWORD),
catch_exceptions=False,
env={'NUCYPHER_KEYRING_PASSWORD': INSECURE_DEVELOPMENT_PASSWORD})
# CLI Output
assert not os.path.isfile(custom_config_filepath), 'Configuration file still exists'
assert 'password' in result.output, 'WARNING: User was not prompted for password'
assert '? [y/N]:' in result.output, 'WARNING: User was not asked to destroy files'
assert custom_filepath in result.output, 'WARNING: Configuration path not in output. Deleting the wrong path?'
assert f'Deleted' in result.output, '"Destroyed" not in output'

69
tests/cli/ursula/test_run_ursula.py
View File

@ -15,15 +15,22 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest_twisted as pt
import time
import pytest
import pytest_twisted as pt
from twisted.internet import threads
from nucypher.characters.base import Learner
from nucypher.cli import actions
from nucypher.cli.actions import UnknownIPAddress
from nucypher.cli.main import nucypher_cli
from nucypher.config.node import NodeConfiguration
from nucypher.utilities.sandbox.constants import INSECURE_DEVELOPMENT_PASSWORD, \
MOCK_URSULA_STARTING_PORT, TEMPORARY_DOMAIN
from nucypher.utilities.sandbox.constants import (
INSECURE_DEVELOPMENT_PASSWORD,
MOCK_URSULA_STARTING_PORT,
TEMPORARY_DOMAIN
)
from nucypher.utilities.sandbox.ursula import start_pytest_ursula_services
@ -108,3 +115,59 @@ def test_ursula_cannot_init_with_dev_flag(click_runner):
result = click_runner.invoke(nucypher_cli, init_args, catch_exceptions=False)
assert result.exit_code == 2
assert 'Cannot create a persistent development character' in result.output, 'Missing or invalid error message was produced.'
def test_ursula_rest_host_determination(click_runner):
# Patch the get_external_ip call
original_call = actions.get_external_ip_from_centralized_source
try:
actions.get_external_ip_from_centralized_source = lambda: '192.0.2.0'
args = ('ursula', 'init',
'--federated-only',
'--network', TEMPORARY_DOMAIN
)
user_input = f'Y\n{INSECURE_DEVELOPMENT_PASSWORD}\n{INSECURE_DEVELOPMENT_PASSWORD}'
result = click_runner.invoke(nucypher_cli, args, catch_exceptions=False,
input=user_input)
assert result.exit_code == 0
assert '(192.0.2.0)' in result.output
args = ('ursula', 'init',
'--federated-only',
'--network', TEMPORARY_DOMAIN,
'--force'
)
user_input = f'{INSECURE_DEVELOPMENT_PASSWORD}\n{INSECURE_DEVELOPMENT_PASSWORD}\n'
result = click_runner.invoke(nucypher_cli, args, catch_exceptions=False,
input=user_input)
assert result.exit_code == 0
assert '192.0.2.0' in result.output
# Patch get_external_ip call to error output
def amazing_ip_oracle():
raise UnknownIPAddress
actions.get_external_ip_from_centralized_source = amazing_ip_oracle
args = ('ursula', 'init',
'--federated-only',
'--network', TEMPORARY_DOMAIN,
'--force'
)
user_input = f'{INSECURE_DEVELOPMENT_PASSWORD}\n{INSECURE_DEVELOPMENT_PASSWORD}\n'
result = click_runner.invoke(nucypher_cli, args, catch_exceptions=True, input=user_input)
assert result.exit_code == 1
assert isinstance(result.exception, UnknownIPAddress)
finally:
# Unpatch call
actions.get_external_ip_from_centralized_source = original_call

12
tests/conftest.py
View File

@ -86,10 +86,22 @@ def pytest_addoption(parser):
def pytest_collection_modifyitems(config, items):
#
# Handle slow tests marker
#
if not config.getoption("--runslow"): # --runslow given in cli: do not skip slow tests
skip_slow = pytest.mark.skip(reason="need --runslow option to run")
for item in items:
if "slow" in item.keywords:
item.add_marker(skip_slow)
#
# Handle Log Level
#
log_level_name = config.getoption("--log-level", "info", skip=True)
GlobalConsoleLogger.set_log_level(log_level_name)

70
tests/fixtures.py
View File

@ -32,10 +32,12 @@ from umbral.signing import Signer
from nucypher.blockchain.economics import TokenEconomics, SlashingEconomics
from nucypher.blockchain.eth.agents import NucypherTokenAgent
from nucypher.blockchain.eth.clients import NuCypherGethDevProcess
from nucypher.blockchain.eth.deployers import (NucypherTokenDeployer,
MinerEscrowDeployer,
PolicyManagerDeployer,
DispatcherDeployer)
DispatcherDeployer,
MiningAdjudicatorDeployer)
from nucypher.blockchain.eth.interfaces import BlockchainDeployerInterface
from nucypher.blockchain.eth.registry import InMemoryEthereumContractRegistry
from nucypher.blockchain.eth.sol.compile import SolidityCompiler
@ -54,7 +56,8 @@ from nucypher.utilities.sandbox.constants import (DEVELOPMENT_ETH_AIRDROP_AMOUNT
MOCK_POLICY_DEFAULT_M,
MOCK_URSULA_STARTING_PORT,
NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK,
TEST_PROVIDER_URI,
TEMPORARY_DOMAIN,
TEST_PROVIDER_URI
)
from nucypher.utilities.sandbox.middleware import MockRestMiddleware
from nucypher.utilities.sandbox.policy import generate_random_label
@ -64,6 +67,7 @@ from nucypher.utilities.sandbox.ursula import (make_decentralized_ursulas,
TEST_CONTRACTS_DIR = os.path.join(BASE_DIR, 'tests', 'blockchain', 'eth', 'contracts', 'contracts')
NodeConfiguration.DEFAULT_DOMAIN = TEMPORARY_DOMAIN
#
@ -92,7 +96,7 @@ def temp_config_root(temp_dir_path):
"""
default_node_config = NodeConfiguration(dev_mode=True,
config_root=temp_dir_path,
import_seed_registry=False)
download_registry=False)
yield default_node_config.config_root
default_node_config.cleanup()
@ -142,7 +146,7 @@ def ursula_decentralized_test_config():
abort_on_learning_error=True,
federated_only=False,
network_middleware=MockRestMiddleware(),
import_seed_registry=False,
download_registry=False,
save_metadata=False,
reload_metadata=False)
yield ursula_config
@ -170,9 +174,9 @@ def alice_blockchain_test_config(blockchain_ursulas, testerchain):
provider_uri=TEST_PROVIDER_URI,
checksum_public_address=testerchain.alice_account,
network_middleware=MockRestMiddleware(),
known_nodes=blockchain_ursulas,
known_nodes=blockchain_ursulas[:-1], # TODO: 1035
abort_on_learning_error=True,
import_seed_registry=False,
download_registry=False,
save_metadata=False,
reload_metadata=False)
yield config
@ -198,11 +202,11 @@ def bob_blockchain_test_config(blockchain_ursulas, testerchain):
provider_uri=TEST_PROVIDER_URI,
checksum_public_address=testerchain.bob_account,
network_middleware=MockRestMiddleware(),
known_nodes=blockchain_ursulas,
known_nodes=blockchain_ursulas[:-1], # TODO: #1035
start_learning_now=False,
abort_on_learning_error=True,
federated_only=False,
import_seed_registry=False,
download_registry=False,
save_metadata=False,
reload_metadata=False)
yield config
@ -363,12 +367,16 @@ def testerchain(solidity_compiler):
provider_uri=TEST_PROVIDER_URI)
# Create the blockchain
testerchain = TesterBlockchain(interface=deployer_interface, airdrop=True)
testerchain = TesterBlockchain(interface=deployer_interface,
eth_airdrop=True,
free_transactions=True,
poa=True)
# Set the deployer address from a freshly created test account
deployer_interface.deployer_address = testerchain.etherbase_account
yield testerchain
deployer_interface.disconnect()
testerchain.sever_connection()
@ -389,24 +397,20 @@ def three_agents(testerchain):
token_agent = token_deployer.make_agent() # 1: Token
miners_escrow_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
miner_escrow_deployer = MinerEscrowDeployer(
deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(miners_escrow_secret))
miner_escrow_deployer = MinerEscrowDeployer(deployer_address=origin)
miner_escrow_deployer.deploy(secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH))
miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow
miner_escrow_deployer.deploy()
policy_manager_secret = os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH)
policy_manager_deployer = PolicyManagerDeployer(
deployer_address=origin,
secret_hash=testerchain.interface.w3.keccak(policy_manager_secret))
policy_manager_deployer.deploy()
policy_manager_deployer = PolicyManagerDeployer(deployer_address=origin)
policy_manager_deployer.deploy(secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH))
miner_agent = miner_escrow_deployer.make_agent() # 2 Miner Escrow
policy_agent = policy_manager_deployer.make_agent() # 3 Policy Agent
adjudicator_deployer = MiningAdjudicatorDeployer(deployer_address=origin)
adjudicator_deployer.deploy(secret_hash=os.urandom(DispatcherDeployer.DISPATCHER_SECRET_LENGTH))
return token_agent, miner_agent, policy_agent
@ -427,13 +431,21 @@ def blockchain_ursulas(three_agents, ursula_decentralized_test_config):
ether_addresses=all_but_the_last_ursula,
stake=True)
# Stake starts next period (or else signature validation will fail)
blockchain.time_travel(periods=1)
# Bootstrap the network
for ursula_to_teach in _ursulas:
for ursula_to_learn_about in _ursulas:
ursula_to_teach.remember_node(ursula_to_learn_about)
# TODO: #1035 - Move non-staking Ursulas to a new fixture
# This one is not going to stake
_non_staking_ursula = make_decentralized_ursulas(ursula_config=ursula_decentralized_test_config,
ether_addresses=[the_last_ursula],
stake=False)
_ursulas.extend(_non_staking_ursula)
blockchain.time_travel(periods=1)
yield _ursulas
@ -476,12 +488,13 @@ def funded_blockchain(testerchain, three_agents, token_economics):
@pytest.fixture(scope='module')
def staking_participant(funded_blockchain, blockchain_ursulas):
# Start up the local fleet
for teacher in blockchain_ursulas:
start_pytest_ursula_services(ursula=teacher)
teachers = list(blockchain_ursulas)
staking_participant = teachers[-1]
staking_participant = teachers[-1] # TODO: # 1035
return staking_participant
@ -536,3 +549,14 @@ def _mock_ursula_reencrypts(ursula, corrupt_cfrag: bool = False):
@pytest.fixture(scope='session')
def mock_ursula_reencrypts():
return _mock_ursula_reencrypts
@pytest.fixture(scope='session')
def geth_dev_node():
geth = NuCypherGethDevProcess()
try:
yield geth
finally:
if geth.is_running:
geth.stop()
assert not geth.is_running

2
tests/keystore/test_keystore.py
View File

@ -43,7 +43,7 @@ def test_policy_arrangement_sqlite_keystore(test_keystore):
# Test add PolicyArrangement
new_arrangement = test_keystore.add_policy_arrangement(
datetime.utcnow(), b'test', arrangement_id, alice_pubkey_sig=alice_keypair_sig.pubkey,
datetime.utcnow(), b'test', arrangement_id, alice_verifying_key=alice_keypair_sig.pubkey,
alice_signature=b'test'
)

14
tests/learning/test_domains.py
View File

@ -8,9 +8,10 @@ def test_learner_learns_about_domains_separately(ursula_federated_test_config, c
ursula_config=ursula_federated_test_config,
quantity=3,
know_each_other=True)
global_learners = lonely_ursula_maker()
first_domain_learners = lonely_ursula_maker(domains=set([b"nucypher1.test_suite"]))
second_domain_learners = lonely_ursula_maker(domains=set([b"nucypher2.test_suite"]))
global_learners = lonely_ursula_maker(domains={"nucypher1.test_suite"})
first_domain_learners = lonely_ursula_maker(domains={"nucypher1.test_suite"})
second_domain_learners = lonely_ursula_maker(domains={"nucypher2.test_suite"})
big_learner = global_learners.pop()
@ -24,10 +25,11 @@ def test_learner_learns_about_domains_separately(ursula_federated_test_config, c
big_learner._current_teacher_node = second_domain_learners.pop()
big_learner.learn_from_teacher_node()
assert len(big_learner.known_nodes) == 8
# All domain 1 nodes
assert len(big_learner.known_nodes) == 5
new_first_domain_learner = lonely_ursula_maker(domains=set([b"nucypher1.test_suite"])).pop()
new_second_domain_learner = lonely_ursula_maker(domains=set([b"nucypher2.test_suite"]))
new_first_domain_learner = lonely_ursula_maker(domains={"nucypher1.test_suite"}).pop()
new_second_domain_learner = lonely_ursula_maker(domains={"nucypher2.test_suite"})
new_first_domain_learner._current_teacher_node = big_learner
new_first_domain_learner.learn_from_teacher_node()

73
tests/learning/test_fault_tolerance.py
View File

@ -10,36 +10,62 @@ from nucypher.utilities.sandbox.middleware import MockRestMiddleware
from nucypher.utilities.sandbox.ursula import make_federated_ursulas
def test_blockchain_ursula_is_not_valid_with_unsigned_identity_evidence(blockchain_ursulas, caplog):
lonely_blockchain_learner, blockchain_teacher, unsigned = list(blockchain_ursulas)[0:3]
def test_blockchain_ursula_stamp_verification_tolerance(blockchain_ursulas, caplog):
unsigned._evidence_of_decentralized_identity = NOT_SIGNED
#
# Setup
#
# Wipe known nodes.
lonely_blockchain_learner._Learner__known_nodes = FleetStateTracker()
lonely_blockchain_learner._current_teacher_node = blockchain_teacher
# TODO: #1035
lonely_blockchain_learner, blockchain_teacher, unsigned, *the_others, non_staking_ursula = list(blockchain_ursulas)
lonely_blockchain_learner.remember_node(blockchain_teacher)
warnings = []
def warning_trapper(event):
if event['log_level'] == LogLevel.warn:
warnings.append(event)
#
# Attempt to verify unsigned stamp
#
unsigned._Teacher__decentralized_identity_evidence = NOT_SIGNED
# Wipe known nodes!
lonely_blockchain_learner._Learner__known_nodes = FleetStateTracker()
lonely_blockchain_learner._current_teacher_node = blockchain_teacher
lonely_blockchain_learner.remember_node(blockchain_teacher)
globalLogPublisher.addObserver(warning_trapper)
lonely_blockchain_learner.learn_from_teacher_node()
globalLogPublisher.removeObserver(warning_trapper)
# We received one warning during learning, and it was about this very matter.
assert len(warnings) == 1
assert warnings[0]['log_format'] == unsigned.invalid_metadata_message.format(unsigned)
warning = warnings[0]['log_format']
assert str(unsigned) in warning
assert "stamp is unsigned" in warning # TODO: Cleanup logging templates
assert unsigned not in lonely_blockchain_learner.known_nodes
# minus 2 for self and, of course, unsigned.
# TODO: #1035
# minus 3: self, a non-staking ursula, and the unsigned ursula.
assert len(lonely_blockchain_learner.known_nodes) == len(blockchain_ursulas) - 3
assert blockchain_teacher in lonely_blockchain_learner.known_nodes
assert unsigned not in lonely_blockchain_learner.known_nodes
#
# Attempt to verify non-staking Ursula
#
lonely_blockchain_learner._current_teacher_node = non_staking_ursula
globalLogPublisher.addObserver(warning_trapper)
lonely_blockchain_learner.learn_from_teacher_node()
globalLogPublisher.removeObserver(warning_trapper)
assert len(warnings) == 2
warning = warnings[1]['log_format']
assert str(non_staking_ursula) in warning
assert "no active stakes" in warning # TODO: Cleanup logging templates
assert non_staking_ursula not in lonely_blockchain_learner.known_nodes
def test_emit_warning_upon_new_version(ursula_federated_test_config, caplog):
@ -47,11 +73,11 @@ def test_emit_warning_upon_new_version(ursula_federated_test_config, caplog):
ursula_config=ursula_federated_test_config,
quantity=2,
know_each_other=True)
learner = lonely_ursula_maker().pop()
teacher, new_node = lonely_ursula_maker()
new_node.TEACHER_VERSION = learner.LEARNER_VERSION + 1
learner._current_teacher_node = teacher
warnings = []
@ -61,26 +87,27 @@ def test_emit_warning_upon_new_version(ursula_federated_test_config, caplog):
warnings.append(event)
globalLogPublisher.addObserver(warning_trapper)
learner.learn_from_teacher_node()
assert len(warnings) == 1
#TODO: Why no assert? Is this in progress?
warnings[0]['log_format'] == learner.unknown_version_message.format(new_node, new_node.TEACHER_VERSION,
learner.LEARNER_VERSION)
assert warnings[0]['log_format'] == learner.unknown_version_message.format(new_node,
new_node.TEACHER_VERSION,
learner.LEARNER_VERSION)
# Now let's go a little further: make the version totally unrecognizable.
crazy_bytes_representation = int(learner.LEARNER_VERSION + 1).to_bytes(2,
byteorder="big") + b"totally unintelligible nonsense"
crazy_bytes_representation = int(learner.LEARNER_VERSION + 1).to_bytes(2, byteorder="big") \
+ b"totally unintelligible nonsense"
Response = namedtuple("MockResponse", ("content", "status_code"))
response = Response(content=crazy_bytes_representation, status_code=200)
learner.network_middleware.get_nodes_via_rest = lambda *args, **kwargs: response
learner.learn_from_teacher_node()
assert len(warnings) == 2
# TODO: Why no assert? Is this in progress?
warnings[1]['log_format'] == learner.unknown_version_message.format(new_node, new_node.TEACHER_VERSION,
learner.LEARNER_VERSION)
# TODO: #1039 - Fails because the above mocked Response is unsigned, and the API now enforces interface signatures
# assert len(warnings) == 2
# assert warnings[1]['log_format'] == learner.unknown_version_message.format(new_node,
# new_node.TEACHER_VERSION,
# learner.LEARNER_VERSION)
globalLogPublisher.removeObserver(warning_trapper)

Some files were not shown because too many files have changed in this diff Show More