carbon.ts

import { 
    accept,
    emit,
    etxn_details,
    etxn_fee_base,
    etxn_reserve,
    hook_account,
    ledger_seq,
    otxn_field,
    rollback,
    trace_,
    trace_num,
    util_accid, _g
} from "./lib";

const sfAmount = ((6 << 16) + 1);
const sfAccount = ((8 << 16) + 1);

// for !HAS_CALLBACK
const PREPARE_PAYMENT_SIMPLE_SIZE = 248;

const ttPAYMENT: u8 = 0;
const tfCANONICAL: u32 = 0x80000000;

const atACCOUNT: u8 = 1;
const atDESTINATION: u8 = 3;

const amAMOUNT: u8 = 1;
const amFEE: u8 = 8;

@inline function TRACESTR(text: string): void {
    trace_("", 0, text, text.length * 2, 0)
}

@inline function IS_BUFFER_EQUAL(buf1: i32, buf2: i32, len: i32, gid: i32): bool {
    for (var i = 0; _g(gid, len + 1), i < len; ++i) {
	if (load<u8>(buf1 + i) != load<u8>(buf2 + i)) {
	    return false;
	}
    }

    return true;
}

@inline function AMOUNT_TO_DROPS(amount_buffer: u32): i64 {
     return (load<u8>(amount_buffer) >> 7) ? -2 : (
	 (((load<u8>(amount_buffer) as u64) & 0xb00111111) << 56) +
	     ((load<u8>(amount_buffer + 1) as u64) << 48) +
	     ((load<u8>(amount_buffer + 2) as u64) << 40) +
	     ((load<u8>(amount_buffer + 3) as u64)) << 32) +
	     ((load<u8>(amount_buffer + 4) as u64) << 24) +
	     ((load<u8>(amount_buffer + 5) as u64) << 16) +
	     ((load<u8>(amount_buffer + 6) as u64) <<  8) +
	     ((load<u8>(amount_buffer + 7) as u64));
}

@inline function ENCODE_TT(buf: u32, utt: u8): u32 {
    store<u8>(buf, 0x12);
    store<u8>(buf + 1, 0);
    store<u8>(buf + 2, utt);
    return buf + 3;
}

@inline function ENCODE_UINT32_COMMON(buf: u32, ui: u32, uf: u8): u32 {
    store<u8>(buf, 0x20 + (uf & 0x0F));
    store<u8>(buf + 1, (ui >> 24) & 0xFF);
    store<u8>(buf + 2, (ui >> 16) & 0xFF);
    store<u8>(buf + 3, (ui >> 8) & 0xFF);
    store<u8>(buf + 4, ui & 0xFF);
    return buf + 5;
}

@inline function ENCODE_UINT32_UNCOMMON(buf: u32, ui: u32, uf: u8): u32 {
    store<u8>(buf, 0x20);
    store<u8>(buf + 1, uf);
    store<u8>(buf + 2, (ui >> 24) & 0xFF);
    store<u8>(buf + 3, (ui >> 16) & 0xFF);
    store<u8>(buf + 4, (ui >> 8) & 0xFF);
    store<u8>(buf + 5, ui & 0xFF);
    return buf + 6;
}

@inline function ENCODE_DROPS(buf: u32, udrops: u64, uat: u8): u32 {
    store<u8>(buf, 0x60 + (uat & 0x0F));
    store<u8>(buf + 1, 0x40 + ((udrops >> 56) & 0x3F));
    store<u8>(buf + 2, (udrops >> 48) & 0xFF);
    store<u8>(buf + 3, (udrops >> 40) & 0xFF);
    store<u8>(buf + 4, (udrops >> 32) & 0xFF);
    store<u8>(buf + 5, (udrops >> 24) & 0xFF);
    store<u8>(buf + 6, (udrops >> 16) & 0xFF);
    store<u8>(buf + 7, (udrops >> 8) & 0xFF);
    store<u8>(buf + 8, udrops & 0xFF);
    return buf + 9;
}

@inline function ENCODE_ACCOUNT(buf: u32, account_id: u32, uat: u8): u32 {
    store<u8>(buf, 0x80 + uat);
    store<u8>(buf + 1, 0x14);
    store<u64>(buf + 2, load<u64>(account_id));
    store<u64>(buf + 10, load<u64>(account_id + 8));
    store<u32>(buf + 18, load<u32>(account_id + 16));
    return buf + 22;
}

@inline function _01_02_ENCODE_TT(buf: u32, tt: u8): u32 {
    return ENCODE_TT(buf, tt);
}

@inline function _02_02_ENCODE_FLAGS(buf: u32, tag: u32): u32 {
    return ENCODE_UINT32_COMMON(buf, tag, 0x2);
}

@inline function _02_03_ENCODE_TAG_SRC(buf: u32, tag: u32): u32 {
    return ENCODE_UINT32_COMMON(buf, tag, 0x3);
}

@inline function _02_04_ENCODE_SEQUENCE(buf: u32, sequence: u32): u32 {
    return ENCODE_UINT32_COMMON(buf, sequence, 0x4);
}

@inline function _02_14_ENCODE_TAG_DST(buf: u32, tag: u32): u32 {
    return ENCODE_UINT32_COMMON(buf, tag, 0xE);
}

@inline function _02_26_ENCODE_FLS(buf: u32, fls: u32): u32 {
    return ENCODE_UINT32_UNCOMMON(buf, fls, 0x1A);
}

@inline function _02_27_ENCODE_LLS(buf: u32, lls: u32): u32 {
    return ENCODE_UINT32_UNCOMMON(buf, lls, 0x1B);
}

@inline function _06_01_ENCODE_DROPS_AMOUNT(buf: u32, drops: u64): u32 {
    return ENCODE_DROPS(buf, drops, amAMOUNT);
}

@inline function _06_08_ENCODE_DROPS_FEE(buf: u32, drops: u64): u32 {
    return ENCODE_DROPS(buf, drops, amFEE);
}

// bug-for-bug compatible w/ ENCODE_SIGNING_PUBKEY_NULL in macro.h
@inline function _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf: u32): u32 {
    store<u8>(buf, 0x73);
    store<u8>(buf + 1, 0x21);
    store<u64>(buf + 2, 0);
    store<u64>(buf + 10, 0);
    store<u64>(buf + 18, 0);
    store<u64>(buf + 25, 0);
    return buf + 35;
}

@inline function _08_01_ENCODE_ACCOUNT_SRC(buf: u32, account_id: u32): u32 {
    return ENCODE_ACCOUNT(buf, account_id, atACCOUNT);
}

@inline function _08_03_ENCODE_ACCOUNT_DST(buf: u32, account_id: u32): u32 {
    return ENCODE_ACCOUNT(buf, account_id, atDESTINATION);
}

@inline function PREPARE_PAYMENT_SIMPLE(buf_out_master: u32, drops_amount: u64, to_address: u32, dest_tag: u32, src_tag: u32): void {
    var buf_out = buf_out_master;
    const acc = memory.data(20) as u32;
    const cls = ledger_seq() as u32;
    hook_account(acc, 20);
    buf_out = _01_02_ENCODE_TT(buf_out, ttPAYMENT);
    buf_out = _02_02_ENCODE_FLAGS(buf_out, tfCANONICAL);
    buf_out = _02_03_ENCODE_TAG_SRC(buf_out, src_tag);
    buf_out = _02_04_ENCODE_SEQUENCE(buf_out, 0);
    buf_out = _02_14_ENCODE_TAG_DST(buf_out, dest_tag);
    buf_out = _02_26_ENCODE_FLS(buf_out, cls + 1);
    buf_out = _02_27_ENCODE_LLS(buf_out, cls + 5);
    buf_out = _06_01_ENCODE_DROPS_AMOUNT(buf_out, drops_amount);
    var fee_ptr = buf_out;
    buf_out = _06_08_ENCODE_DROPS_FEE(buf_out, 0);
    buf_out = _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out);
    buf_out = _08_01_ENCODE_ACCOUNT_SRC(buf_out, acc);
    buf_out = _08_03_ENCODE_ACCOUNT_DST(buf_out, to_address);
    etxn_details(buf_out, PREPARE_PAYMENT_SIMPLE_SIZE);
    var fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);
    _06_08_ENCODE_DROPS_FEE(fee_ptr, fee);
}

export function hook(reserved: i32 = 0): i64 {
    // before we start calling hook-api functions we should tell the hook how many tx we intend to create
    etxn_reserve(1); // we are going to emit 1 transaction

    const carbon_accid = memory.data(20) as u32;
    const raddr = memory.data(34) as u32;
    const acct = "rhJGnHbgxfu7aYUwdDR8FQLFn1yTm1i2Zm";
    for (var i = 0; _g(18, 35), i < 34; ++i)
        store<u8>(raddr + i, acct.charCodeAt(i));

    const ret = util_accid(
        carbon_accid,
        20,
        raddr,
        34);
    trace_num("ret", 6, ret);

    // this api fetches the AccountID of the account the hook currently executing is installed on
    // since hooks can be triggered by both incoming and ougoing transactions this is important to know
    const hook_accid = memory.data(20) as u32;
    hook_account(hook_accid, 20);

    // next fetch the sfAccount field from the originating transaction
    const account_field = memory.data(20) as u32;
    const account_field_len = otxn_field(account_field, 20, sfAccount);
    trace_num("account_field_len", 34, account_field_len);
    if (account_field_len < 20)                                   // negative values indicate errors from every api
        rollback("Carbon: sfAccount field missing!!!", 68, 1);    // this code could never be hit in prod
                                                                  // but it's here for completeness

    // compare the "From Account" (sfAccount) on the transaction with the account the hook is running on
    if (!IS_BUFFER_EQUAL(hook_accid, account_field, 20, 50)) {
        // if the accounts are not equal (memcmp != 0) the otxn was sent to the hook account by someone else
        // accept() it and end the hook execution here
        accept("Carbon: Incoming transaction", 56, 2);
    }

    // execution to here means the user has sent a valid transaction FROM the account the hook is installed on

    // fetch the sent Amount
    // Amounts can be 384 bits or 64 bits. If the Amount is an XRP value it will be 64 bits.
    const amount_buffer = memory.data(48) as u32;
    const amount_len = otxn_field(amount_buffer, 48, sfAmount);
    var drops_to_send: i64 = 1000; // this will be the default

    if (amount_len != 8) {
        // you can trace the behaviour of your hook using the trace(buf, size, as_hex) api
        // which will output to xrpld's trace log
        TRACESTR("Carbon: Non-xrp transaction detected, sending default 1000 drops to rfCarbon");
    } else {
        TRACESTR("Carbon: XRP transaction detected, computing 1% to send to rfCarbon");
        const otxn_drops = AMOUNT_TO_DROPS(amount_buffer);
	trace_num("otxn_drops", 20, otxn_drops);
        if (otxn_drops > 100000)   // if its less we send the default amount. or if there was an error we send default
            drops_to_send = otxn_drops / 100; // otherwise we send 1%
    }

    trace_num("drops_to_send", 26, drops_to_send);

    // create a buffer to write the emitted transaction into
    const tx = memory.data(PREPARE_PAYMENT_SIMPLE_SIZE) as u32;
    
    // this will populate the buffer with a serialized binary transaction
    PREPARE_PAYMENT_SIMPLE(tx, drops_to_send, carbon_accid, 0, 0);

    // emit the transaction
    const emithash = memory.data(32) as u32;
    const emit_result = emit(emithash, 32, tx, PREPARE_PAYMENT_SIMPLE_SIZE);
    trace_num("emit_result", 22, emit_result);
    
    // accept and allow the original transaction through
    accept("Carbon: Emitted transaction", 58, 0);
    return 0;
}

lib.ts

/**
 * Guard function. Each time a loop appears in your code a call to this must be the first branch instruction after the
 * beginning of the loop.
 * @param id The identifier of the guard (typically the line number).
 * @param maxiter The maximum number of times this loop will iterate across the life of the hook.
 * @return Can be ignored. If the guard is violated the hook will terminate.
 */
@external('env', '_g')
export declare function _g(id: i32, maxiter: i32): i32

/**
 * Accept the originating transaction and commit all hook state changes and submit all emitted transactions.
 * @param read_ptr An optional string to use as a return comment. May be 0.
 * @param read_len The length of the string. May be 0.
 * @return Will never return, terminates the hook.
 */
@external('env', 'accept')
export declare function accept(read_ptr: string, read_len: i32, error_code: i64): i64

/**
 * Rollback the originating transaction, discard all hook state changes and emitted transactions.
 * @param read_ptr An optional string to use as a return comment. May be 0.
 * @param read_len The length of the string. May be 0.
 * @return Will never return, terminates the hook.
 */
@external('env', 'rollback')
export declare function rollback(read_ptr: string, read_len: i32, error_code: i64): i64

/**
 * Read a 20 byte account-id from the memory pointed to by read_ptr of length read_len and encode it to a base58-check
 * encoded r-address.
 * @param read_ptr The memory address of the account-id
 * @param read_len The byte length of the account-id (should always be 20)
 * @param write_ptr The memory address of a suitable buffer to write the encoded r-address into.
 * @param write_len The size of the write buffer.
 * @return On success the length of the r-address will be returned indicating the bytes written to the write buffer.
 *         On failure a negative integer is returned indicating what went wrong.
 */
@external('env', 'util_raddr')
export declare function util_raddr(write_ptr: i32, write_len: i32, read_ptr: i32, read_len: i32): i64

/**
 * Read an r-address from the memory pointed to by read_ptr of length read_len and decode it to a 20 byte account id
 * and write to write_ptr
 * @param read_ptr The memory address of the r-address
 * @param read_len The byte length of the r-address
 * @param write_ptr The memory address of a suitable buffer to write the decoded account id into.
 * @param write_len The size of the write buffer.
 * @return On success 20 will be returned indicating the bytes written. On failure a negative integer is returned
 *         indicating what went wrong.
 */
@external('env', 'util_accid')
export declare function util_accid(write_ptr: i32, write_len: i32, read_ptr: i32, read_len: i32): i64

/**
 * Verify a cryptographic signature either ED25519 of SECP256k1. Public key should be prefixed with 0xED for 25519.
 * @param dread_ptr The memory location of the data or payload to verify
 * @param dread_len The length of the data or payload to verify
 * @param sread_ptr The memory location of the signature
 * @param sread_len The length of the signature
 * @param kread_ptr The memory location of the public key
 * @param kread_len The length of the public key
 * @return True if and only if the signature was verified.
 */
@external('env', 'util_verify')
export declare function util_verify(dread_ptr: i32, dread_len: i32, sread_ptr: i32, sread_len: i32, kread_ptr: i32, kread_len: i32): i64

/**
 * Compute the first half of a SHA512 checksum.
 * @param write_ptr The buffer to write the checksum into. Must be at least 32 bytes.
 * @param write_len The length of the buffer.
 * @param read_ptr  The buffer to read data for digest from.
 * @param read_len  The amount of data to read from the buffer.
 * @return The number of bytes written to write_ptr or a negative integer on error.
 */
@external('env', 'util_sha512h')
export declare function util_sha512h(write_ptr: i32, write_len: i32, read_ptr: i32,  read_len: i32): i64

/**
 * Index into a xrpld serialized object and return the location and length of a subfield. Except for Array subtypes
 * the offset and length refer to the **payload** of the subfield not the entire subfield. Use SUB_OFFSET and
 * SUB_LENGTH macros to extract return value.
 * @param read_ptr The memory location of the stobject
 * @param read_len The length of the stobject
 * @param field_id The Field Code of the subfield
 * @return high-word (most significant 4 bytes excluding the most significant bit (MSB)) is the field offset relative
 *         to read_ptr and the low-word (least significant 4 bytes) is its length. MSB is sign bit, if set (negative)
 *         return value indicates error (typically error means could not find.)
 */
@external('env', 'sto_subfield')
export declare function sto_subfield(read_ptr: i32, read_len: i32, field_id: i32): i64


/**
 * Index into a xrpld serialized array and return the location and length of an index. Unlike sto_subfield this api
 * always returns the offset and length of the whole object at that index (not its payload.) Use SUB_OFFSET and
 * SUB_LENGTH macros to extract return value.
 * @param read_ptr The memory location of the stobject
 * @param read_len The length of the stobject
 * @param array_id The index requested
 * @return high-word (most significant 4 bytes excluding the most significant bit (MSB)) is the field offset relative
 *         to read_ptr and the low-word (least significant 4 bytes) is its length. MSB is sign bit, if set (negative)
 *         return value indicates error (typically error means could not find.)
 */
@external('env', 'sto_subarray')
export declare function sto_subarray(read_ptr: i32,  read_len: i32, array_id: i32): i64

@external('env', 'sto_validate')
export declare function sto_validate(read_ptr: i32,  read_len: i32): i64

@external('env', 'sto_emplace')
export declare function sto_emplace(write_ptr: i32, write_len: i32, sread_ptr: i32, sread_len: i32, fread_ptr: i32, fread_len: i32, field_id: i32): i64

@external('env', 'sto_erase')
export declare function sto_erase(write_ptr: i32,  write_len: i32, read_ptr: i32, read_len: i32, field_id: i32): i64

@external('env', 'util_keylet')
export declare function util_keylet(write_ptr: i32, write_len: i32, keylet_type: i32, a: i32, b: i32, c: i32, d: i32, e: i32, f: i32): i64

/**
 * Compute burden for an emitted transaction.
 * @return the burden a theoretically emitted transaction would have.
 */
@external('env', 'etxn_burden')
export declare function etxn_burden(): i64

/**
 * Write a full emit_details stobject into the buffer specified.
 * @param write_ptr A sufficiently large buffer to write into.
 * @param write_len The length of that buffer.
 * @return The number of bytes written or a negative integer indicating an error.
 */
@external('env', 'etxn_details')
export declare function etxn_details(write_ptr: i32, write_len: i32): i64

/**
 * Compute the minimum fee required to be paid by a hypothetically emitted transaction based on its size in bytes.
 * @return The minimum fee in drops this transaction should pay to succeed
 */
@external('env', 'etxn_fee_base')
export declare function etxn_fee_base(read_ptr: i32, read_len: i32): i64

/**
 * Inform xrpld that you will be emitting at most @count@ transactions during the course of this hook execution.
 * @param count The number of transactions you intend to emit from this  hook.
 * @return If a negaitve integer an error has occured
 */
@external('env', 'etxn_reserve')
export declare function etxn_reserve(count: i32): i64

/**
 * Compute the generation of an emitted transaction. If this hook was invoked by a transaction emitted by a previous
 * hook then the generation counter will be 1+ the previous generation counter otherwise it will be 1.
 * @return The generation of a hypothetically emitted transaction.
 */
@external('env', 'etxn_generation')
export declare function etxn_generation(): i64

/**
 * Emit a transaction from this hook.
 * @param read_ptr Memory location of a buffer containing the fully formed binary transaction to emit.
 * @param read_len The length of the transaction.
 * @return A negative integer if the emission failed.
 */
 @external('env', 'emit')
export declare function emit(write_ptr: i32, write_len: i32, read_ptr: i32, read_len: i32): i64

/**
 * Retrieve the account the hook is running on.
 * @param write_ptr A buffer of at least 20 bytes to write into.
 * @param write_len The length of that buffer
 * @return The number of bytes written into the buffer of a negative integer if an error occured.
 */
@external('env', 'hook_account')
export declare function hook_account(write_ptr: i32, write_len: i32): i64

/**
 * Retrieve the hash of the currently executing hook.
 * @param write_ptr A buffer of at least 32 bytes to write into.
 * @param write_len The length of that buffer
 * @return The number of bytes written into the buffer of a negative integer if an error occured.
 */
@external('env', 'emhook_hashit')
export declare function hook_hash(write_ptr: i32, write_len: i32): i64

/**
 * Retrive the currently recommended minimum fee for a transaction to succeed.
 */
@external('env', 'fee_base')
export declare function fee_base(): i64

/**
 * Retrieve the current ledger sequence number
 */
@external('env', 'ledger_seq')
export declare function ledger_seq(): i64

@external('env', 'ledger_last_hash')
export declare function ledger_last_hash(write_ptr: i32, write_len: i32): i64

/**
 * Retrieve a nonce for use in an emitted transaction (or another task). Can be called repeatedly for multiple nonces.
 * @param write_ptr A buffer of at least 32 bytes to write into.
 * @param write_len The length of that buffer
 * @return The number of bytes written into the buffer of a negative integer if an error occured.
 */
@external('env', 'nonce')
export declare function nonce(write_ptr: i32, write_len: i32): i64


/**
 * Slot functions have not been implemented yet and the api for them is subject to change
 */
@external('env', 'slot')
export declare function slot(write_ptr: i32, write_len: i32, slot: i32): i64

@external('env', 'slot_clear')
export declare function slot_clear(slot: i32): i64

@external('env', 'slot_count')
export declare function slot_count(slot: i32): i64

@external('env', 'slot_id')
export declare function slot_id(slot: i32): i64

@external('env', 'slot_set')
export declare function slot_set(read_ptr: i32, read_len: i32, slot: i32): i64

@external('env', 'slot_size')
export declare function slot_size(slot: i32): i64

@external('env', 'slot_subarray')
export declare function slot_subarray(parent_slot: i32, array_id: i32, new_slot: i32): i64

@external('env', 'slot_subfield')
export declare function slot_subfield(parent_slot: i32, field_id: i32, new_slot: i32): i64

@external('env', 'slot_type')
export declare function slot_type(slot: i32, flags: i32): i64

@external('env', 'slot_float')
export declare function slot_float(slot: i32): i64

@external('env', 'trace_slot')
export declare function trace_slot(mread_ptr: i32, mread_len: i32, slot: i32): i64

@external('env', 'otxn_slot')
export declare function otxn_slot(slot: i32): i64


/**
 * In the hook's state key-value map, set the value for the key pointed at by kread_ptr.
 * @param read_ptr A buffer containing the data to store
 * @param read_len The length of the data
 * @param kread_ptr A buffer containing the key
 * @param kread_len The length of the key
 * @return The number of bytes stored or a negative integer if an error occured
 */
@external('env', 'state_set')
export declare function state_set(read_ptr: i32, read_len: i32, kread_ptr: i32, kread_len: i32): i64

/**
 * Retrieve a value from the hook's key-value map.
 * @param write_ptr A buffer to write the state value into
 * @param write_len The length of that buffer
 * @param kread_ptr A buffer to read the state key from
 * @param kread_len The length of that key
 * @return The number of bytes written or a negative integer if an error occured.
 */
@external('env', 'state')
export declare function state(write_ptr: i32, write_len: i32, kread_ptr: i32, kread_len: i32): i64

/**
 * Retrieve a value from another hook's key-value map.
 * @param write_ptr A buffer to write the state value into
 * @param write_len The length of that buffer
 * @param kread_ptr A buffer to read the state key from
 * @param kread_len The length of that key
 * @param aread_ptr A buffer containing an account-id of another account containing a hook whose state we are reading
 * @param aread_len The length of the account-id (should always be 20).
 * @return The number of bytes written or a negative integer if an error occured.
 */
@external('env', 'state_foreign')
export declare function state_foreign(write_ptr: i32, write_len: i32, kread_ptr: i32, kread_len: i32, aread_ptr: i32,  aread_len: i32): i64

/**
 * Print some output to the trace log on xrpld. Any xrpld instance set to "trace" log level will see this.
 * @param read_ptr A buffer containing either data or text (in either utf8, or utf16le)
 * @param read_len The byte length of the data/text to send to the trace log
 * @param as_hex If 0 treat the read_ptr as pointing at a string of text, otherwise treat it as data and print hex
 * @return The number of bytes output or a negative integer if an error occured.
 */
@external('env', 'trace')
export declare function trace_(mread_ptr: string, mread_len: i32, dread_ptr: string, dread_len: i32, as_hex: i32): i64

/**
 * Print some output to the trace log on xrpld along with a decimal number. Any xrpld instance set to "trace" log
 * level will see this.
 * @param read_ptr A pointer to the string to output
 * @param read_len The length of the string to output
 * @param number Any integer you wish to display after the text
 * @return A negative value on error
 */
@external('env', 'trace_num')
export declare function trace_num(read_ptr: string, read_len: i32, number: i64): i64

/**
 * Retrieve the burden of the originating transaction (if any)
 * @return The burden of the originating transaction
 */
@external('env', 'otxn_burden')
export declare function otxn_burden(): i64

/**
 * Retrieve a field from the originating transaction as "full text" (The way it is displayed in JSON)
 * @param write_ptr A buffer to write the representation into
 * @param write_len The length of the buffer
 * @param field_id The field code of the field being requested
 * @return The number of bytes written to write_ptr or a negative integer if an error occured.
 */
@external('env', 'otxn_field_txt')
export declare function otxn_field_txt(write_ptr: i32, write_len: i32, field_id: i32): i64

/**
 * Retrieve a field from the originating transaction in its raw serialized form.
 * @param write_ptr A buffer to output the field into
 * @param write_len The length of the buffer.
 * @param field_if The field code of the field being requested
 * @return The number of bytes written to write_ptr or a negative integer if an error occured.
 */
@external('env', 'otxn_field')
export declare function otxn_field(write_ptr: i32, write_len: i32, field_id: i32): i64

/**
 * Retrieve the generation of the originating transaction (if any).
 * @return the generation of the originating transaction.
 */
@external('env', 'otxn_generation')
export declare function otxn_generation(): i64

/**
 * Retrieve the TXNID of the originating transaction.
 * @param write_ptr A buffer at least 32 bytes long
 * @param write_len The length of the buffer.
 * @return The number of bytes written into the buffer or a negative integer on failure.
 */
@external('env', 'otxn_id')
export declare function otxn_id(write_ptr: i32, write_len: i32): i64

/**
 * Retrieve the Transaction Type (e.g. ttPayment = 0) of the originating transaction.
 * @return The Transaction Type (tt-code)
 */
@external('env', 'otxn_type')
export declare function otxn_type(): i64

@external('env', 'float_set')
export declare function float_set(exponent: i32, mantissa: i64): i64

@external('env', 'float_multiply')
export declare function float_multiply(float1: i64, float2: i64): i64

@external('env', 'float_mulratio')
export declare function float_mulratio(float1: i64, round_up: i32, numerator: i32, denominator: i32): i64

@external('env', 'float_negate')
export declare function float_negate(float1: i64): i64

@external('env', 'float_compare')
export declare function float_compare(float1: i64, float2: i64, mode: i32): i64

@external('env', 'float_sum')
export declare function float_sum(float1: i64, float2: i64): i64

@external('env', 'float_sto')
// @ts-ignore
export declare function float_sto(write_ptr: i32, write_len: i32, cread_ptr: i32, cread_len: i32, iread_ptr: i32, iread_le: i32n, float1: i64, field_code: i32): i64

@external('env', 'float_sto_set')
export declare function float_sto_set(read_ptr: i32, read_len: i32): i64

@external('env', 'float_invert')
export declare function float_invert(float1: i64): i64

@external('env', 'float_divide')
export declare function float_divide(float1: i64, float2: i64): i64

@external('env', 'float_one')
export declare function float_one(): i64

@external('env', 'float_exponent')
export declare function float_exponent(float1: i64): i64

@external('env', 'float_exponent_set')
export declare function float_exponent_set(float1: i64, exponent: i32): i64

@external('env', 'float_mantissa')
export declare function float_mantissa(float1: i64): i64

@external('env', 'float_mantissa_set')
export declare function float_mantissa_set(float1: i64, mantissa: i64): i64

@external('env', 'float_sign')
export declare function float_sign(float1: i64): i64

@external('env', 'float_sign_set')
export declare function float_sign_set(float1: i64, negative: i32): i64

@external('env', 'float_int')
export declare function float_int(float1: i64, decimal_places: i32, abs: i32): i64

@external('env', 'trace_float')
export declare function trace_float(mread_ptr: i32, mread_len: i32, float1: i64): i64

const SUCCESS = 0                  // return codes > 0 are reserved for hook apis to return "success"
const OUT_OF_BOUNDS = -1           // could not read or write to a pointer to provided by hook
const INTERNAL_ERROR = -2          // eg directory is corrupt
const TOO_BIG = -3                 // something you tried to store was too big
const TOO_SMALL = -4               // something you tried to store or provide was too small
const DOESNT_EXIST = -5            // something you requested wasn't found
const NO_FREE_SLOTS = -6           // when trying to load an object there is a maximum of 255 slots
const INVALID_ARGUMENT = -7        // self explanatory
const ALREADY_SET = -8             // returned when a one-time parameter was already set by the hook
const PREREQUISITE_NOT_MET = -9    // returned if a required param wasn't set before calling
const FEE_TOO_LARGE = -10          // returned if the attempted operation would result in an absurd fee
const EMISSION_FAILURE = -11       // returned if an emitted tx was not accepted by rippled
const TOO_MANY_NONCES = -12        // a hook has a maximum of 256 nonces
const TOO_MANY_EMITTED_TXN = -13   // a hook has emitted more than its stated number of emitted txn
const NOT_IMPLEMENTED = -14        // an api was called that is reserved for a future version
const INVALID_ACCOUNT = -15        // an api expected an account id but got something else
const GUARD_VIOLATION = -16        // a guarded loop or function iterated over its maximum
const INVALID_FIELD = -17          // the field requested is returning sfInvalid
const PARSE_ERROR = -18            // hook asked hookapi to parse something the contents of which was invalid
const RC_ROLLBACK = -19            // used internally by hook api to indicate a rollback
const RC_ACCEPT = -20              // used internally by hook api to indicate an accept
const NO_SUCH_KEYLET = -21         // the specified keylet or keylet type does not exist or could not be computed

const INVALID_FLOAT = -10024       // if the mantissa or exponent are outside normalized ranges

const KEYLET_HOOK = 1
const KEYLET_HOOK_STATE = 2
const KEYLET_ACCOUNT = 3
const KEYLET_AMENDMENTS = 4
const KEYLET_CHILD = 5
const KEYLET_SKIP = 6
const KEYLET_FEES = 7
const KEYLET_NEGATIVE_UNL = 8
const KEYLET_LINE = 9
const KEYLET_OFFER = 10
const KEYLET_QUALITY = 11
const KEYLET_EMITTED_DIR = 12
const KEYLET_TICKET = 13
const KEYLET_SIGNERS = 14
const KEYLET_CHECK = 15
const KEYLET_DEPOSIT_PREAUTH = 16
const KEYLET_UNCHECKED = 17
const KEYLET_OWNER_DIR = 18
const KEYLET_PAGE = 19
const KEYLET_ESCROW = 20
const KEYLET_PAYCHAN = 21
const KEYLET_EMITTED = 22

const COMPARE_EQUAL = '1U'
const COMPARE_LESS = '2U'
const COMPARE_GREATER = '4U'