/*
 * Generated using zcbor version 0.6.0
 * https://github.com/NordicSemiconductor/zcbor
 * Generated with a --default-max-qty of 3
 */

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include "zcbor_encode.h"
#include "eip4527_encode.h"

#if DEFAULT_MAX_QTY != 3
#error "The type file was generated with a different default_max_qty than this file"
#endif

static bool encode_uuid(zcbor_state_t *state, const struct zcbor_string *input);

static bool encode_repeated_eth_signature_request_id(zcbor_state_t *state, const struct eth_signature_request_id *input);

static bool encode_repeated_eth_signature_signature_origin(zcbor_state_t *state, const struct eth_signature_signature_origin *input);

static bool encode_coininfo(zcbor_state_t *state, const struct coininfo *input);

static bool encode_repeated_hd_key_use_info(zcbor_state_t *state, const struct hd_key_use_info *input);

static bool encode_path_component(zcbor_state_t *state, const struct path_component *input);

static bool encode_repeated_crypto_keypath_source_fingerprint(zcbor_state_t *state, const struct crypto_keypath_source_fingerprint *input);

static bool encode_repeated_crypto_keypath_depth(zcbor_state_t *state, const struct crypto_keypath_depth *input);

static bool encode_crypto_keypath(zcbor_state_t *state, const struct crypto_keypath *input);

static bool encode_repeated_crypto_multi_accounts_device(zcbor_state_t *state, const struct crypto_multi_accounts_device *input);

static bool encode_repeated_crypto_multi_accounts_device_id(zcbor_state_t *state, const struct crypto_multi_accounts_device_id *input);

static bool encode_repeated_crypto_multi_accounts_version(zcbor_state_t *state, const struct crypto_multi_accounts_version *input);

static bool encode_crypto_multi_accounts(zcbor_state_t *state, const struct crypto_multi_accounts *input);

static bool encode_hd_key(zcbor_state_t *state, const struct hd_key *input);

static bool encode_eth_signature(zcbor_state_t *state, const struct eth_signature *input);


static bool encode_uuid(
		zcbor_state_t *state, const struct zcbor_string *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((zcbor_tag_encode(state, 37)
	&& (zcbor_bstr_encode(state, (&(*input))))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_eth_signature_request_id(
		zcbor_state_t *state, const struct eth_signature_request_id *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (1))))
	&& (encode_uuid(state, (&(*input)._eth_signature_request_id)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_eth_signature_signature_origin(
		zcbor_state_t *state, const struct eth_signature_signature_origin *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (3))))
	&& (zcbor_tstr_encode(state, (&(*input)._eth_signature_signature_origin)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_coininfo(
		zcbor_state_t *state, const struct coininfo *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = (((zcbor_map_start_encode(state, 2) && (((((zcbor_uint32_put(state, (1))))
	&& ((((((((*input)._coininfo_coin_type <= 4294967295)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._coininfo_coin_type))))
	&& (((zcbor_uint32_put(state, (2))))
	&& (zcbor_int32_encode(state, (&(*input)._coininfo_network))))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 2))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_hd_key_use_info(
		zcbor_state_t *state, const struct hd_key_use_info *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (5))))
	&& zcbor_tag_encode(state, 305)
	&& (encode_coininfo(state, (&(*input)._hd_key_use_info)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_path_component(
		zcbor_state_t *state, const struct path_component *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((((((((((((*input)._path_component__child_index <= 4294967295)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._path_component__child_index))))
	&& ((zcbor_bool_encode(state, (&(*input)._path_component__is_hardened)))))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_crypto_keypath_source_fingerprint(
		zcbor_state_t *state, const struct crypto_keypath_source_fingerprint *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (2))))
	&& ((((((*input)._crypto_keypath_source_fingerprint <= 4294967295)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._crypto_keypath_source_fingerprint)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_crypto_keypath_depth(
		zcbor_state_t *state, const struct crypto_keypath_depth *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (3))))
	&& ((((((*input)._crypto_keypath_depth <= 255)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._crypto_keypath_depth)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_crypto_keypath(
		zcbor_state_t *state, const struct crypto_keypath *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = (((zcbor_map_start_encode(state, 3) && (((((zcbor_uint32_put(state, (1))))
	&& (zcbor_list_start_encode(state, 20) && ((zcbor_multi_encode_minmax(0, 10, &(*input)._crypto_keypath_components__path_component_count, (zcbor_encoder_t *)encode_path_component, state, (&(*input)._crypto_keypath_components__path_component), sizeof(struct path_component))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 20)))
	&& zcbor_present_encode(&((*input)._crypto_keypath_source_fingerprint_present), (zcbor_encoder_t *)encode_repeated_crypto_keypath_source_fingerprint, state, (&(*input)._crypto_keypath_source_fingerprint))
	&& zcbor_present_encode(&((*input)._crypto_keypath_depth_present), (zcbor_encoder_t *)encode_repeated_crypto_keypath_depth, state, (&(*input)._crypto_keypath_depth))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 3))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_crypto_multi_accounts_device(
		zcbor_state_t *state, const struct crypto_multi_accounts_device *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (3))))
	&& (zcbor_tstr_encode(state, (&(*input)._crypto_multi_accounts_device)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_crypto_multi_accounts_device_id(
		zcbor_state_t *state, const struct crypto_multi_accounts_device_id *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (4))))
	&& ((((((*input)._crypto_multi_accounts_device_id.len >= 20)
	&& ((*input)._crypto_multi_accounts_device_id.len <= 20)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_bstr_encode(state, (&(*input)._crypto_multi_accounts_device_id)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_repeated_crypto_multi_accounts_version(
		zcbor_state_t *state, const struct crypto_multi_accounts_version *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = ((((zcbor_uint32_put(state, (5))))
	&& (zcbor_tstr_encode(state, (&(*input)._crypto_multi_accounts_version)))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_crypto_multi_accounts(
		zcbor_state_t *state, const struct crypto_multi_accounts *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = (((zcbor_map_start_encode(state, 5) && (((((zcbor_uint32_put(state, (1))))
	&& ((((((*input)._crypto_multi_accounts_master_fingerprint <= 4294967295)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._crypto_multi_accounts_master_fingerprint))))
	&& (((zcbor_uint32_put(state, (2))))
	&& (zcbor_list_start_encode(state, 3) && ((zcbor_multi_encode_minmax(0, 3, &(*input)._crypto_multi_accounts_keys__hd_key_count, (zcbor_encoder_t *)encode_hd_key, state, (&(*input)._crypto_multi_accounts_keys__hd_key), sizeof(struct hd_key))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 3)))
	&& zcbor_present_encode(&((*input)._crypto_multi_accounts_device_present), (zcbor_encoder_t *)encode_repeated_crypto_multi_accounts_device, state, (&(*input)._crypto_multi_accounts_device))
	&& zcbor_present_encode(&((*input)._crypto_multi_accounts_device_id_present), (zcbor_encoder_t *)encode_repeated_crypto_multi_accounts_device_id, state, (&(*input)._crypto_multi_accounts_device_id))
	&& zcbor_present_encode(&((*input)._crypto_multi_accounts_version_present), (zcbor_encoder_t *)encode_repeated_crypto_multi_accounts_version, state, (&(*input)._crypto_multi_accounts_version))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 5))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_hd_key(
		zcbor_state_t *state, const struct hd_key *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = (((zcbor_map_start_encode(state, 9) && (((((zcbor_uint32_put(state, (1))))
	&& (zcbor_bool_encode(state, (&(*input)._hd_key_is_master))))
	&& (((zcbor_uint32_put(state, (2))))
	&& (zcbor_bool_encode(state, (&(*input)._hd_key_is_private))))
	&& (((zcbor_uint32_put(state, (3))))
	&& ((((((*input)._hd_key_key_data.len >= 33)
	&& ((*input)._hd_key_key_data.len <= 33)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_bstr_encode(state, (&(*input)._hd_key_key_data))))
	&& (((zcbor_uint32_put(state, (4))))
	&& ((((((*input)._hd_key_chain_code.len >= 32)
	&& ((*input)._hd_key_chain_code.len <= 32)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_bstr_encode(state, (&(*input)._hd_key_chain_code))))
	&& zcbor_present_encode(&((*input)._hd_key_use_info_present), (zcbor_encoder_t *)encode_repeated_hd_key_use_info, state, (&(*input)._hd_key_use_info))
	&& (((zcbor_uint32_put(state, (6))))
	&& zcbor_tag_encode(state, 304)
	&& (encode_crypto_keypath(state, (&(*input)._hd_key_origin))))
	&& (((zcbor_uint32_put(state, (8))))
	&& ((((((*input)._hd_key_parent_fingerprint <= 4294967295)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
	&& (zcbor_uint32_encode(state, (&(*input)._hd_key_parent_fingerprint))))
	&& (((zcbor_uint32_put(state, (9))))
	&& (zcbor_tstr_encode(state, (&(*input)._hd_key_name))))
	&& (((zcbor_uint32_put(state, (10))))
	&& (zcbor_tstr_encode(state, (&(*input)._hd_key_source))))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 9))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}


static bool encode_eth_signature(
		zcbor_state_t *state, const struct eth_signature *input)
{
	zcbor_print("%s\r\n", __func__);

	bool tmp_result = (((zcbor_map_start_encode(state, 3) && ((zcbor_present_encode(&((*input)._eth_signature_request_id_present), (zcbor_encoder_t *)encode_repeated_eth_signature_request_id, state, (&(*input)._eth_signature_request_id))
	&& (((zcbor_uint32_put(state, (2))))
	&& (zcbor_bstr_encode(state, (&(*input)._eth_signature_signature))))
	&& zcbor_present_encode(&((*input)._eth_signature_signature_origin_present), (zcbor_encoder_t *)encode_repeated_eth_signature_signature_origin, state, (&(*input)._eth_signature_signature_origin))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 3))));

	if (!tmp_result)
		zcbor_trace();

	return tmp_result;
}



int cbor_encode_eth_signature(
		uint8_t *payload, size_t payload_len,
		const struct eth_signature *input,
		size_t *payload_len_out)
{
	zcbor_state_t states[3];

	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);

	bool ret = encode_eth_signature(states, input);

	if (ret && (payload_len_out != NULL)) {
		*payload_len_out = MIN(payload_len,
				(size_t)states[0].payload - (size_t)payload);
	}

	if (!ret) {
		int err = zcbor_pop_error(states);

		zcbor_print("Return error: %d\r\n", err);
		return (err == ZCBOR_SUCCESS) ? ZCBOR_ERR_UNKNOWN : err;
	}
	return ZCBOR_SUCCESS;
}



int cbor_encode_hd_key(
		uint8_t *payload, size_t payload_len,
		const struct hd_key *input,
		size_t *payload_len_out)
{
	zcbor_state_t states[5];

	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);

	bool ret = encode_hd_key(states, input);

	if (ret && (payload_len_out != NULL)) {
		*payload_len_out = MIN(payload_len,
				(size_t)states[0].payload - (size_t)payload);
	}

	if (!ret) {
		int err = zcbor_pop_error(states);

		zcbor_print("Return error: %d\r\n", err);
		return (err == ZCBOR_SUCCESS) ? ZCBOR_ERR_UNKNOWN : err;
	}
	return ZCBOR_SUCCESS;
}



int cbor_encode_crypto_multi_accounts(
		uint8_t *payload, size_t payload_len,
		const struct crypto_multi_accounts *input,
		size_t *payload_len_out)
{
	zcbor_state_t states[7];

	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);

	bool ret = encode_crypto_multi_accounts(states, input);

	if (ret && (payload_len_out != NULL)) {
		*payload_len_out = MIN(payload_len,
				(size_t)states[0].payload - (size_t)payload);
	}

	if (!ret) {
		int err = zcbor_pop_error(states);

		zcbor_print("Return error: %d\r\n", err);
		return (err == ZCBOR_SUCCESS) ? ZCBOR_ERR_UNKNOWN : err;
	}
	return ZCBOR_SUCCESS;
}