Transaction format

metaverse transactions are mostly the same as Bitcoin, Only the transaction Output is extended with attachment.

ref. https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch06.asciidoc#transactions

Transaction

Exactly the same as Bitcoin

struct

uint32_t version;
uint32_t locktime;
input::list inputs;
output::list outputs;

transaction version

0 : null version
1 : first version
2 : check output script
3 : nova special testnet transaction (only for some tx can't pass validation)
4 : nova transaction

Genesis transaction version is recommend to 0.
Coinbase transaction version is recommend to 1.
Coinstake transaction version is recommend to 2.
All the other transactions' version are recommend to the latest version (at present 4).

NOTICE:

Do not use the transaction version to judge the transaction’s kind.
For example, use version 0 to judge a transaction is a genesis transaction,
or use version 1 to judge a transaction is a coinbase transaction.

If a transaction version >= 2, then the validation will check if all its outputs script pattern is standard. If has unkown script pattern, the transaction can not pass validation.

serialization

void transaction::to_data(writer& sink) const
{
    sink.write_4_bytes_little_endian(version);
    sink.write_variable_uint_little_endian(inputs.size());

    for (const auto& input: inputs)
        input.to_data(sink);

    sink.write_variable_uint_little_endian(outputs.size());

    for (const auto& output: outputs)
        output.to_data(sink);

    sink.write_4_bytes_little_endian(locktime);
}

Transaction Input

Exactly the same as Bitcoin

ref. https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch06.asciidoc#transaction-inputs

struct

hash_digest hash; // 32 bytes
uint32_t index;
chain::script script;
uint32_t sequence;

serialization

void input::to_data(writer& sink) const
{
    sink.write_hash(hash);
    sink.write_4_bytes_little_endian(index);
    script.to_data(sink, true);
    sink.write_4_bytes_little_endian(sequence);
}

Transaction Output

Mostly the same as Bitcoin.
Extent with an attachment data for metaverse extended functions (Asset, Cert, DID, MIT, etc).

Please see Output-attachment for more info.

struct

uint64_t value;
chain::script script;
chain::attachment attachment; // Extended field

serialization

sink.write_8_bytes_little_endian(value);
script.to_data(sink, true);
attachment.to_data(sink);

Script

Almost the same as Bitcoin

ref. https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch06.asciidoc#transaction-scripts-and-script-language

Except the following difference:

operation code

OP_CHECKATTENUATIONVERIFY has op code of 178 (newly added for Asset lock)
OP_CHECKSEQUENCEVERIFY has op code of 179 (while Bitcoin is 178)

script pattern

add pay_blackhole_address (for Burn transaction)
add pay_key_hash_with_attenuation_model (for Asset lock transaction)

struct

operation::stack operations; // vector of operation

struct operation {
    opcode code;
    std::vector<uint8_t> data;
}

serialization

// prefix is true in signing
void script::to_data(writer& sink, bool prefix) const
{
    if (prefix)
        sink.write_variable_uint_little_endian(satoshi_content_size());

    if ((operations.size() > 0) && (operations[0].code == opcode::raw_data)) {
        operations[0].to_data(sink);
    } else {
        for (const auto& op: operations)
            op.to_data(sink);
    }
}

Output attachment

struct

uint32_t version;
uint32_t type;
std::string todid;
std::string fromdid;
boost::variant<
    etp,
    etp_award, // unused
    asset,
    blockchain_message,
    did,
    asset_cert,
    asset_mit
> attach;

attachment version

1   : normal
207 : did related

attachment type

0 : etp
1 : etp_award // unused
2 : asset
3 : message
4 : did
5 : asset_cert
6 : asset_mit

serialization

void attachment::to_data_t(writer& sink) const
{
    sink.write_4_bytes_little_endian(version);
    sink.write_4_bytes_little_endian(type);
    if (version == 207) {
        sink.write_string(todid);
        sink.write_string(fromdid);
    }
    attach.to_data(sink); // visit boost::variant
}

`etp` attachment

Empty.
Nothing to serialize.

`asset` attachment

struct

uint32_t status; // 1 for issue, 2 for transfer
boost::variant<asset_detail, asset_transfer> data;

serialization

void asset::to_data(writer& sink) const
{
    sink.write_4_bytes_little_endian(status);
    data.to_data(sink); // visit boost::variant
}

1. `asset_detail`

struct

std::string symbol;      // < 64 bytes
uint64_t maximum_supply;
uint8_t decimal_number;
uint8_t secondaryissue_threshold;
uint8_t unused2;
uint8_t unused3;
std::string issuer;      // < 64 bytes
std::string address;     // < 64 bytes
std::string description; // < 64 bytes

serialization

void asset_detail::to_data(writer& sink) const
{
    sink.write_string(symbol);
    sink.write_8_bytes_little_endian(maximum_supply);
    sink.write_byte(decimal_number);
    sink.write_byte(secondaryissue_threshold);
    sink.write_byte(unused2);
    sink.write_byte(unused3);
    sink.write_string(issuer);
    sink.write_string(address);
    sink.write_string(description);
}

2. `asset_transfer`

struct

std::string symbol; // < 64 bytes
uint64_t quantity;  // = 8 bytes

serialization

void asset_transfer::to_data(writer& sink) const
{
    sink.write_string(symbol);
    sink.write_8_bytes_little_endian(quantity);
}

`blockchain_message` attachment

struct

std::string content; // < 253 bytes

serialization

void message::to_data(writer& sink) const
{
    sink.write_string(content);
}

`did` attachment

struct

uint32_t status;     // 1 for register, 2 for transfer
std::string symbol;  // < 64 bytes
std::string address; // < 64 bytes

serialization

void did::to_data(writer& sink) const
{
    sink.write_4_bytes_little_endian(status);
    sink.write_string(symbol);
    sink.write_string(address);
}

`asset_cert` attachment

struct

std::string symbol;   // < 64 bytes
std::string owner;    // < 64 bytes
std::string address;  // < 64 bytes
uint32_t cert_type;   // = 4 bytes
uint8_t status;       // = 1 byte
std::string content;  // < 64 bytes

cert type

1 : issue
2 : domain
3 : naming
0x60000004 : mining
5 : witness

0x80000000 : marriage
0x80000001 : kyc

serialization

void asset_cert::to_data(writer& sink) const
{
    sink.write_string(symbol);
    sink.write_string(owner);
    sink.write_string(address);
    sink.write_4_bytes_little_endian(cert_type);
    sink.write_byte(status);

    if (has_content()) { // only write in issuing *mining* asset cert
        sink.write_string(content);
    }
}

`asset_mit` attachment

struct

uint8_t status.      // 1 for register, 2 for transfer
std::string symbol;  // < 64 bytes
std::string address; // < 64 bytes
std::string content; // < 256 bytes

serialization

void asset_mit::to_data(writer& sink) const
{
    sink.write_byte(status);
    sink.write_string(symbol);
    sink.write_string(address);

    if (is_register_status()) { // don't write in transfer case
        sink.write_string(content);
    }
}

Transaction signing

Exactly the same as Bitcoin

ref. https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch06.asciidoc#digital-signatures-ecdsa

Signing use RPC API

First install and run a metaverse full node.
ref. https://mvs.org/wallet.html and https://docs.mvs.org/docs/

ref. https://docs.mvs.org/api_v3/rawtx.html

use createrawtx to create metaverse raw transaction
use decoderawtx to decode raw transaction to json string
use signrawtx to sign raw transaction
use sendrawtx to broadcast signed transaction

You can combine the above APIs to check and verify your own implementation of creating and signing metaverse transaction.

Hexo

Transaction format and signing

Transaction format

Transaction

Transaction Input

Transaction Output

Script

Output attachment

`etp` attachment

`asset` attachment

1. `asset_detail`

2. `asset_transfer`

`blockchain_message` attachment

`did` attachment

`asset_cert` attachment

`asset_mit` attachment

Transaction signing

Signing use RPC API

Transaction format

Transaction

Transaction Input

Transaction Output

Script

Output attachment

etp attachment

asset attachment

1. asset_detail

2. asset_transfer

blockchain_message attachment

did attachment

asset_cert attachment

asset_mit attachment

Transaction signing

Signing use RPC API

`etp` attachment

`asset` attachment

1. `asset_detail`

2. `asset_transfer`

`blockchain_message` attachment

`did` attachment

`asset_cert` attachment

`asset_mit` attachment