Bitcoin Forum

https://docs.google.com/forms/d/18_EO8Yc5d79kxvj0bOh3LrL7JkA-A2DYCvqSbrbu_I0

https://www.bitpacket.net/
Bitpacket; A meshnet protocol

Roadmap
Pollock
- diffie-hellman key encryption of packets
- TUN network forwarding to low level kernel sockets API through a user-space program
- TCP packet support
- UDP packet support
- Dual node support (i.e. node_a <-> proxy_node <-> destination server)

Matisse
- Peer discovery
- Multi-node support (i.e. node_a <-> node_n1 <-> node_n2 <-> destination server)

Warhol
- TAP network forwarding support (in addition to TUN)
- Reward scheme for nodes forwarding traffic
- Fee based scheme in addition to reward scheme for users who want to "get ahead" in packet congestion

How does it work?
This will be a very basic overview, though it will still be fairly technical to those who are not familiar with network programming.
This is how the network will work in the "Pollock" release - It's worth noting that after the "Matisse" release is implemented things get significantly more complicated.

1) Requests are wired through TUN/TAP forwarding
2) Search for a proxy node
3) Node_a (your node) intercepts the packets within local routing, encrypts them, as well as adding the server destination address, then forwards the packets to the given proxy node
4) Proxy node decrypts the packets with the shared diffie-hellman secret and extracts the server destination address
5) Sends the data to the server
6) Gets response and re-encrypts it again with diffie-hellman + cipher scheme, forwards the packet back to node_a
7) Node_a decrypts the packets

How will the reward scheme work?
Again, this will be a simple overview of the cryptography behind the nodes and rewards. The first is fees. Where the user can either choose to use the network for free, or he can pay to get prioritised traffic forwarding. If he chooses to pay, then the fees go to the nodes. Like so;
1) Initial packet gets sent to the node along with fee
2) The "fee" contains an ecdsa signed message with the fee commit. e.g. sign(FEE_AMOUNT, messaged_commit);
4) Every n bytes that gets sent and received, the node sends a new message with sign(FEE_AMOUNT+ADDITIONAL_FEE_AMOUNT, messaged_commit);
5) When he does, there are several checks in place;
 - sc checks that the signature is valid
 - it has the "messaged_commit"
 - funds are sent to the node (from the user's deposited account)
 - the "messaged_commit" is updated to something new so as to prevent sybil attacks of multiple withdrawals from the same signature


Telegram: t.me/bitpacket

bump