Developer Reference

2015-05-29T08:11:43Z

Dissem: /* Other Implementations */

This page is intended to provide information and other resources that are useful for Bitmessage developers.

==Protocol Information==

Protocol specification: https://bitmessage.org/wiki/Protocol_specification

Encryption scheme: https://bitmessage.org/wiki/Encryption

Proof of Work scheme: https://bitmessage.org/wiki/Proof_of_work

Bitmessage White Paper: https://bitmessage.org/bitmessage.pdf

Bitmessage Technical Paper (Note: not updated for protocol version 3): https://bitmessage.org/Bitmessage%20Technical%20Paper.pdf

== Implementations ==

===Full Node Implementations===

PyBitmessage (Reference Client) (Python): https://github.com/bitmessage/pybitmessage

bitmessaged (C++): https://github.com/Thomas-Astade/bitmessaged

===Lite Client Implementations===

Bitseal (Java): https://github.com/jonathancoe/bitseal

Notbit (C): https://github.com/bpeel/notbit

Bmr (Javascript): https://github.com/chovy/bmr

bitmessage-web (Javascript): https://github.com/jclement/bitmessage-web

Bitpost (Objective-C): https://github.com/Voluntarynet/Bitpost

===Web Clients===

Blinked (Javascript): https://blinked.ca

Bitmsg.me (Javascript): https://bitmsg.me

===Gateway Services===

https://bitmessage.ch

http://bitmessage.mobi

https://mailchuck.com

===Other Implementations===

Please note that some of these other implementations may be incomplete or not up-to-date with the current Bitmessage protocol.

libbitmessage (C++): https://github.com/corebob/libbitmessage

bitmessage-go (Go): https://github.com/corebob/bitmessage-go

cppbitmessage (C++): https://github.com/bashrc/cppbitmessage

JBitmessage (Java): https://github.com/ISibboI/JBitmessage

Jabit (Java): https://github.com/Dissem/Jabit

SharpBitmessage (C#): https://github.com/sharpbitmessage/SharpBitmessage

Bitmessage-js (Javascript): https://github.com/indigots/Bitmessage-js

bitmessage-ruby (Ruby): https://github.com/staii/bitmessage-ruby

bitchan (Javascript): https://github.com/bitchan

==Scripts and Utilities==

===PyBitmessage Utilities===

Bitmessage PHP class - Bitmessage PHP Class to control PyBitmessage daemon using xmlrpc - https://github.com/Conver/class.bitmessage.php

bmwrapper - Email wrapper for PyBitmessage: https://github.com/Arceliar/bmwrapper

BitCrypt - Encrypts and decrypts PyBitmessage .dat files: https://github.com/AyrA/BitCrypt

BitUpdate - Automatically update PyBitmessage: https://github.com/AyrA/BitUpdate

NIIP-BitMessageLib - A .NET implementation of the API exposed by PyBitmessage: https://bitbucket.org/niip/niip-bitmessagelib

===Others===

bitmessage-powfaster - Bitmessage Proof Of Work optimizations including OpenCL and C based PoW code: https://github.com/grant-olson/bitmessage-powfaster

BitMailServer - Bitmesssage to Email Gateway: https://github.com/AyrA/BitMailServer

BitDNS - Bitmessage DNS and Namecoin integration: https://github.com/AyrA/BitDNS

BitCenter - Powerful Bitmessage message processing: https://github.com/AyrA/BitCenter

BitHTTP - HTTP proxy over Bitmessage: https://github.com/AyrA/BitHTTP

BinSend - Send and decode binary attachments via Bitmessage: https://github.com/AyrA/BinSend

BitMessageForum - Browse your bitmessages via a forum-like UI: https://github.com/grant-olson/BitMessageForum

Protocol specification

2015-05-22T18:28:04Z

Dissem:

All objects sent on the network should support protocol v3 starting on Sun, 16 Nov 2014 22:00:00 GMT. 

==Common standards==

=== Hashes ===

Most of the time [http://en.wikipedia.org/wiki/SHA-2 SHA-512] hashes are used, however [http://en.wikipedia.org/wiki/RIPEMD RIPEMD-160] is also used when creating an address.

A double-round of SHA-512 is used for the Proof Of Work. Example of double-SHA-512 encoding of string "hello":

hello
9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043(first round of sha-512)
0592a10584ffabf96539f3d780d776828c67da1ab5b169e9e8aed838aaecc9ed36d49ff1423c55f019e050c66c6324f53588be88894fef4dcffdb74b98e2b200(second round of sha-512)

For Bitmessage addresses (RIPEMD-160) this would give:

hello
9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043(first round is sha-512)
79a324faeebcbf9849f310545ed531556882487e (with ripemd-160)

== Common structures ==

All integers are encoded in big endian. (This is different from Bitcoin).

=== Message structure ===

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 4 || magic || uint32_t || Magic value indicating message origin network, and used to seek to next message when stream state is unknown
|-
| 12 || command || char[12] || ASCII string identifying the packet content, NULL padded (non-NULL padding results in packet rejected)
|-
| 4 || length || uint32_t || Length of payload in number of bytes. Because of other restrictions, there is no reason why this length would ever be larger than 1600003 bytes. Some clients include a sanity-check to avoid processing messages which are larger than this.
|-
| 4 || checksum || uint32_t || First 4 bytes of sha512(payload)
|-
| ? || message_payload || uchar[] || The actual data, a [[#Message_types|message]] or an [[#object|object]]. Not to be confused with objectPayload.
|}

Known magic values:

{|class="wikitable"
! Magic value !! Sent over wire as
|-
| 0xE9BEB4D9 || E9 BE B4 D9
|}

=== Variable length integer ===

Integer can be encoded depending on the represented value to save space. Variable length integers always precede an array/vector of a type of data that may vary in length. Varints MUST use the minimum possible number of bytes to encode a value. For example; the value 6 can be encoded with one byte therefore a varint that uses three bytes to encode the value 6 is malformed and the decoding task must be aborted.

{|class="wikitable"
! Value !! Storage length !! Format
|-
| < 0xfd || 1 || uint8_t
|-
| <= 0xffff || 3 || 0xfd followed by the integer as uint16_t
|-
| <= 0xffffffff || 5 || 0xfe followed by the integer as uint32_t
|-
| - || 9 || 0xff followed by the integer as uint64_t
|}

=== Variable length string ===

Variable length string can be stored using a variable length integer followed by the string itself.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 1+ || length || [[Protocol_specification#Variable_length_integer|var_int]] || Length of the string
|-
| ? || string || char[] || The string itself (can be empty)
|}

=== Variable length list of integers===

n integers can be stored using n+1 [[Protocol_specification#Variable_length_integer|variable length integers]] where the first var_int equals n.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 1+ || count|| [[Protocol_specification#Variable_length_integer|var_int]] || Number of var_ints below
|-
| 1+ || || var_int || The first value stored
|-
| 1+ || || var_int || The second value stored...
|-
| 1+ || || var_int || etc...
|}

=== Network address ===

When a network address is needed somewhere, this structure is used. Network addresses are not prefixed with a timestamp or stream in the version message.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 8 || time || uint32 || the Time.
|-
| 4 || stream|| uint32 || Stream number for this node
|-
| 8 || services || uint64_t || same service(s) listed in [[#version|version]]
|-
| 16 || IPv6/4 || char[16] || IPv6 address. IPv4 addresses are written into the message as a 16 byte [http://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses IPv4-mapped IPv6 address]
(12 bytes ''00 00 00 00 00 00 00 00 00 00 FF FF'', followed by the 4 bytes of the IPv4 address).
|-
| 2 || port || uint16_t || port number
|}

=== Inventory Vectors ===

Inventory vectors are used for notifying other nodes about objects they have or data which is being requested. Two rounds of SHA-512 are used, resulting in a 64 byte hash. Only the first 32 bytes are used; the later 32 bytes are ignored.

Inventory vectors consist of the following data format:

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 32 || hash || char[32] || Hash of the object
|}

=== Encrypted payload ===

Bitmessage uses [https://en.wikipedia.org/wiki/Integrated_Encryption_Scheme ECIES] to encrypt its messages. For more information see [[Encryption]]

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 16||IV||uchar[]||Initialization Vector used for AES-256-CBC
|-
| 2||uint16_t||Curve type||Elliptic Curve type 0x02CA (714)
|-
| 2||uint16_t||X length||Length of X component of public key R
|-
| X length||uchar[]||X||X component of public key R
|-
| 2||uint16_t||Y length||Length of Y component of public key R
|-
| Y length||uchar[]||Y||Y component of public key R
|-
| ?||encrypted||uchar[]||Cipher text
|-
| 32||MAC|| uchar[]||HMACSHA256 Message Authentication Code
|}

=== Unencrypted Message Data ===

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 1+||msg_version||var_int||Message format version. This field is not included after the protocol v3 upgrade period.
|-
| 1+||address_version||var_int||Sender's address version number. This is needed in order to calculate the sender's address to show in the UI, and also to allow for forwards compatible changes to the public-key data included below.
|-
| 1+||stream||var_int||Sender's stream number
|-
| 4||behavior bitfield||uint32_t||A bitfield of optional behaviors and features that can be expected from the node with this pubkey included in this msg message (the sender's pubkey).
|-
| 64||public signing key||uchar[]||The ECC public key used for signing (uncompressed format; normally prepended with \x04 )
|-
| 64||public encryption key||uchar[]||The ECC public key used for encryption (uncompressed format; normally prepended with \x04 )
|-
| 1+||nonce_trials_per_byte||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is the average number of nonce trials a node will have to perform to meet the Proof of Work requirement. 1000 is the network minimum so any lower values will be automatically raised to 1000. '''This field is new and is only included when the address_version >= 3.'''
|-
| 1+||extra_bytes||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is added to the data length to make sending small messages more difficult. 1000 is the network minimum so any lower values will be automatically raised to 1000. '''This field is new and is only included when the address_version >= 3.'''
|-
| 20||destination ripe||uchar[]||The ripe hash of the public key of the receiver of the message
|-
| 1+||encoding||var_int||[[Protocol_specification#Message_Encodings|Message Encoding]] type
|-
| 1+||message_length||var_int||Message Length
|-
| message_length||message||uchar[]||The message.
|-
| 1+||ack_length||var_int||Length of the acknowledgement data
|-
| ack_length||ack_data||uchar[]||The acknowledgement data to be transmitted. This takes the form of a Bitmessage protocol message, like another msg message. The POW therein must already be completed.
|-
| 1+||sig_length||var_int||Length of the signature
|-
| sig_length||signature||uchar[]||The ECDSA signature which covers the object header starting with the time, appended with the data described in this table down to the ack_data.
|}

====Message Encodings====
{|class="wikitable"
! Value !! Name !! Description
|-
| 0 || IGNORE || Any data with this number may be ignored. The sending node might simply be sharing its public key with you.
|-
| 1 || TRIVIAL|| UTF-8. No 'Subject' or 'Body' sections. Useful for simple strings of data, like URIs or magnet links.
|-
| 2 || SIMPLE || UTF-8. Uses 'Subject' and 'Body' sections. No MIME is used.
<code>messageToTransmit = 'Subject:' + subject + '\n' + 'Body:' + message</code>
|}

Further values for the message encodings can be decided upon by the community. Any MIME or MIME-like encoding format, should they be used, should make use of Bitmessage's 8-bit bytes.

====Pubkey bitfield features====
{|class="wikitable"
! Bit!! Name !! Description
|-
| 0 || undefined || The most significant bit at the beginning of the structure. Undefined
|-
| 1 || undefined || The next most significant bit. Undefined
|-
| ... || ... || ...
|-
| 30 || include_destination || Receiving node expects that the RIPE hash encoded in their address preceedes the encrypted message data of msg messages bound for them.
|-
| 31 || does_ack|| If true, the receiving node does send acknowledgements (rather than dropping them).
|}

== Message types ==
Undefined messages received on the wire must be ignored.

=== version ===

When a node creates an outgoing connection, it will immediately advertise its version. The remote node will respond with its version. No futher communication is possible until both peers have exchanged their version.

Payload:

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 4 || version || int32_t || Identifies protocol version being used by the node. Should equal 3. Nodes should disconnect if the remote node's version is lower but continue with the connection if it is higher.
|-
| 8 || services || uint64_t || bitfield of features to be enabled for this connection
|-
| 8 || timestamp || int64_t || standard UNIX timestamp in seconds
|-
| 26 || addr_recv || net_addr || The network address of the node receiving this message (not including the time or stream number)
|-
| 26 || addr_from || net_addr || The network address of the node emitting this message (not including the time or stream number and the ip itself is ignored by the receiver)
|-
| 8 || nonce || uint64_t || Random nonce used to detect connections to self.
|-
| 1+ || user_agent || [[#Variable length string|var_str]] || [[User Agent]] (0x00 if string is 0 bytes long). Sending nodes must not include a user_agent longer than 5000 bytes.
|-
| 1+ || stream_numbers || [[#Variable length list of integers|var_int_list]] || The stream numbers that the emitting node is interested in. Sending nodes must not include more than 160000 stream numbers.
|}

A "verack" packet shall be sent if the version packet was accepted. Once you have sent and received a verack messages with the remote node, send an addr message advertising up to 1000 peers of which you are aware, and one or more inv messages advertising all of the valid objects of which you are aware.

The following services are currently assigned:

{|class="wikitable"
! Value !! Name !! Description
|-
| 1 || NODE_NETWORK || This is a normal network node.
|}

=== verack ===

The ''verack'' message is sent in reply to ''version''. This message consists of only a [[#Message structure|message header]] with the command string "verack". The TCP timeout starts out at 20 seconds; after verack messages are exchanged, the timeout is raised to 10 minutes.

=== addr ===

Provide information on known nodes of the network. Non-advertised nodes should be forgotten after typically 3 hours

Payload:
{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 1+ || count || [[Protocol_specification#Variable_length_integer|var_int]] || Number of address entries (max: 1000)
|-
| 38 || addr_list || [[Protocol_specification#Network_address|net_addr]] || Address of other nodes on the network.
|}

=== inv ===

Allows a node to advertise its knowledge of one or more objects.
Payload (maximum payload length: 50000 items):

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| ? || count || [[Protocol_specification#Variable_length_integer|var_int]] || Number of inventory entries
|-
| 32x? || inventory || [[Protocol specification#Inventory Vectors|inv_vect]][] || Inventory vectors
|}

=== getdata ===

getdata is used in response to an ''inv'' message to retrieve the content of a specific object after filtering known elements.

Payload (maximum payload length: 50000 entries):

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| ? || count || [[Protocol_specification#Variable_length_integer|var_int]] || Number of inventory entries
|-
| 32x? || inventory || [[Protocol specification#Inventory Vectors|inv_vect]][] || Inventory vectors
|}

=== object ===

An object is a message which is shared throughout a stream. It is the only message which propagates; all others are only between two nodes. Objects have a type, like 'msg', or 'broadcast'. To be a valid object, the [[Proof of work|Proof Of Work]] must be done. The maximum allowable length of an object (not to be confused with the objectPayload) is 218 bytes.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 8||nonce||uint64_t||
Random nonce used for the [[Proof of work|Proof Of Work]]
|-
| 8||expiresTime||uint64_t||
The "end of life" time of this object (be aware, in version 2 of the protocol this was the generation time). Objects shall be shared with peers until its end-of-life time has been reached. The node should store the inventory vector of that object for some extra period of time to avoid reloading it from another node with a small time delay. The time may be no further than 28 days + 3 hours in the future.
|-
| 4||objectType||uint32_t||
Four values are currently defined: 0-"getpubkey", 1-"pubkey", 2-"msg", 3-"broadcast". All other values are reserved. Nodes should relay objects even if they use an undefined object type.
|-
| 1+||version||var_int||The object's version. Note that msg objects won't contain a version until Sun, 16 Nov 2014 22:00:00 GMT.
|-
| 1+||stream number||var_int||The stream number in which this object may propagate
|-
| ?||objectPayload||uchar[]||
This field varies depending on the object type; see below.
|-
|}

== Object types ==
Here are the payloads for various object types.

=== getpubkey ===

When a node has the hash of a public key (from an address) but not the public key itself, it must send out a request for the public key.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 20||ripe||uchar[]||The ripemd hash of the public key. This field is only included when the address version is <= 3.
|-
| 32||tag||uchar[]||The tag derived from the address version, stream number, and ripe. This field is only included when the address version is >= 4.
|}

=== pubkey ===

A version 2 pubkey. This is still in use and supported by current clients but ''new'' v2 addresses are not generated by clients.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 4||[[Protocol_specification#Pubkey_bitfield_features|behavior bitfield]]||uint32_t||A bitfield of optional behaviors and features that can be expected from the node receiving the message.
|-
| 64||public signing key||uchar[]||The ECC public key used for signing (uncompressed format; normally prepended with \x04 )
|-
| 64||public encryption key||uchar[]||The ECC public key used for encryption (uncompressed format; normally prepended with \x04 )
|}

A version 3 pubkey

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 4||[[Protocol_specification#Pubkey_bitfield_features|behavior bitfield]]||uint32_t||A bitfield of optional behaviors and features that can be expected from the node receiving the message.
|-
| 64||public signing key||uchar[]||The ECC public key used for signing (uncompressed format; normally prepended with \x04 )
|-
| 64||public encryption key||uchar[]||The ECC public key used for encryption (uncompressed format; normally prepended with \x04 )
|-
| 1+||nonce_trials_per_byte||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is the average number of nonce trials a node will have to perform to meet the Proof of Work requirement. 1000 is the network minimum so any lower values will be automatically raised to 1000.
|-
| 1+||extra_bytes||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is added to the data length to make sending small messages more difficult. 1000 is the network minimum so any lower values will be automatically raised to 1000.
|-
| 1+||sig_length||var_int||Length of the signature
|-
| sig_length||signature||uchar[]||The ECDSA signature which, as of protocol v3, covers the object header starting with the time, appended with the data described in this table down to the extra_bytes.
|}

A version 4 pubkey

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 32||tag||uchar[]||The tag, made up of bytes 32-64 of the double hash of the address data (see example python code below)
|-
| ?||encrypted||uchar[]||Encrypted pubkey data.
|-
|}

When version 4 pubkeys are created, most of the data in the pubkey is encrypted. This is done in such a way that only someone who has the Bitmessage address which corresponds to a pubkey can decrypt and use that pubkey. This prevents people from gathering pubkeys sent around the network and using the data from them to create messages to be used in spam or in flooding attacks.

In order to encrypt the pubkey data, a double SHA-512 hash is calculated from the address version number, stream number, and ripe hash of the Bitmessage address that the pubkey corresponds to. The first 32 bytes of this hash are used to create a public and private key pair with which to encrypt and decrypt the pubkey data, using the same algorithm as message encryption (see [[Encryption]]). The remaining 32 bytes of this hash are added to the unencrypted part of the pubkey and used as a tag, as above. This allows nodes to determine which pubkey to decrypt when they wish to send a message.

In PyBitmessage, the double hash of the address data is calculated using the python code below:

doubleHashOfAddressData = hashlib.sha512(hashlib.sha512(encodeVarint(addressVersionNumber) + encodeVarint(streamNumber) + hash).digest()).digest()

Encrypted data in version 4 pubkeys:

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
|-
| 4||[[Protocol_specification#Pubkey_bitfield_features|behavior bitfield]]||uint32_t||A bitfield of optional behaviors and features that can be expected from the node receiving the message.
|-
| 64||public signing key||uchar[]||The ECC public key used for signing (uncompressed format; normally prepended with \x04 )
|-
| 64||public encryption key||uchar[]||The ECC public key used for encryption (uncompressed format; normally prepended with \x04 )
|-
| 1+||nonce_trials_per_byte||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is the average number of nonce trials a node will have to perform to meet the Proof of Work requirement. 1000 is the network minimum so any lower values will be automatically raised to 1000.
|-
| 1+||extra_bytes||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is added to the data length to make sending small messages more difficult. 1000 is the network minimum so any lower values will be automatically raised to 1000.
|-
| 1+||sig_length||var_int||Length of the signature
|-
| sig_length||signature||uchar[]||The ECDSA signature which covers everything from the object header starting with the time, then appended with the decrypted data down to the extra_bytes. This was changed in protocol v3. 
|}

=== msg ===
Used for person-to-person messages. Note that msg objects won't contain a version in the object header until Sun, 16 Nov 2014 22:00:00 GMT.
{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| ?||encrypted||uchar[]||Encrypted data. See [[Protocol_specification#Encrypted_payload|Encrypted payload]]. See also [[Protocol_specification#Unencrypted_Message_Data|Unencrypted Message Data Format]]
|}

=== broadcast ===
Users who are subscribed to the sending address will see the message appear in their inbox. Broadcasts are version 4 or 5.

Pubkey objects and v5 broadcast objects are encrypted the same way: The data encoded in the sender's Bitmessage address is hashed twice. The first 32 bytes of the resulting hash constitutes the "private" encryption key and the last 32 bytes constitute a '''tag''' so that anyone listening can easily decide if this particular message is interesting. The sender calculates the public key from the private key and then encrypts the object with this public key. Thus anyone who knows the Bitmessage address of the sender of a broadcast or pubkey object can decrypt it.

The version of broadcast objects was previously 2 or 3 but was changed to 4 or 5 for protocol v3. Having a broadcast version of 5 indicates that a tag is used which, in turn, is used when the sender's address version is >=4.

{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 32 || tag|| uchar[]||The tag. This field is new and only included when the broadcast version is >= 5. Changed in protocol v3
|-
| ?||encrypted||uchar[]||Encrypted broadcast data. The keys are derived as described in the paragraph above. See [[Protocol_specification#Encrypted_payload|Encrypted payload]] for details about the encryption algorithm itself.
|}

Unencrypted data format:
{|class="wikitable"
! Field Size !! Description !! Data type !! Comments
|-
| 1+|| broadcast version|| var_int||The version number of this broadcast protocol message which is equal to 2 or 3. This is included here so that it can be signed. This is no longer included in protocol v3
|-
| 1+ || address version|| var_int||The sender's address version
|-
| 1+ || stream number|| var_int||The sender's stream number
|-
| 4||[[Protocol_specification#Pubkey_bitfield_features|behavior bitfield]]||uint32_t||A bitfield of optional behaviors and features that can be expected from the owner of this pubkey.
|-
| 64||public signing key||uchar[]||The ECC public key used for signing (uncompressed format; normally prepended with \x04 )
|-
| 64||public encryption key||uchar[]||The ECC public key used for encryption (uncompressed format; normally prepended with \x04 )
|-
| 1+||nonce_trials_per_byte||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is the average number of nonce trials a node will have to perform to meet the Proof of Work requirement. 1000 is the network minimum so any lower values will be automatically raised to 1000. This field is new and is only included when the address_version >= 3.
|-
| 1+||extra_bytes||var_int||Used to calculate the difficulty target of messages accepted by this node. The higher this value, the more difficult the Proof of Work must be before this individual will accept the message. This number is added to the data length to make sending small messages more difficult. 1000 is the network minimum so any lower values will be automatically raised to 1000. This field is new and is only included when the address_version >= 3.
|-
| 1+ || [[Protocol_specification#Message_Encodings|encoding]]|| var_int||The [[Protocol_specification#Message_Encodings|encoding type]] of the message
|-
| 1+ ||messageLength || var_int||The message length in bytes
|-
| messageLength || message||uchar[] ||The message
|-
| 1+||sig_length||var_int||Length of the signature
|-
| sig_length|| signature||uchar[] ||The signature which did cover the unencrypted data from the broadcast version down through the message. In protocol v3, it covers the unencrypted object header starting with the time, all appended with the decrypted data.
|}

Bitmessage Wiki - User contributions [en]

Talk:Extended encoding

Developer Reference

Protocol specification