/**
 * Copyright (c) 2013-2014 Tomas Dzetkulic
 * Copyright (c) 2013-2014 Pavol Rusnak
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <check.h>
#include "check_mem.h"

#if VALGRIND
#include <valgrind/memcheck.h>
#include <valgrind/valgrind.h>
#endif

#include "options.h"

#include "address.h"
#include "aes/aes.h"
#include "base32.h"
#include "base58.h"
#include "bignum.h"
#include "bip32.h"
#include "bip39.h"
#include "blake256.h"
#include "blake2b.h"
#include "blake2s.h"
#include "curves.h"
#include "ecdsa.h"
#include "ed25519-donna/ed25519-donna.h"
#include "ed25519-donna/ed25519-keccak.h"
#include "ed25519-donna/ed25519.h"
#include "memzero.h"
#include "monero/monero.h"
#include "nem.h"
#include "nist256p1.h"
#include "pbkdf2.h"
#include "rand.h"
#include "rc4.h"
#include "rfc6979.h"
#include "schnorr.h"
#include "script.h"
#include "secp256k1.h"
#include "sha2.h"
#include "sha3.h"
#include "shamir.h"

#if VALGRIND
/*
 * This is a clever trick to make Valgrind's Memcheck verify code
 * is constant-time with respect to secret data.
 */

/* Call after secret data is written, before first use */
#define MARK_SECRET_DATA(addr, len) VALGRIND_MAKE_MEM_UNDEFINED(addr, len)
/* Call before secret data is freed or to mark non-secret data (public keys or
 * signatures) */
#define UNMARK_SECRET_DATA(addr, len) VALGRIND_MAKE_MEM_DEFINED(addr, len)
#else
#define MARK_SECRET_DATA(addr, len)
#define UNMARK_SECRET_DATA(addr, len)
#endif

#define FROMHEX_MAXLEN 512

#define VERSION_PUBLIC 0x0488b21e
#define VERSION_PRIVATE 0x0488ade4

#define DECRED_VERSION_PUBLIC 0x02fda926
#define DECRED_VERSION_PRIVATE 0x02fda4e8

const uint8_t *fromhex(const char *str) {
  static uint8_t buf[FROMHEX_MAXLEN];
  size_t len = strlen(str) / 2;
  if (len > FROMHEX_MAXLEN) len = FROMHEX_MAXLEN;
  for (size_t i = 0; i < len; i++) {
    uint8_t c = 0;
    if (str[i * 2] >= '0' && str[i * 2] <= '9') c += (str[i * 2] - '0') << 4;
    if ((str[i * 2] & ~0x20) >= 'A' && (str[i * 2] & ~0x20) <= 'F')
      c += (10 + (str[i * 2] & ~0x20) - 'A') << 4;
    if (str[i * 2 + 1] >= '0' && str[i * 2 + 1] <= '9')
      c += (str[i * 2 + 1] - '0');
    if ((str[i * 2 + 1] & ~0x20) >= 'A' && (str[i * 2 + 1] & ~0x20) <= 'F')
      c += (10 + (str[i * 2 + 1] & ~0x20) - 'A');
    buf[i] = c;
  }
  return buf;
}

void nem_private_key(const char *reversed_hex, ed25519_secret_key private_key) {
  const uint8_t *reversed_key = fromhex(reversed_hex);
  for (size_t j = 0; j < sizeof(ed25519_secret_key); j++) {
    private_key[j] = reversed_key[sizeof(ed25519_secret_key) - j - 1];
  }
}

START_TEST(test_bignum_read_be) {
  bignum256 a;
  uint8_t input[32];

  memcpy(
      input,
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      32);

  bn_read_be(input, &a);

  bignum256 b = {{0x286d8bd5, 0x380c7c17, 0x3c6a2ec1, 0x2d787ef5, 0x14437cd3,
                  0x25a043f8, 0x1dd5263f, 0x33a162c3, 0x0000c55e}};

  for (int i = 0; i < 9; i++) {
    ck_assert_int_eq(a.val[i], b.val[i]);
  }
}
END_TEST

START_TEST(test_bignum_write_be) {
  bignum256 a = {{0x286d8bd5, 0x380c7c17, 0x3c6a2ec1, 0x2d787ef5, 0x14437cd3,
                  0x25a043f8, 0x1dd5263f, 0x33a162c3, 0x0000c55e}};
  uint8_t tmp[32];

  bn_write_be(&a, tmp);

  ck_assert_mem_eq(
      tmp,
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      32);
}
END_TEST

START_TEST(test_bignum_is_equal) {
  bignum256 a = {{0x286d8bd5, 0x380c7c17, 0x3c6a2ec1, 0x2d787ef5, 0x14437cd3,
                  0x25a043f8, 0x1dd5263f, 0x33a162c3, 0x0000c55e}};
  bignum256 b = {{0x286d8bd5, 0x380c7c17, 0x3c6a2ec1, 0x2d787ef5, 0x14437cd3,
                  0x25a043f8, 0x1dd5263f, 0x33a162c3, 0x0000c55e}};
  bignum256 c = {{
      0,
  }};

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
  ck_assert_int_eq(bn_is_equal(&c, &c), 1);
  ck_assert_int_eq(bn_is_equal(&a, &c), 0);
}
END_TEST

START_TEST(test_bignum_zero) {
  bignum256 a;
  bignum256 b;

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  bn_zero(&b);

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_is_zero) {
  bignum256 a;

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  ck_assert_int_eq(bn_is_zero(&a), 1);

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000001"),
      &a);
  ck_assert_int_eq(bn_is_zero(&a), 0);

  bn_read_be(
      fromhex(
          "1000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  ck_assert_int_eq(bn_is_zero(&a), 0);

  bn_read_be(
      fromhex(
          "f000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  ck_assert_int_eq(bn_is_zero(&a), 0);
}
END_TEST

START_TEST(test_bignum_one) {
  bignum256 a;
  bignum256 b;

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000001"),
      &a);
  bn_one(&b);

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_read_le) {
  bignum256 a;
  bignum256 b;

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      &a);
  bn_read_le(
      fromhex(
          "d58b6de8051f031eeca2c6d7fbe1b5d37c4314fe1068f96352dd0d8b85ce5ec5"),
      &b);

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_write_le) {
  bignum256 a;
  bignum256 b;
  uint8_t tmp[32];

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      &a);
  bn_write_le(&a, tmp);

  bn_read_le(tmp, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  bn_read_be(
      fromhex(
          "d58b6de8051f031eeca2c6d7fbe1b5d37c4314fe1068f96352dd0d8b85ce5ec5"),
      &a);
  bn_read_be(tmp, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_read_uint32) {
  bignum256 a;
  bignum256 b;

  // lowest 30 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000000000003fffffff"),
      &a);
  bn_read_uint32(0x3fffffff, &b);

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  // bit 31 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000040000000"),
      &a);
  bn_read_uint32(0x40000000, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_read_uint64) {
  bignum256 a;
  bignum256 b;

  // lowest 30 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000000000003fffffff"),
      &a);
  bn_read_uint64(0x3fffffff, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  // bit 31 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000040000000"),
      &a);
  bn_read_uint64(0x40000000, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  // bit 33 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000100000000"),
      &a);
  bn_read_uint64(0x100000000LL, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  // bit 61 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000002000000000000000"),
      &a);
  bn_read_uint64(0x2000000000000000LL, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);

  // all 64 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000ffffffffffffffff"),
      &a);
  bn_read_uint64(0xffffffffffffffffLL, &b);
  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_write_uint32) {
  bignum256 a;

  // lowest 30 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000000000003fffffff"),
      &a);
  ck_assert_int_eq(bn_write_uint32(&a), 0x3fffffff);

  // bit 31 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000040000000"),
      &a);
  ck_assert_int_eq(bn_write_uint32(&a), 0x40000000);
}
END_TEST

START_TEST(test_bignum_write_uint64) {
  bignum256 a;

  // lowest 30 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000000000003fffffff"),
      &a);
  ck_assert_int_eq(bn_write_uint64(&a), 0x3fffffff);

  // bit 31 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000040000000"),
      &a);
  ck_assert_int_eq(bn_write_uint64(&a), 0x40000000);

  // bit 33 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000100000000"),
      &a);
  ck_assert_int_eq(bn_write_uint64(&a), 0x100000000LL);

  // bit 61 set
  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000002000000000000000"),
      &a);
  ck_assert_int_eq(bn_write_uint64(&a), 0x2000000000000000LL);

  // all 64 bits set
  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000ffffffffffffffff"),
      &a);
  ck_assert_int_eq(bn_write_uint64(&a), 0xffffffffffffffffLL);
}
END_TEST

START_TEST(test_bignum_copy) {
  bignum256 a;
  bignum256 b;

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      &a);
  bn_copy(&a, &b);

  ck_assert_int_eq(bn_is_equal(&a, &b), 1);
}
END_TEST

START_TEST(test_bignum_is_even) {
  bignum256 a;

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      &a);
  ck_assert_int_eq(bn_is_even(&a), 0);

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd2"),
      &a);
  ck_assert_int_eq(bn_is_even(&a), 1);

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd0"),
      &a);
  ck_assert_int_eq(bn_is_even(&a), 1);
}
END_TEST

START_TEST(test_bignum_is_odd) {
  bignum256 a;

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"),
      &a);
  ck_assert_int_eq(bn_is_odd(&a), 1);

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd2"),
      &a);
  ck_assert_int_eq(bn_is_odd(&a), 0);

  bn_read_be(
      fromhex(
          "c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd0"),
      &a);
  ck_assert_int_eq(bn_is_odd(&a), 0);
}
END_TEST

START_TEST(test_bignum_is_less) {
  bignum256 a;
  bignum256 b;

  bn_read_uint32(0x1234, &a);
  bn_read_uint32(0x8765, &b);

  ck_assert_int_eq(bn_is_less(&a, &b), 1);
  ck_assert_int_eq(bn_is_less(&b, &a), 0);

  bn_zero(&a);
  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &b);

  ck_assert_int_eq(bn_is_less(&a, &b), 1);
  ck_assert_int_eq(bn_is_less(&b, &a), 0);
}
END_TEST

START_TEST(test_bignum_bitcount) {
  bignum256 a, b;

  bn_zero(&a);
  ck_assert_int_eq(bn_bitcount(&a), 0);

  bn_one(&a);
  ck_assert_int_eq(bn_bitcount(&a), 1);

  // test for 10000 and 11111 when i=5
  for (int i = 2; i <= 256; i++) {
    bn_one(&a);
    bn_one(&b);
    for (int j = 2; j <= i; j++) {
      bn_lshift(&a);
      bn_lshift(&b);
      bn_addi(&b, 1);
    }
    ck_assert_int_eq(bn_bitcount(&a), i);
    ck_assert_int_eq(bn_bitcount(&b), i);
  }

  bn_read_uint32(0x3fffffff, &a);
  ck_assert_int_eq(bn_bitcount(&a), 30);

  bn_read_uint32(0xffffffff, &a);
  ck_assert_int_eq(bn_bitcount(&a), 32);

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  ck_assert_int_eq(bn_bitcount(&a), 256);
}
END_TEST

START_TEST(test_bignum_digitcount) {
  bignum256 a;

  bn_zero(&a);
  ck_assert_int_eq(bn_digitcount(&a), 1);

  // test for (10^i) and (10^i) - 1
  uint64_t m = 1;
  for (int i = 0; i <= 19; i++, m *= 10) {
    bn_read_uint64(m, &a);
    ck_assert_int_eq(bn_digitcount(&a), i + 1);

    uint64_t n = m - 1;
    bn_read_uint64(n, &a);
    ck_assert_int_eq(bn_digitcount(&a), n == 0 ? 1 : i);
  }

  bn_read_uint32(0x3fffffff, &a);
  ck_assert_int_eq(bn_digitcount(&a), 10);

  bn_read_uint32(0xffffffff, &a);
  ck_assert_int_eq(bn_digitcount(&a), 10);

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  ck_assert_int_eq(bn_digitcount(&a), 78);
}
END_TEST

START_TEST(test_bignum_format_uint64) {
  char buf[128], str[128];
  int r;
  // test for (10^i) and (10^i) - 1
  uint64_t m = 1;
  for (int i = 0; i <= 19; i++, m *= 10) {
    sprintf(str, "%" PRIu64, m);
    r = bn_format_uint64(m, NULL, NULL, 0, 0, false, buf, sizeof(buf));
    ck_assert_int_eq(r, strlen(str));
    ck_assert_str_eq(buf, str);

    uint64_t n = m - 1;
    sprintf(str, "%" PRIu64, n);
    r = bn_format_uint64(n, NULL, NULL, 0, 0, false, buf, sizeof(buf));
    ck_assert_int_eq(r, strlen(str));
    ck_assert_str_eq(buf, str);
  }
}
END_TEST

START_TEST(test_bignum_format) {
  bignum256 a;
  char buf[128];
  int r;

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, NULL, 20, 0, true, buf, sizeof(buf));
  ck_assert_int_eq(r, 22);
  ck_assert_str_eq(buf, "0.00000000000000000000");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 5, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, -5, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, "", "", 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, "SFFX", 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1 + 4);
  ck_assert_str_eq(buf, "0SFFX");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, "PRFX", NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 4 + 1);
  ck_assert_str_eq(buf, "PRFX0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, "PRFX", "SFFX", 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 4 + 1 + 4);
  ck_assert_str_eq(buf, "PRFX0SFFX");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      &a);
  r = bn_format(&a, NULL, NULL, 18, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "0.0");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000001"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "1");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000001"),
      &a);
  r = bn_format(&a, NULL, NULL, 6, 6, true, buf, sizeof(buf));
  ck_assert_int_eq(r, 8);
  ck_assert_str_eq(buf, "1.000000");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000002"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "2");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000005"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "5");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000009"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 1);
  ck_assert_str_eq(buf, "9");

  bn_read_be(
      fromhex(
          "000000000000000000000000000000000000000000000000000000000000000a"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 2);
  ck_assert_str_eq(buf, "10");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000014"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 2);
  ck_assert_str_eq(buf, "20");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000032"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 2);
  ck_assert_str_eq(buf, "50");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000063"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 2);
  ck_assert_str_eq(buf, "99");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000064"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "100");

  bn_read_be(
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000c8"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "200");

  bn_read_be(
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000001f4"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "500");

  bn_read_be(
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000003e7"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "999");

  bn_read_be(
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000003e8"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 4);
  ck_assert_str_eq(buf, "1000");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000989680"),
      &a);
  r = bn_format(&a, NULL, NULL, 7, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 3);
  ck_assert_str_eq(buf, "1.0");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 78);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "7584007913129639935");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 1, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 79);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "758400791312963993.5");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 2, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 79);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "75840079131296399.35");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 8, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 79);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "75840079131.29639935");

  bn_read_be(
      fromhex(
          "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe3bbb00"),
      &a);
  r = bn_format(&a, NULL, NULL, 8, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 72);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "75840079131.0");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 18, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 79);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "7.584007913129639935");

  bn_read_be(
      fromhex(
          "fffffffffffffffffffffffffffffffffffffffffffffffff7e52fe5afe40000"),
      &a);
  r = bn_format(&a, NULL, NULL, 18, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 62);
  ck_assert_str_eq(
      buf, "115792089237316195423570985008687907853269984665640564039457.0");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 78, 0, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 80);
  ck_assert_str_eq(buf,
                   "0."
                   "11579208923731619542357098500868790785326998466564056403945"
                   "7584007913129639935");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, NULL, NULL, 0, 10, false, buf, sizeof(buf));
  ck_assert_int_eq(r, 88);
  ck_assert_str_eq(buf,
                   "11579208923731619542357098500868790785326998466564056403945"
                   "75840079131296399350000000000");

  bn_read_be(
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      &a);
  r = bn_format(&a, "quite a long prefix", "even longer suffix", 60, 0, false,
                buf, sizeof(buf));
  ck_assert_int_eq(r, 116);
  ck_assert_str_eq(buf,
                   "quite a long "
                   "prefix115792089237316195."
                   "42357098500868790785326998466564056403945758400791312963993"
                   "5even longer suffix");

  bn_read_be(
      fromhex(
          "0000000000000000000000000000000000000000000000000123456789abcdef"),
      &a);
  memset(buf, 'a', sizeof(buf));
  r = bn_format(&a, "prefix", "suffix", 10, 0, false, buf, 31);
  ck_assert_str_eq(buf, "prefix8198552.9216486895suffix");
  ck_assert_int_eq(r, 30);

  memset(buf, 'a', sizeof(buf));
  r = bn_format(&a, "prefix", "suffix", 10, 0, false, buf, 30);
  ck_assert_int_eq(r, 0);
  ck_assert_str_eq(buf, "prefix198552.9216486895suffix");
}
END_TEST

// https://tools.ietf.org/html/rfc4648#section-10
START_TEST(test_base32_rfc4648) {
  static const struct {
    const char *decoded;
    const char *encoded;
    const char *encoded_lowercase;
  } tests[] = {
      {"", "", ""},
      {"f", "MY", "my"},
      {"fo", "MZXQ", "mzxq"},
      {"foo", "MZXW6", "mzxw6"},
      {"foob", "MZXW6YQ", "mzxw6yq"},
      {"fooba", "MZXW6YTB", "mzxw6ytb"},
      {"foobar", "MZXW6YTBOI", "mzxw6ytboi"},
  };

  char buffer[64];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    const char *in = tests[i].decoded;
    const char *out = tests[i].encoded;
    const char *out_lowercase = tests[i].encoded_lowercase;

    size_t inlen = strlen(in);
    size_t outlen = strlen(out);

    ck_assert_int_eq(outlen, base32_encoded_length(inlen));
    ck_assert_int_eq(inlen, base32_decoded_length(outlen));

    ck_assert(base32_encode((uint8_t *)in, inlen, buffer, sizeof(buffer),
                            BASE32_ALPHABET_RFC4648) != NULL);
    ck_assert_str_eq(buffer, out);

    char *ret = (char *)base32_decode(out, outlen, (uint8_t *)buffer,
                                      sizeof(buffer), BASE32_ALPHABET_RFC4648);
    ck_assert(ret != NULL);
    *ret = '\0';
    ck_assert_str_eq(buffer, in);

    ret = (char *)base32_decode(out_lowercase, outlen, (uint8_t *)buffer,
                                sizeof(buffer), BASE32_ALPHABET_RFC4648);
    ck_assert(ret != NULL);
    *ret = '\0';
    ck_assert_str_eq(buffer, in);
  }
}
END_TEST

// from
// https://github.com/bitcoin/bitcoin/blob/master/src/test/data/base58_keys_valid.json
START_TEST(test_base58) {
  static const char *base58_vector[] = {
      "0065a16059864a2fdbc7c99a4723a8395bc6f188eb",
      "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i",
      "0574f209f6ea907e2ea48f74fae05782ae8a665257",
      "3CMNFxN1oHBc4R1EpboAL5yzHGgE611Xou",
      "6f53c0307d6851aa0ce7825ba883c6bd9ad242b486",
      "mo9ncXisMeAoXwqcV5EWuyncbmCcQN4rVs",
      "c46349a418fc4578d10a372b54b45c280cc8c4382f",
      "2N2JD6wb56AfK4tfmM6PwdVmoYk2dCKf4Br",
      "80eddbdc1168f1daeadbd3e44c1e3f8f5a284c2029f78ad26af98583a499de5b19",
      "5Kd3NBUAdUnhyzenEwVLy9pBKxSwXvE9FMPyR4UKZvpe6E3AgLr",
      "8055c9bccb9ed68446d1b75273bbce89d7fe013a8acd1625514420fb2aca1a21c401",
      "Kz6UJmQACJmLtaQj5A3JAge4kVTNQ8gbvXuwbmCj7bsaabudb3RD",
      "ef36cb93b9ab1bdabf7fb9f2c04f1b9cc879933530ae7842398eef5a63a56800c2",
      "9213qJab2HNEpMpYNBa7wHGFKKbkDn24jpANDs2huN3yi4J11ko",
      "efb9f4892c9e8282028fea1d2667c4dc5213564d41fc5783896a0d843fc15089f301",
      "cTpB4YiyKiBcPxnefsDpbnDxFDffjqJob8wGCEDXxgQ7zQoMXJdH",
      "006d23156cbbdcc82a5a47eee4c2c7c583c18b6bf4",
      "1Ax4gZtb7gAit2TivwejZHYtNNLT18PUXJ",
      "05fcc5460dd6e2487c7d75b1963625da0e8f4c5975",
      "3QjYXhTkvuj8qPaXHTTWb5wjXhdsLAAWVy",
      "6ff1d470f9b02370fdec2e6b708b08ac431bf7a5f7",
      "n3ZddxzLvAY9o7184TB4c6FJasAybsw4HZ",
      "c4c579342c2c4c9220205e2cdc285617040c924a0a",
      "2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
      "80a326b95ebae30164217d7a7f57d72ab2b54e3be64928a19da0210b9568d4015e",
      "5K494XZwps2bGyeL71pWid4noiSNA2cfCibrvRWqcHSptoFn7rc",
      "807d998b45c219a1e38e99e7cbd312ef67f77a455a9b50c730c27f02c6f730dfb401",
      "L1RrrnXkcKut5DEMwtDthjwRcTTwED36thyL1DebVrKuwvohjMNi",
      "efd6bca256b5abc5602ec2e1c121a08b0da2556587430bcf7e1898af2224885203",
      "93DVKyFYwSN6wEo3E2fCrFPUp17FtrtNi2Lf7n4G3garFb16CRj",
      "efa81ca4e8f90181ec4b61b6a7eb998af17b2cb04de8a03b504b9e34c4c61db7d901",
      "cTDVKtMGVYWTHCb1AFjmVbEbWjvKpKqKgMaR3QJxToMSQAhmCeTN",
      "007987ccaa53d02c8873487ef919677cd3db7a6912",
      "1C5bSj1iEGUgSTbziymG7Cn18ENQuT36vv",
      "0563bcc565f9e68ee0189dd5cc67f1b0e5f02f45cb",
      "3AnNxabYGoTxYiTEZwFEnerUoeFXK2Zoks",
      "6fef66444b5b17f14e8fae6e7e19b045a78c54fd79",
      "n3LnJXCqbPjghuVs8ph9CYsAe4Sh4j97wk",
      "c4c3e55fceceaa4391ed2a9677f4a4d34eacd021a0",
      "2NB72XtkjpnATMggui83aEtPawyyKvnbX2o",
      "80e75d936d56377f432f404aabb406601f892fd49da90eb6ac558a733c93b47252",
      "5KaBW9vNtWNhc3ZEDyNCiXLPdVPHCikRxSBWwV9NrpLLa4LsXi9",
      "808248bd0375f2f75d7e274ae544fb920f51784480866b102384190b1addfbaa5c01",
      "L1axzbSyynNYA8mCAhzxkipKkfHtAXYF4YQnhSKcLV8YXA874fgT",
      "ef44c4f6a096eac5238291a94cc24c01e3b19b8d8cef72874a079e00a242237a52",
      "927CnUkUbasYtDwYwVn2j8GdTuACNnKkjZ1rpZd2yBB1CLcnXpo",
      "efd1de707020a9059d6d3abaf85e17967c6555151143db13dbb06db78df0f15c6901",
      "cUcfCMRjiQf85YMzzQEk9d1s5A4K7xL5SmBCLrezqXFuTVefyhY7",
      "00adc1cc2081a27206fae25792f28bbc55b831549d",
      "1Gqk4Tv79P91Cc1STQtU3s1W6277M2CVWu",
      "05188f91a931947eddd7432d6e614387e32b244709",
      "33vt8ViH5jsr115AGkW6cEmEz9MpvJSwDk",
      "6f1694f5bc1a7295b600f40018a618a6ea48eeb498",
      "mhaMcBxNh5cqXm4aTQ6EcVbKtfL6LGyK2H",
      "c43b9b3fd7a50d4f08d1a5b0f62f644fa7115ae2f3",
      "2MxgPqX1iThW3oZVk9KoFcE5M4JpiETssVN",
      "80091035445ef105fa1bb125eccfb1882f3fe69592265956ade751fd095033d8d0",
      "5HtH6GdcwCJA4ggWEL1B3jzBBUB8HPiBi9SBc5h9i4Wk4PSeApR",
      "80ab2b4bcdfc91d34dee0ae2a8c6b6668dadaeb3a88b9859743156f462325187af01",
      "L2xSYmMeVo3Zek3ZTsv9xUrXVAmrWxJ8Ua4cw8pkfbQhcEFhkXT8",
      "efb4204389cef18bbe2b353623cbf93e8678fbc92a475b664ae98ed594e6cf0856",
      "92xFEve1Z9N8Z641KQQS7ByCSb8kGjsDzw6fAmjHN1LZGKQXyMq",
      "efe7b230133f1b5489843260236b06edca25f66adb1be455fbd38d4010d48faeef01",
      "cVM65tdYu1YK37tNoAyGoJTR13VBYFva1vg9FLuPAsJijGvG6NEA",
      "00c4c1b72491ede1eedaca00618407ee0b772cad0d",
      "1JwMWBVLtiqtscbaRHai4pqHokhFCbtoB4",
      "05f6fe69bcb548a829cce4c57bf6fff8af3a5981f9",
      "3QCzvfL4ZRvmJFiWWBVwxfdaNBT8EtxB5y",
      "6f261f83568a098a8638844bd7aeca039d5f2352c0",
      "mizXiucXRCsEriQCHUkCqef9ph9qtPbZZ6",
      "c4e930e1834a4d234702773951d627cce82fbb5d2e",
      "2NEWDzHWwY5ZZp8CQWbB7ouNMLqCia6YRda",
      "80d1fab7ab7385ad26872237f1eb9789aa25cc986bacc695e07ac571d6cdac8bc0",
      "5KQmDryMNDcisTzRp3zEq9e4awRmJrEVU1j5vFRTKpRNYPqYrMg",
      "80b0bbede33ef254e8376aceb1510253fc3550efd0fcf84dcd0c9998b288f166b301",
      "L39Fy7AC2Hhj95gh3Yb2AU5YHh1mQSAHgpNixvm27poizcJyLtUi",
      "ef037f4192c630f399d9271e26c575269b1d15be553ea1a7217f0cb8513cef41cb",
      "91cTVUcgydqyZLgaANpf1fvL55FH53QMm4BsnCADVNYuWuqdVys",
      "ef6251e205e8ad508bab5596bee086ef16cd4b239e0cc0c5d7c4e6035441e7d5de01",
      "cQspfSzsgLeiJGB2u8vrAiWpCU4MxUT6JseWo2SjXy4Qbzn2fwDw",
      "005eadaf9bb7121f0f192561a5a62f5e5f54210292",
      "19dcawoKcZdQz365WpXWMhX6QCUpR9SY4r",
      "053f210e7277c899c3a155cc1c90f4106cbddeec6e",
      "37Sp6Rv3y4kVd1nQ1JV5pfqXccHNyZm1x3",
      "6fc8a3c2a09a298592c3e180f02487cd91ba3400b5",
      "myoqcgYiehufrsnnkqdqbp69dddVDMopJu",
      "c499b31df7c9068d1481b596578ddbb4d3bd90baeb",
      "2N7FuwuUuoTBrDFdrAZ9KxBmtqMLxce9i1C",
      "80c7666842503db6dc6ea061f092cfb9c388448629a6fe868d068c42a488b478ae",
      "5KL6zEaMtPRXZKo1bbMq7JDjjo1bJuQcsgL33je3oY8uSJCR5b4",
      "8007f0803fc5399e773555ab1e8939907e9badacc17ca129e67a2f5f2ff84351dd01",
      "KwV9KAfwbwt51veZWNscRTeZs9CKpojyu1MsPnaKTF5kz69H1UN2",
      "efea577acfb5d1d14d3b7b195c321566f12f87d2b77ea3a53f68df7ebf8604a801",
      "93N87D6uxSBzwXvpokpzg8FFmfQPmvX4xHoWQe3pLdYpbiwT5YV",
      "ef0b3b34f0958d8a268193a9814da92c3e8b58b4a4378a542863e34ac289cd830c01",
      "cMxXusSihaX58wpJ3tNuuUcZEQGt6DKJ1wEpxys88FFaQCYjku9h",
      "001ed467017f043e91ed4c44b4e8dd674db211c4e6",
      "13p1ijLwsnrcuyqcTvJXkq2ASdXqcnEBLE",
      "055ece0cadddc415b1980f001785947120acdb36fc",
      "3ALJH9Y951VCGcVZYAdpA3KchoP9McEj1G",
      0,
      0,
  };
  const char **raw = base58_vector;
  const char **str = base58_vector + 1;
  uint8_t rawn[34];
  char strn[53];
  int r;
  while (*raw && *str) {
    int len = strlen(*raw) / 2;

    memcpy(rawn, fromhex(*raw), len);
    r = base58_encode_check(rawn, len, HASHER_SHA2D, strn, sizeof(strn));
    ck_assert_int_eq((size_t)r, strlen(*str) + 1);
    ck_assert_str_eq(strn, *str);

    r = base58_decode_check(strn, HASHER_SHA2D, rawn, len);
    ck_assert_int_eq(r, len);
    ck_assert_mem_eq(rawn, fromhex(*raw), len);

    raw += 2;
    str += 2;
  }
}
END_TEST

#if USE_GRAPHENE

// Graphene Base85CheckEncoding
START_TEST(test_base58gph) {
  static const char *base58_vector[] = {
      "02e649f63f8e8121345fd7f47d0d185a3ccaa843115cd2e9392dcd9b82263bc680",
      "6dumtt9swxCqwdPZBGXh9YmHoEjFFnNfwHaTqRbQTghGAY2gRz",
      "021c7359cd885c0e319924d97e3980206ad64387aff54908241125b3a88b55ca16",
      "5725vivYpuFWbeyTifZ5KevnHyqXCi5hwHbNU9cYz1FHbFXCxX",
      "02f561e0b57a552df3fa1df2d87a906b7a9fc33a83d5d15fa68a644ecb0806b49a",
      "6kZKHSuxqAwdCYsMvwTcipoTsNE2jmEUNBQufGYywpniBKXWZK",
      "03e7595c3e6b58f907bee951dc29796f3757307e700ecf3d09307a0cc4a564eba3",
      "8b82mpnH8YX1E9RHnU2a2YgLTZ8ooevEGP9N15c1yFqhoBvJur",
      0,
      0,
  };
  const char **raw = base58_vector;
  const char **str = base58_vector + 1;
  uint8_t rawn[34];
  char strn[53];
  int r;
  while (*raw && *str) {
    int len = strlen(*raw) / 2;

    memcpy(rawn, fromhex(*raw), len);
    r = base58gph_encode_check(rawn, len, strn, sizeof(strn));
    ck_assert_int_eq((size_t)r, strlen(*str) + 1);
    ck_assert_str_eq(strn, *str);

    r = base58gph_decode_check(strn, rawn, len);
    ck_assert_int_eq(r, len);
    ck_assert_mem_eq(rawn, fromhex(*raw), len);

    raw += 2;
    str += 2;
  }
}
END_TEST

#endif

START_TEST(test_bignum_divmod) {
  uint32_t r;
  int i;

  bignum256 a = {{0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff,
                  0x3fffffff, 0x3fffffff, 0x3fffffff, 0xffff}};
  uint32_t ar[] = {15, 14, 55, 29, 44, 24, 53, 49, 18, 55, 2,  28, 5,  4,  12,
                   43, 18, 37, 28, 14, 30, 46, 12, 11, 17, 10, 10, 13, 24, 45,
                   4,  33, 44, 42, 2,  46, 34, 43, 45, 28, 21, 18, 13, 17};

  i = 0;
  while (!bn_is_zero(&a) && i < 44) {
    bn_divmod58(&a, &r);
    ck_assert_int_eq(r, ar[i]);
    i++;
  }
  ck_assert_int_eq(i, 44);

  bignum256 b = {{0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff,
                  0x3fffffff, 0x3fffffff, 0x3fffffff, 0xffff}};
  uint32_t br[] = {935, 639, 129, 913, 7,   584, 457, 39, 564,
                   640, 665, 984, 269, 853, 907, 687, 8,  985,
                   570, 423, 195, 316, 237, 89,  792, 115};

  i = 0;
  while (!bn_is_zero(&b) && i < 26) {
    bn_divmod1000(&b, &r);
    ck_assert_int_eq(r, br[i]);
    i++;
  }
  ck_assert_int_eq(i, 26);
}
END_TEST

// test vector 1 from
// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vector-1
START_TEST(test_bip32_vector_1) {
  HDNode node, node2, node3;
  uint32_t fingerprint;
  char str[112];
  int r;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   SECP256K1_NAME, &node);

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqji"
                   "ChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2"
                   "gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 0);
  ck_assert_int_eq(fingerprint, 0x3442193e);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "035a784662a4a20a65bf6aab9ae98a6c068a81c52e4b032c0fb5400c706cfccc56"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4"
                   "cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP"
                   "6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(fingerprint, 0x5c1bd648);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03501e454bf00751f24b1b489aa925215d66af2234e3891c3b21a52bedb3cd711c"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSx"
                   "qu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFH"
                   "KkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 2);
  ck_assert_int_eq(fingerprint, 0xbef5a2f9);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0357bfe1e341d01c69fe5654309956cbea516822fba8a601743a012a7896ee8dc2"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptW"
                   "mT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgq"
                   "FJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2'/2]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(fingerprint, 0xee7ab90c);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02e8445082a72f29b75ca48748a914df60622a609cacfce8ed0e35804560741d29"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Ty"
                   "h8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJ"
                   "AyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2'/2/1000000000]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1000000000);
  ck_assert_int_eq(fingerprint, 0xd880d7d8);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "022a471424da5e657499d1ff51cb43c47481a03b1e77f951fe64cec9f5a48f7011"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8"
                   "kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNT"
                   "EcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
}
END_TEST

// test vector 2 from
// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vector-2
START_TEST(test_bip32_vector_2) {
  HDNode node, node2, node3;
  uint32_t fingerprint;
  char str[112];
  int r;

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, SECP256K1_NAME, &node);

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "60499f801b896d83179a4374aeb7822aaeaceaa0db1f85ee3e904c4defbd9689"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "4b03d6fc340455b363f51020ad3ecca4f0850280cf436c70c727923f6db46c3e"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03cbcaa9c98c877a26977d00825c956a238e8dddfbd322cce4f74b0b5bd6ace4a7"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGds"
                   "o3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSC"
                   "Gu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0xbd16bee5);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f15ac7e1e"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22a98d12ea"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT"
                   "3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGm"
                   "XUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483647);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x5a61ff8e);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18fd52e6e93"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03c01e7425647bdefa82b12d9bad5e3e6865bee0502694b94ca58b666abc0a5c3b"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYE"
                   "eEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ"
                   "85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0xd8ab4937);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "704addf544a06e5ee4bea37098463c23613da32020d604506da8c0518e1da4b7"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03a7d1d856deb74c508e05031f9895dab54626251b3806e16b4bd12e781a7df5b9"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd"
                   "25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5Ew"
                   "VvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1/2147483646']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483646);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x78412e3a);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b247d6a2d"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02d2b36900396c9282fa14628566582f206a5dd0bcc8d5e892611806cafb0301f0"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz"
                   "7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJ"
                   "bZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1/2147483646'/2]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x31a507b8);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a4842125ac23"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "024d902e1a2fc7a8755ab5b694c575fce742c48d9ff192e63df5193e4c7afe1f9c"),
      33);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw"
                   "7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLF"
                   "bdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, SECP256K1_NAME, &node);

  // test public derivation
  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_public_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0xbd16bee5);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22a98d12ea"),
      33);
}
END_TEST

// test vector 3 from
// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vector-3
START_TEST(test_bip32_vector_3) {
  HDNode node, node2, node3;
  uint32_t fingerprint;
  char str[112];
  int r;

  // init m
  hdnode_from_seed(
      fromhex(
          "4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45"
          "d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be"),
      64, SECP256K1_NAME, &node);

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  hdnode_fill_public_key(&node);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7"
                   "KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhR"
                   "oP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 0);
  ck_assert_int_eq(r, 1);
  hdnode_fill_public_key(&node);
  hdnode_serialize_private(&node, fingerprint, VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu"
                   "2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, VERSION_PUBLIC, str, sizeof(str));
  ck_assert_str_eq(str,
                   "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrAD"
                   "WgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
  r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME,
                         &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
}
END_TEST

START_TEST(test_bip32_compare) {
  HDNode node1, node2, node3;
  int i, r;
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node1);
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node2);
  hdnode_fill_public_key(&node2);
  for (i = 0; i < 100; i++) {
    memcpy(&node3, &node1, sizeof(HDNode));
    hdnode_fill_public_key(&node3);
    r = hdnode_private_ckd(&node1, i);
    ck_assert_int_eq(r, 1);
    r = hdnode_public_ckd(&node2, i);
    ck_assert_int_eq(r, 1);
    r = hdnode_public_ckd(&node3, i);
    ck_assert_int_eq(r, 1);
    ck_assert_int_eq(node1.depth, node2.depth);
    ck_assert_int_eq(node1.depth, node3.depth);
    ck_assert_int_eq(node1.child_num, node2.child_num);
    ck_assert_int_eq(node1.child_num, node3.child_num);
    ck_assert_mem_eq(node1.chain_code, node2.chain_code, 32);
    ck_assert_mem_eq(node1.chain_code, node3.chain_code, 32);
    ck_assert_mem_eq(
        node2.private_key,
        fromhex(
            "0000000000000000000000000000000000000000000000000000000000000000"),
        32);
    ck_assert_mem_eq(
        node3.private_key,
        fromhex(
            "0000000000000000000000000000000000000000000000000000000000000000"),
        32);
    hdnode_fill_public_key(&node1);
    ck_assert_mem_eq(node1.public_key, node2.public_key, 33);
    ck_assert_mem_eq(node1.public_key, node3.public_key, 33);
  }
}
END_TEST

START_TEST(test_bip32_optimized) {
  HDNode root;
  hdnode_from_seed((uint8_t *)"NothingToSeeHere", 16, SECP256K1_NAME, &root);
  hdnode_fill_public_key(&root);

  curve_point pub;
  ecdsa_read_pubkey(&secp256k1, root.public_key, &pub);

  HDNode node;
  char addr1[MAX_ADDR_SIZE], addr2[MAX_ADDR_SIZE];

  for (int i = 0; i < 40; i++) {
    // unoptimized
    memcpy(&node, &root, sizeof(HDNode));
    hdnode_public_ckd(&node, i);
    hdnode_fill_public_key(&node);
    ecdsa_get_address(node.public_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                      addr1, sizeof(addr1));
    // optimized
    hdnode_public_ckd_address_optimized(&pub, root.chain_code, i, 0,
                                        HASHER_SHA2_RIPEMD, HASHER_SHA2D, addr2,
                                        sizeof(addr2), 0);
    // check
    ck_assert_str_eq(addr1, addr2);
  }
}
END_TEST

START_TEST(test_bip32_cache_1) {
  HDNode node1, node2;
  int i, r;

  // test 1 .. 8
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node1);
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node2);

  uint32_t ii[] = {0x80000001, 0x80000002, 0x80000003, 0x80000004,
                   0x80000005, 0x80000006, 0x80000007, 0x80000008};

  for (i = 0; i < 8; i++) {
    r = hdnode_private_ckd(&node1, ii[i]);
    ck_assert_int_eq(r, 1);
  }
  r = hdnode_private_ckd_cached(&node2, ii, 8, NULL);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));

  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node1);
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node2);

  // test 1 .. 7, 20
  ii[7] = 20;
  for (i = 0; i < 8; i++) {
    r = hdnode_private_ckd(&node1, ii[i]);
    ck_assert_int_eq(r, 1);
  }
  r = hdnode_private_ckd_cached(&node2, ii, 8, NULL);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));

  // test different root node
  hdnode_from_seed(
      fromhex(
          "000000002ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node1);
  hdnode_from_seed(
      fromhex(
          "000000002ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, SECP256K1_NAME, &node2);

  for (i = 0; i < 8; i++) {
    r = hdnode_private_ckd(&node1, ii[i]);
    ck_assert_int_eq(r, 1);
  }
  r = hdnode_private_ckd_cached(&node2, ii, 8, NULL);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));
}
END_TEST

START_TEST(test_bip32_cache_2) {
  HDNode nodea[9], nodeb[9];
  int i, j, r;

  for (j = 0; j < 9; j++) {
    hdnode_from_seed(
        fromhex(
            "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d627"
            "88f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
        64, SECP256K1_NAME, &(nodea[j]));
    hdnode_from_seed(
        fromhex(
            "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d627"
            "88f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
        64, SECP256K1_NAME, &(nodeb[j]));
  }

  uint32_t ii[] = {0x80000001, 0x80000002, 0x80000003, 0x80000004,
                   0x80000005, 0x80000006, 0x80000007, 0x80000008};
  for (j = 0; j < 9; j++) {
    // non cached
    for (i = 1; i <= j; i++) {
      r = hdnode_private_ckd(&(nodea[j]), ii[i - 1]);
      ck_assert_int_eq(r, 1);
    }
    // cached
    r = hdnode_private_ckd_cached(&(nodeb[j]), ii, j, NULL);
    ck_assert_int_eq(r, 1);
  }

  ck_assert_mem_eq(&(nodea[0]), &(nodeb[0]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[1]), &(nodeb[1]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[2]), &(nodeb[2]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[3]), &(nodeb[3]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[4]), &(nodeb[4]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[5]), &(nodeb[5]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[6]), &(nodeb[6]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[7]), &(nodeb[7]), sizeof(HDNode));
  ck_assert_mem_eq(&(nodea[8]), &(nodeb[8]), sizeof(HDNode));
}
END_TEST

START_TEST(test_bip32_nist_seed) {
  HDNode node;

  // init m
  hdnode_from_seed(
      fromhex(
          "a7305bc8df8d0951f0cb224c0e95d7707cbdf2c6ce7e8d481fec69c7ff5e9446"),
      32, NIST256P1_NAME, &node);

  // [Chain m]
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "3b8c18469a4634517d6d0b65448f8e6c62091b45540a1743c5846be55d47d88f"),
      32);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "7762f9729fed06121fd13f326884c82f59aa95c57ac492ce8c9654e60efd130c"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0383619fadcde31063d8c5cb00dbfe1713f3e6fa169d8541a798752a1c1ca0cb20"),
      33);

  // init m
  hdnode_from_seed(
      fromhex(
          "aa305bc8df8d0951f0cb29ad4568d7707cbdf2c6ce7e8d481fec69c7ff5e9446"),
      32, NIST256P1_NAME, &node);

  // [Chain m]
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "a81d21f36f987fa0be3b065301bfb6aa9deefbf3dfef6744c37b9a4abc3c68f1"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "0e49dc46ce1d8c29d9b80a05e40f5d0cd68cbf02ae98572186f5343be18084bf"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03aaa4c89acd9a98935330773d3dae55122f3591bac4a40942681768de8df6ba63"),
      33);
}
END_TEST

START_TEST(test_bip32_nist_vector_1) {
  HDNode node;
  uint32_t fingerprint;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   NIST256P1_NAME, &node);

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "beeb672fe4621673f722f38529c07392fecaa61015c80c34f29ce8b41b3cb6ea"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "612091aaa12e22dd2abef664f8a01a82cae99ad7441b7ef8110424915c268bc2"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0266874dc6ade47b3ecd096745ca09bcd29638dd52c2c12117b11ed3e458cfa9e8"),
      33);

  // [Chain m/0']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 0);
  ck_assert_int_eq(fingerprint, 0xbe6105b5);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "3460cea53e6a6bb5fb391eeef3237ffd8724bf0a40e94943c98b83825342ee11"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "6939694369114c67917a182c59ddb8cafc3004e63ca5d3b84403ba8613debc0c"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0384610f5ecffe8fda089363a41f56a5c7ffc1d81b59a612d0d649b2d22355590c"),
      33);

  // [Chain m/0'/1]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(fingerprint, 0x9b02312f);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "4187afff1aafa8445010097fb99d23aee9f599450c7bd140b6826ac22ba21d0c"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "284e9d38d07d21e4e281b645089a94f4cf5a5a81369acf151a1c3a57f18b2129"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03526c63f8d0b4bbbf9c80df553fe66742df4676b241dabefdef67733e070f6844"),
      33);

  // [Chain m/0'/1/2']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 2);
  ck_assert_int_eq(fingerprint, 0xb98005c1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "98c7514f562e64e74170cc3cf304ee1ce54d6b6da4f880f313e8204c2a185318"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "694596e8a54f252c960eb771a3c41e7e32496d03b954aeb90f61635b8e092aa7"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0359cf160040778a4b14c5f4d7b76e327ccc8c4a6086dd9451b7482b5a4972dda0"),
      33);

  // [Chain m/0'/1/2'/2]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(fingerprint, 0x0e9f3274);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "ba96f776a5c3907d7fd48bde5620ee374d4acfd540378476019eab70790c63a0"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "5996c37fd3dd2679039b23ed6f70b506c6b56b3cb5e424681fb0fa64caf82aaa"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "029f871f4cb9e1c97f9f4de9ccd0d4a2f2a171110c61178f84430062230833ff20"),
      33);

  // [Chain m/0'/1/2'/2/1000000000]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1000000000);
  ck_assert_int_eq(fingerprint, 0x8b2b5c4b);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "b9b7b82d326bb9cb5b5b121066feea4eb93d5241103c9e7a18aad40f1dde8059"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "21c4f269ef0a5fd1badf47eeacebeeaa3de22eb8e5b0adcd0f27dd99d34d0119"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02216cd26d31147f72427a453c443ed2cde8a1e53c9cc44e5ddf739725413fe3f4"),
      33);
}
END_TEST

START_TEST(test_bip32_nist_vector_2) {
  HDNode node;
  uint32_t fingerprint;
  int r;

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, NIST256P1_NAME, &node);

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "96cd4465a9644e31528eda3592aa35eb39a9527769ce1855beafc1b81055e75d"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "eaa31c2e46ca2962227cf21d73a7ef0ce8b31c756897521eb6c7b39796633357"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02c9e16154474b3ed5b38218bb0463e008f89ee03e62d22fdcc8014beab25b48fa"),
      33);

  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x607f628f);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "84e9c258bb8557a40e0d041115b376dd55eda99c0042ce29e81ebe4efed9b86a"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "d7d065f63a62624888500cdb4f88b6d59c2927fee9e6d0cdff9cad555884df6e"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "039b6df4bece7b6c81e2adfeea4bcf5c8c8a6e40ea7ffa3cf6e8494c61a1fc82cc"),
      33);

  // [Chain m/0/2147483647']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483647);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x946d2a54);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f235b2bc5c04606ca9c30027a84f353acf4e4683edbd11f635d0dcc1cd106ea6"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "96d2ec9316746a75e7793684ed01e3d51194d81a42a3276858a5b7376d4b94b9"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02f89c5deb1cae4fedc9905f98ae6cbf6cbab120d8cb85d5bd9a91a72f4c068c76"),
      33);

  // [Chain m/0/2147483647'/1]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x218182d8);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "7c0b833106235e452eba79d2bdd58d4086e663bc8cc55e9773d2b5eeda313f3b"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "974f9096ea6873a915910e82b29d7c338542ccde39d2064d1cc228f371542bbc"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03abe0ad54c97c1d654c1852dfdc32d6d3e487e75fa16f0fd6304b9ceae4220c64"),
      33);

  // [Chain m/0/2147483647'/1/2147483646']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483646);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x931223e4);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "5794e616eadaf33413aa309318a26ee0fd5163b70466de7a4512fd4b1a5c9e6a"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "da29649bbfaff095cd43819eda9a7be74236539a29094cd8336b07ed8d4eff63"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03cb8cb067d248691808cd6b5a5a06b48e34ebac4d965cba33e6dc46fe13d9b933"),
      33);

  // [Chain m/0/2147483647'/1/2147483646'/2]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x956c4629);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "3bfb29ee8ac4484f09db09c2079b520ea5616df7820f071a20320366fbe226a7"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "bb0a77ba01cc31d77205d51d08bd313b979a71ef4de9b062f8958297e746bd67"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "020ee02e18967237cf62672983b253ee62fa4dd431f8243bfeccdf39dbe181387f"),
      33);

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, NIST256P1_NAME, &node);

  // test public derivation
  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_public_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x607f628f);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "84e9c258bb8557a40e0d041115b376dd55eda99c0042ce29e81ebe4efed9b86a"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      32);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "039b6df4bece7b6c81e2adfeea4bcf5c8c8a6e40ea7ffa3cf6e8494c61a1fc82cc"),
      33);
}
END_TEST

START_TEST(test_bip32_nist_compare) {
  HDNode node1, node2, node3;
  int i, r;
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, NIST256P1_NAME, &node1);
  hdnode_from_seed(
      fromhex(
          "301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788"
          "f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"),
      64, NIST256P1_NAME, &node2);
  hdnode_fill_public_key(&node2);
  for (i = 0; i < 100; i++) {
    memcpy(&node3, &node1, sizeof(HDNode));
    hdnode_fill_public_key(&node3);
    r = hdnode_private_ckd(&node1, i);
    ck_assert_int_eq(r, 1);
    r = hdnode_public_ckd(&node2, i);
    ck_assert_int_eq(r, 1);
    r = hdnode_public_ckd(&node3, i);
    ck_assert_int_eq(r, 1);
    ck_assert_int_eq(node1.depth, node2.depth);
    ck_assert_int_eq(node1.depth, node3.depth);
    ck_assert_int_eq(node1.child_num, node2.child_num);
    ck_assert_int_eq(node1.child_num, node3.child_num);
    ck_assert_mem_eq(node1.chain_code, node2.chain_code, 32);
    ck_assert_mem_eq(node1.chain_code, node3.chain_code, 32);
    ck_assert_mem_eq(
        node2.private_key,
        fromhex(
            "0000000000000000000000000000000000000000000000000000000000000000"),
        32);
    ck_assert_mem_eq(
        node3.private_key,
        fromhex(
            "0000000000000000000000000000000000000000000000000000000000000000"),
        32);
    hdnode_fill_public_key(&node1);
    ck_assert_mem_eq(node1.public_key, node2.public_key, 33);
    ck_assert_mem_eq(node1.public_key, node3.public_key, 33);
  }
}
END_TEST

START_TEST(test_bip32_nist_repeat) {
  HDNode node, node2;
  uint32_t fingerprint;
  int r;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   NIST256P1_NAME, &node);

  // [Chain m/28578']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 28578);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0xbe6105b5);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "e94c8ebe30c2250a14713212f6449b20f3329105ea15b652ca5bdfc68f6c65c2"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "06f0db126f023755d0b8d86d4591718a5210dd8d024e3e14b6159d63f53aa669"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02519b5554a4872e8c9c1c847115363051ec43e93400e030ba3c36b52a3e70a5b7"),
      33);

  memcpy(&node2, &node, sizeof(HDNode));
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node2, 33941);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x3e2b7bc6);
  ck_assert_mem_eq(
      node2.chain_code,
      fromhex(
          "9e87fe95031f14736774cd82f25fd885065cb7c358c1edf813c72af535e83071"),
      32);
  ck_assert_mem_eq(
      node2.private_key,
      fromhex(
          "092154eed4af83e078ff9b84322015aefe5769e31270f62c3f66c33888335f3a"),
      32);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(
      node2.public_key,
      fromhex(
          "0235bfee614c0d5b2cae260000bb1d0d84b270099ad790022c1ae0b2e782efe120"),
      33);

  memcpy(&node2, &node, sizeof(HDNode));
  memzero(&node2.private_key, 32);
  r = hdnode_public_ckd(&node2, 33941);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x3e2b7bc6);
  ck_assert_mem_eq(
      node2.chain_code,
      fromhex(
          "9e87fe95031f14736774cd82f25fd885065cb7c358c1edf813c72af535e83071"),
      32);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(
      node2.public_key,
      fromhex(
          "0235bfee614c0d5b2cae260000bb1d0d84b270099ad790022c1ae0b2e782efe120"),
      33);
}
END_TEST

// test vector 1 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_ed25519_vector_1) {
  HDNode node;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   ED25519_NAME, &node);

  // [Chain m]
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "90046a93de5380a72b5e45010748567d5ea02bbf6522f979e05c0d8d8ca9fffb"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "2b4be7f19ee27bbf30c667b642d5f4aa69fd169872f8fc3059c08ebae2eb19e7"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "01a4b2856bfec510abab89753fac1ac0e1112364e7d250545963f135f2a33188ed"),
      33);

  // [Chain m/0']
  hdnode_private_ckd_prime(&node, 0);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "8b59aa11380b624e81507a27fedda59fea6d0b779a778918a2fd3590e16e9c69"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "68e0fe46dfb67e368c75379acec591dad19df3cde26e63b93a8e704f1dade7a3"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "018c8a13df77a28f3445213a0f432fde644acaa215fc72dcdf300d5efaa85d350c"),
      33);

  // [Chain m/0'/1']
  hdnode_private_ckd_prime(&node, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "a320425f77d1b5c2505a6b1b27382b37368ee640e3557c315416801243552f14"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "b1d0bad404bf35da785a64ca1ac54b2617211d2777696fbffaf208f746ae84f2"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "011932a5270f335bed617d5b935c80aedb1a35bd9fc1e31acafd5372c30f5c1187"),
      33);

  // [Chain m/0'/1'/2']
  hdnode_private_ckd_prime(&node, 2);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "2e69929e00b5ab250f49c3fb1c12f252de4fed2c1db88387094a0f8c4c9ccd6c"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "92a5b23c0b8a99e37d07df3fb9966917f5d06e02ddbd909c7e184371463e9fc9"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "01ae98736566d30ed0e9d2f4486a64bc95740d89c7db33f52121f8ea8f76ff0fc1"),
      33);

  // [Chain m/0'/1'/2'/2']
  hdnode_private_ckd_prime(&node, 2);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "8f6d87f93d750e0efccda017d662a1b31a266e4a6f5993b15f5c1f07f74dd5cc"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "30d1dc7e5fc04c31219ab25a27ae00b50f6fd66622f6e9c913253d6511d1e662"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "018abae2d66361c879b900d204ad2cc4984fa2aa344dd7ddc46007329ac76c429c"),
      33);

  // [Chain m/0'/1'/2'/2'/1000000000']
  hdnode_private_ckd_prime(&node, 1000000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "68789923a0cac2cd5a29172a475fe9e0fb14cd6adb5ad98a3fa70333e7afa230"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "013c24da049451555d51a7014a37337aa4e12d41e485abccfa46b47dfb2af54b7a"),
      33);
}
END_TEST

// test vector 2 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_ed25519_vector_2) {
  HDNode node;
  int r;

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, ED25519_NAME, &node);

  // [Chain m]
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "ef70a74db9c3a5af931b5fe73ed8e1a53464133654fd55e7a66f8570b8e33c3b"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "171cb88b1b3c1db25add599712e36245d75bc65a1a5c9e18d76f9f2b1eab4012"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "018fe9693f8fa62a4305a140b9764c5ee01e455963744fe18204b4fb948249308a"),
      33);

  // [Chain m/0']
  r = hdnode_private_ckd_prime(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "0b78a3226f915c082bf118f83618a618ab6dec793752624cbeb622acb562862d"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "1559eb2bbec5790b0c65d8693e4d0875b1747f4970ae8b650486ed7470845635"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0186fab68dcb57aa196c77c5f264f215a112c22a912c10d123b0d03c3c28ef1037"),
      33);

  // [Chain m/0'/2147483647']
  r = hdnode_private_ckd_prime(&node, 2147483647);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "138f0b2551bcafeca6ff2aa88ba8ed0ed8de070841f0c4ef0165df8181eaad7f"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "ea4f5bfe8694d8bb74b7b59404632fd5968b774ed545e810de9c32a4fb4192f4"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "015ba3b9ac6e90e83effcd25ac4e58a1365a9e35a3d3ae5eb07b9e4d90bcf7506d"),
      33);

  // [Chain m/0'/2147483647'/1']
  r = hdnode_private_ckd_prime(&node, 1);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "73bd9fff1cfbde33a1b846c27085f711c0fe2d66fd32e139d3ebc28e5a4a6b90"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "3757c7577170179c7868353ada796c839135b3d30554bbb74a4b1e4a5a58505c"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "012e66aa57069c86cc18249aecf5cb5a9cebbfd6fadeab056254763874a9352b45"),
      33);

  // [Chain m/0'/2147483647'/1'/2147483646']
  r = hdnode_private_ckd_prime(&node, 2147483646);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "0902fe8a29f9140480a00ef244bd183e8a13288e4412d8389d140aac1794825a"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "5837736c89570de861ebc173b1086da4f505d4adb387c6a1b1342d5e4ac9ec72"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "01e33c0f7d81d843c572275f287498e8d408654fdf0d1e065b84e2e6f157aab09b"),
      33);

  // [Chain m/0'/2147483647'/1'/2147483646'/2']
  r = hdnode_private_ckd_prime(&node, 2);
  ck_assert_int_eq(r, 1);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "5d70af781f3a37b829f0d060924d5e960bdc02e85423494afc0b1a41bbe196d4"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "551d333177df541ad876a60ea71f00447931c0a9da16f227c11ea080d7391b8d"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0147150c75db263559a70d5778bf36abbab30fb061ad69f69ece61a72b0cfa4fc0"),
      33);
}
END_TEST

// test vector 1 from
// https://github.com/decred/dcrd/blob/master/hdkeychain/extendedkey_test.go
START_TEST(test_bip32_decred_vector_1) {
  HDNode node, node2, node3;
  uint32_t fingerprint;
  char str[112];
  int r;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   SECP256K1_NAME, &node);

  // secp256k1_decred_info.bip32_name != "Bitcoin seed" so we cannot use it in
  // hdnode_from_seed
  node.curve = &secp256k1_decred_info;

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3hCznBesA6jBtmoyVFPfyMSZ1qYZ3WdjdebquvkEfmRfxC9VFEFi2YD"
                   "aJqHnx7uGe75eGSa3Mn3oHK11hBW7KZUrPxwbCPBmuCi1nwm182s");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZ9169KDAEUnyoBhjjmT2VaEodr6pUTDoqCEAeqgbfr2JfkB88BbK77j"
                   "bTYbcYXb2FVz7DKBdW4P618yd51MwF8DjKVopSbS7Lkgi6bowX5w");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 0);
  ck_assert_int_eq(fingerprint, 0xbc495588);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "035a784662a4a20a65bf6aab9ae98a6c068a81c52e4b032c0fb5400c706cfccc56"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3kUQDBztdyjKuwnaL3hfKYpT7W6X2huYH5d61YSWFBebSYwEBHAXJkC"
                   "pQ7rvMAxPzKqxVCGLvBqWvGxXjAyMJsV1XwKkfnQCM9KctC8k8bk");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZCGVaKZBiMo7pMgLaZm1qmchjWenTeVcUdFQkTNsFGFEA6xs4EW8PKi"
                   "qYqP7HBAitt9Hw16VQkQ1tjsZQSHNWFc6bEK6bLqrbco24FzBTY4");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(fingerprint, 0xc67bc2ef);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03501e454bf00751f24b1b489aa925215d66af2234e3891c3b21a52bedb3cd711c"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3nRtCZ5VAoHW4RUwQgRafSNRPUDFrmsgyY71A5eoZceVfuyL9SbZe2r"
                   "cbwDW2UwpkEniE4urffgbypegscNchPajWzy9QS4cRxF8QYXsZtq");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZEDyZgdnFBMHxqNhfCUwBfAg1UmXHiTmB5jKtzbAZhF8PTzy2PwAicN"
                   "dkg1CmW6TARxQeUbgC7nAQenJts4YoG3KMiqcjsjgeMvwLc43w6C");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2']
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd_prime(&node, 2);
  ck_assert_int_eq(fingerprint, 0xe7072187);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "0357bfe1e341d01c69fe5654309956cbea516822fba8a601743a012a7896ee8dc2"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3pYtkZK168vgrU38gXkUSjHQ2LGpEUzQ9fXrR8fGUR59YviSnm6U82X"
                   "jQYhpJEUPnVcC9bguJBQU5xVM4VFcDHu9BgScGPA6mQMH4bn5Cth");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZGLz7gsJAWzUksvtw3opxx5eeLq5fRaUMDABA3bdUVfnGUk5fiS5Cc3"
                   "kZGTjWtYr3jrEavQQnAF6jv2WCpZtFX4uFgifXqev6ED1TM9rTCB");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2'/2]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(fingerprint, 0xbcbbc1c4);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02e8445082a72f29b75ca48748a914df60622a609cacfce8ed0e35804560741d29"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3r7zqYFjT3NiNzdnwGxGpYh6S1TJCp1zA6mSEGaqLBJFnCB94cRMp7Y"
                   "YLR49aTZHZ7ya1CXwQJ6rodKeU9NgQTxkPSK7pzgZRgjYkQ7rgJh");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZHv6Cfp2XRSWHQXZBo1dLmVM421Zdkc4MePkyBXCLFttVkCmwZkxth4"
                   "ZV9PzkFP3DtD5xcVq2CPSYpJMWMaoxu1ixz4GNZFVcE2xnHP6chJ");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0'/1/2'/2/1000000000]
  fingerprint = hdnode_fingerprint(&node);
  hdnode_private_ckd(&node, 1000000000);
  ck_assert_int_eq(fingerprint, 0xe58b52e4);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "022a471424da5e657499d1ff51cb43c47481a03b1e77f951fe64cec9f5a48f7011"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3tJXnTDSb3uE6Euo6WvvhFKfBMNfxuJt5smqyPoHEoomoBMQyhYoQSK"
                   "JAHWtWxmuqdUVb8q9J2NaTkF6rYm6XDrSotkJ55bM21fffa7VV97");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZL6d9amjfRy1zeoZM2zHDU7uoMvwPqtxHRQAiJjeEtQQWjP3retQV1q"
                   "KJyzUd6ZJNgbJGXjtc5pdoBcTTYTLoxQzvV9JJCzCjB2eCWpRf8T");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
}
END_TEST

// test vector 2 from
// https://github.com/decred/dcrd/blob/master/hdkeychain/extendedkey_test.go
START_TEST(test_bip32_decred_vector_2) {
  HDNode node, node2, node3;
  uint32_t fingerprint;
  char str[112];
  int r;

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, SECP256K1_NAME, &node);

  // secp256k1_decred_info.bip32_name != "Bitcoin seed" so we cannot use it in
  // hdnode_from_seed
  node.curve = &secp256k1_decred_info;

  // [Chain m]
  fingerprint = 0;
  ck_assert_int_eq(fingerprint, 0x00000000);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "60499f801b896d83179a4374aeb7822aaeaceaa0db1f85ee3e904c4defbd9689"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "4b03d6fc340455b363f51020ad3ecca4f0850280cf436c70c727923f6db46c3e"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03cbcaa9c98c877a26977d00825c956a238e8dddfbd322cce4f74b0b5bd6ace4a7"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3hCznBesA6jBtPKJbQTxRZAKG2gyj8tZKEPaCsV4e9YYFBAgRP2eTSP"
                   "Aeu4r8dTMt9q51j2Vdt5zNqj7jbtovvocrP1qLj6WUTLF9xYQt4y");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZ9169KDAEUnynoD4qvXJwmxZt3FFA5UdWn1twnRReE9AxjCKJLNFY1u"
                   "BoegbFmwzA4Du7yqnu8tLivhrCCH6P3DgBS1HH5vmf8MpNXvvYT9");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x2524c9d3);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f15ac7e1e"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22a98d12ea"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3jMy45BuuDETfxi59P8NTSjHPrNVq4wPRfLgRd57923L2hosj5NUEqi"
                   "LYQ4i7fJtUpiXZLr2wUeToJY2Tm5sCpAJdajEHDmieVJiPQNXwu9");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZBA4RCkCybJFaNbqPuBiyfXY1rvmG1XTdCy1AY1U96dxkFqWc2i5KRE"
                   "Mh7NYPpy7ZPMhdpFMAesex3JdFDfX4J5FEW3HjSacqEYPfwb9Cj7");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483647);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x6035c6ad);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18fd52e6e93"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03c01e7425647bdefa82b12d9bad5e3e6865bee0502694b94ca58b666abc0a5c3b"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3mgHPRgK838mLK6T1p6WeBoJoJtXA1pGTHjqFuyHekcM7UTuER8fGwe"
                   "RRsoLqSuHa98uskVPnJnfWZEBUC1AVmXnSCPDvUFKydXNnnPHTuQ");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZDUNkZEcCRCZEizDGL9sAQbZRKSnaxQLeqN9zpueeqCyq2VY7NUGMXA"
                   "SacsK96S8XzNjq3YgFgwLtj8MJBToW6To9U5zxuazEyh89bjR1xA");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 1);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x36fc7080);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "704addf544a06e5ee4bea37098463c23613da32020d604506da8c0518e1da4b7"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "03a7d1d856deb74c508e05031f9895dab54626251b3806e16b4bd12e781a7df5b9"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3oFqwZZ9bJcUmhAeJyyshvrTWtrAsHfcRYQbEzNiiH5nGvM6wVTDn6w"
                   "oQEz92b2EHTYZBtLi82jKEnxSouA3cVaW8YWBsw5c3f4mwAhA3d2");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZF3wJh7SfggGg74QZW3EE9ei8uQSJEFgd62uyuK5iMgQzUNjpSnprgT"
                   "pYz3d6Q3fXXtEEXQqpzWcP4LUVuXFsgA8JKt1Hot5kyUk4pPRhDz");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1/2147483646']
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd_prime(&node, 2147483646);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x45309b4c);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b247d6a2d"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "02d2b36900396c9282fa14628566582f206a5dd0bcc8d5e892611806cafb0301f0"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3qF3177i87wMirg6sraDvqty8yZg6THpXFPSXuM5AShBiiUQbq8FhSZ"
                   "DGkYmBNR3RKfBrxzkKDBpsRFJfTnQfLsvpPPqRnakat6hHQA43X9");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZH38NEg1CW19dGZs8NdaT4hDkz7wXPstio1mGpHSAXHpSGW3UnTrn25"
                   "ERT1Mp8ae5GMoQHMbgQiPrChMXQMdx3UqS8YqFkT1pqait8fY92u");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // [Chain m/0/2147483647'/1/2147483646'/2]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_private_ckd(&node, 2);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x3491a5e6);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"),
      32);
  ck_assert_mem_eq(
      node.private_key,
      fromhex(
          "bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a4842125ac23"),
      32);
  hdnode_fill_public_key(&node);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "024d902e1a2fc7a8755ab5b694c575fce742c48d9ff192e63df5193e4c7afe1f9c"),
      33);
  hdnode_serialize_private(&node, fingerprint, DECRED_VERSION_PRIVATE, str,
                           sizeof(str));
  ck_assert_str_eq(str,
                   "dprv3s15tfqzxhw8Kmo7RBEqMeyvC7uGekLniSmvbs3bckpxQ6ks1KKqfmH"
                   "144Jgh3PLxkyZRcS367kp7DrtUmnG16NpnsoNhxSXRgKbJJ7MUQR");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  hdnode_fill_public_key(&node2);
  ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZJoBFoQJ35zvEBgsfhJBssnAp8TY5gvruzQFLmyxcqRb7enVtGfSkLo"
                   "2CkAZJMpa6T2fx6fUtvTgXtUvSVgAZ56bEwGxQsToeZfFV8VadE1");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  memcpy(&node3, &node, sizeof(HDNode));
  memzero(&node3.private_key, 32);
  ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));

  // init m
  hdnode_deserialize(
      "dpubZF4LSCdF9YKZfNzTVYhz4RBxsjYXqms8AQnMBHXZ8GUKoRSigG7kQnKiJt5pzk93Q8Fx"
      "cdVBEkQZruSXduGtWnkwXzGnjbSovQ97dCxqaXc",
      DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, SECP256K1_DECRED_NAME,
      &node, NULL);

  // test public derivation
  // [Chain m/0]
  fingerprint = hdnode_fingerprint(&node);
  r = hdnode_public_ckd(&node, 0);
  ck_assert_int_eq(r, 1);
  ck_assert_int_eq(fingerprint, 0x6a19cfb3);
  ck_assert_mem_eq(
      node.chain_code,
      fromhex(
          "dcfe00831741a3a4803955147cdfc7053d69b167b1d03b5f9e63934217a005fd"),
      32);
  ck_assert_mem_eq(
      node.public_key,
      fromhex(
          "029555ea7bde276cd2c42c4502f40b5d16469fb310ae3aeee2a9000455f41b0866"),
      33);
  hdnode_serialize_public(&node, fingerprint, DECRED_VERSION_PUBLIC, str,
                          sizeof(str));
  ck_assert_str_eq(str,
                   "dpubZHJs2Z3PtHbbpaXQCi5wBKPhU8tC5ztBKUYBCYNGKk8eZ1EmBs3MhnL"
                   "JbxHFMAahGnDnZT7qZxC7AXKP8PB6BDNUZgkG77moNMRmXyQ6s6s");
  r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE,
                         SECP256K1_DECRED_NAME, &node2, NULL);
  ck_assert_int_eq(r, 0);
  ck_assert_mem_eq(&node2, &node, sizeof(HDNode));
}
END_TEST

START_TEST(test_ecdsa_signature) {
  int res;
  uint8_t digest[32];
  uint8_t pubkey[65];
  const ecdsa_curve *curve = &secp256k1;

  // sha2(sha2("\x18Bitcoin Signed Message:\n\x0cHello World!"))
  memcpy(
      digest,
      fromhex(
          "de4e9524586d6fce45667f9ff12f661e79870c4105fa0fb58af976619bb11432"),
      32);
  // r = 2:  Four points should exist
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000020123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 0);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "043fc5bf5fec35b6ffe6fd246226d312742a8c296bfa57dd22da509a2e348529b7dd"
          "b9faf8afe1ecda3c05e7b2bda47ee1f5a87e952742b22afca560b29d972fcf"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000020123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 1);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "0456d8089137b1fd0d890f8c7d4a04d0fd4520a30b19518ee87bd168ea12ed809032"
          "9274c4c6c0d9df04515776f2741eeffc30235d596065d718c3973e19711ad0"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000020123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 2);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "04cee0e740f41aab39156844afef0182dea2a8026885b10454a2d539df6f6df9023a"
          "bfcb0f01c50bef3c0fa8e59a998d07441e18b1c60583ef75cc8b912fb21a15"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000020123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 3);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "0490d2bd2e9a564d6e1d8324fc6ad00aa4ae597684ecf4abea58bdfe7287ea4fa729"
          "68c2e5b0b40999ede3d7898d94e82c3f8dc4536a567a4bd45998c826a4c4b2"),
      65);

  memcpy(
      digest,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000000"),
      32);
  // r = 7:  No point P with P.x = 7,  but P.x = (order + 7) exists
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000070123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 2);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "044d81bb47a31ffc6cf1f780ecb1e201ec47214b651650867c07f13ad06e12a1b040"
          "de78f8dbda700f4d3cd7ee21b3651a74c7661809699d2be7ea0992b0d39797"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000070123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 3);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "044d81bb47a31ffc6cf1f780ecb1e201ec47214b651650867c07f13ad06e12a1b0bf"
          "21870724258ff0b2c32811de4c9ae58b3899e7f69662d41815f66c4f2c6498"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000070123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 0);
  ck_assert_int_eq(res, 1);

  memcpy(
      digest,
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      32);
  // r = 1:  Two points P with P.x = 1,  but P.x = (order + 7) doesn't exist
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000010123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 0);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "045d330b2f89dbfca149828277bae852dd4aebfe136982cb531a88e9e7a89463fe71"
          "519f34ea8feb9490c707f14bc38c9ece51762bfd034ea014719b7c85d2871b"),
      65);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000010123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 1);
  ck_assert_int_eq(res, 0);
  ck_assert_mem_eq(
      pubkey,
      fromhex(
          "049e609c3950e70d6f3e3f3c81a473b1d5ca72739d51debdd80230ae80cab05134a9"
          "4285375c834a417e8115c546c41da83a263087b79ef1cae25c7b3c738daa2b"),
      65);

  // r = 0 is always invalid
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000010123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 2);
  ck_assert_int_eq(res, 1);
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000000123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 0);
  ck_assert_int_eq(res, 1);
  // r >= order is always invalid
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd03641410123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 0);
  ck_assert_int_eq(res, 1);
  // check that overflow of r is handled
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "000000000000000000000000000000014551231950B75FC4402DA1722FC9BAEE0123"
          "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"),
      digest, 2);
  ck_assert_int_eq(res, 1);
  // s = 0 is always invalid
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000020000"
          "000000000000000000000000000000000000000000000000000000000000"),
      digest, 0);
  ck_assert_int_eq(res, 1);
  // s >= order is always invalid
  res = ecdsa_recover_pub_from_sig(
      curve, pubkey,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000002ffff"
          "fffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
      digest, 0);
  ck_assert_int_eq(res, 1);
}
END_TEST

#define test_deterministic(KEY, MSG, K)           \
  do {                                            \
    sha256_Raw((uint8_t *)MSG, strlen(MSG), buf); \
    init_rfc6979(fromhex(KEY), buf, &rng);        \
    generate_k_rfc6979(&k, &rng);                 \
    bn_write_be(&k, buf);                         \
    ck_assert_mem_eq(buf, fromhex(K), 32);        \
  } while (0)

START_TEST(test_rfc6979) {
  bignum256 k;
  uint8_t buf[32];
  rfc6979_state rng;

  test_deterministic(
      "c9afa9d845ba75166b5c215767b1d6934e50c3db36e89b127b8a622b120f6721",
      "sample",
      "a6e3c57dd01abe90086538398355dd4c3b17aa873382b0f24d6129493d8aad60");
  test_deterministic(
      "cca9fbcc1b41e5a95d369eaa6ddcff73b61a4efaa279cfc6567e8daa39cbaf50",
      "sample",
      "2df40ca70e639d89528a6b670d9d48d9165fdc0febc0974056bdce192b8e16a3");
  test_deterministic(
      "0000000000000000000000000000000000000000000000000000000000000001",
      "Satoshi Nakamoto",
      "8f8a276c19f4149656b280621e358cce24f5f52542772691ee69063b74f15d15");
  test_deterministic(
      "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
      "Satoshi Nakamoto",
      "33a19b60e25fb6f4435af53a3d42d493644827367e6453928554f43e49aa6f90");
  test_deterministic(
      "f8b8af8ce3c7cca5e300d33939540c10d45ce001b8f252bfbc57ba0342904181",
      "Alan Turing",
      "525a82b70e67874398067543fd84c83d30c175fdc45fdeee082fe13b1d7cfdf1");
  test_deterministic(
      "0000000000000000000000000000000000000000000000000000000000000001",
      "All those moments will be lost in time, like tears in rain. Time to "
      "die...",
      "38aa22d72376b4dbc472e06c3ba403ee0a394da63fc58d88686c611aba98d6b3");
  test_deterministic(
      "e91671c46231f833a6406ccbea0e3e392c76c167bac1cb013f6f1013980455c2",
      "There is a computer disease that anybody who works with computers knows "
      "about. It's a very serious disease and it interferes completely with "
      "the work. The trouble with computers is that you 'play' with them!",
      "1f4b84c23a86a221d233f2521be018d9318639d5b8bbd6374a8a59232d16ad3d");
}
END_TEST

// test vectors from
// http://www.inconteam.com/software-development/41-encryption/55-aes-test-vectors
START_TEST(test_aes) {
  aes_encrypt_ctx ctxe;
  aes_decrypt_ctx ctxd;
  uint8_t ibuf[16], obuf[16], iv[16], cbuf[16];
  const char **ivp, **plainp, **cipherp;

  // ECB
  static const char *ecb_vector[] = {
      // plain                            cipher
      "6bc1bee22e409f96e93d7e117393172a",
      "f3eed1bdb5d2a03c064b5a7e3db181f8",
      "ae2d8a571e03ac9c9eb76fac45af8e51",
      "591ccb10d410ed26dc5ba74a31362870",
      "30c81c46a35ce411e5fbc1191a0a52ef",
      "b6ed21b99ca6f4f9f153e7b1beafed1d",
      "f69f2445df4f9b17ad2b417be66c3710",
      "23304b7a39f9f3ff067d8d8f9e24ecc7",
      0,
      0,
  };
  plainp = ecb_vector;
  cipherp = ecb_vector + 1;
  while (*plainp && *cipherp) {
    // encrypt
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(ibuf, fromhex(*plainp), 16);
    aes_ecb_encrypt(ibuf, obuf, 16, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
    // decrypt
    aes_decrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxd);
    memcpy(ibuf, fromhex(*cipherp), 16);
    aes_ecb_decrypt(ibuf, obuf, 16, &ctxd);
    ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
    plainp += 2;
    cipherp += 2;
  }

  // CBC
  static const char *cbc_vector[] = {
      // iv                               plain cipher
      "000102030405060708090A0B0C0D0E0F",
      "6bc1bee22e409f96e93d7e117393172a",
      "f58c4c04d6e5f1ba779eabfb5f7bfbd6",
      "F58C4C04D6E5F1BA779EABFB5F7BFBD6",
      "ae2d8a571e03ac9c9eb76fac45af8e51",
      "9cfc4e967edb808d679f777bc6702c7d",
      "9CFC4E967EDB808D679F777BC6702C7D",
      "30c81c46a35ce411e5fbc1191a0a52ef",
      "39f23369a9d9bacfa530e26304231461",
      "39F23369A9D9BACFA530E26304231461",
      "f69f2445df4f9b17ad2b417be66c3710",
      "b2eb05e2c39be9fcda6c19078c6a9d1b",
      0,
      0,
      0,
  };
  ivp = cbc_vector;
  plainp = cbc_vector + 1;
  cipherp = cbc_vector + 2;
  while (*plainp && *cipherp) {
    // encrypt
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*plainp), 16);
    aes_cbc_encrypt(ibuf, obuf, 16, iv, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
    // decrypt
    aes_decrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxd);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*cipherp), 16);
    aes_cbc_decrypt(ibuf, obuf, 16, iv, &ctxd);
    ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
    ivp += 3;
    plainp += 3;
    cipherp += 3;
  }

  // CFB
  static const char *cfb_vector[] = {
      "000102030405060708090A0B0C0D0E0F",
      "6bc1bee22e409f96e93d7e117393172a",
      "DC7E84BFDA79164B7ECD8486985D3860",
      "DC7E84BFDA79164B7ECD8486985D3860",
      "ae2d8a571e03ac9c9eb76fac45af8e51",
      "39ffed143b28b1c832113c6331e5407b",
      "39FFED143B28B1C832113C6331E5407B",
      "30c81c46a35ce411e5fbc1191a0a52ef",
      "df10132415e54b92a13ed0a8267ae2f9",
      "DF10132415E54B92A13ED0A8267AE2F9",
      "f69f2445df4f9b17ad2b417be66c3710",
      "75a385741ab9cef82031623d55b1e471",
      0,
      0,
      0,
  };
  ivp = cfb_vector;
  plainp = cfb_vector + 1;
  cipherp = cfb_vector + 2;
  while (*plainp && *cipherp) {
    // encrypt
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*plainp), 16);
    aes_cfb_encrypt(ibuf, obuf, 16, iv, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
    // decrypt (uses encryption)
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*cipherp), 16);
    aes_cfb_decrypt(ibuf, obuf, 16, iv, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
    ivp += 3;
    plainp += 3;
    cipherp += 3;
  }

  // OFB
  static const char *ofb_vector[] = {
      "000102030405060708090A0B0C0D0E0F",
      "6bc1bee22e409f96e93d7e117393172a",
      "dc7e84bfda79164b7ecd8486985d3860",
      "B7BF3A5DF43989DD97F0FA97EBCE2F4A",
      "ae2d8a571e03ac9c9eb76fac45af8e51",
      "4febdc6740d20b3ac88f6ad82a4fb08d",
      "E1C656305ED1A7A6563805746FE03EDC",
      "30c81c46a35ce411e5fbc1191a0a52ef",
      "71ab47a086e86eedf39d1c5bba97c408",
      "41635BE625B48AFC1666DD42A09D96E7",
      "f69f2445df4f9b17ad2b417be66c3710",
      "0126141d67f37be8538f5a8be740e484",
      0,
      0,
      0,
  };
  ivp = ofb_vector;
  plainp = ofb_vector + 1;
  cipherp = ofb_vector + 2;
  while (*plainp && *cipherp) {
    // encrypt
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*plainp), 16);
    aes_ofb_encrypt(ibuf, obuf, 16, iv, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
    // decrypt (uses encryption)
    aes_encrypt_key256(
        fromhex(
            "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
        &ctxe);
    memcpy(iv, fromhex(*ivp), 16);
    memcpy(ibuf, fromhex(*cipherp), 16);
    aes_ofb_decrypt(ibuf, obuf, 16, iv, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
    ivp += 3;
    plainp += 3;
    cipherp += 3;
  }

  // CTR
  static const char *ctr_vector[] = {
      // plain                            cipher
      "6bc1bee22e409f96e93d7e117393172a",
      "601ec313775789a5b7a7f504bbf3d228",
      "ae2d8a571e03ac9c9eb76fac45af8e51",
      "f443e3ca4d62b59aca84e990cacaf5c5",
      "30c81c46a35ce411e5fbc1191a0a52ef",
      "2b0930daa23de94ce87017ba2d84988d",
      "f69f2445df4f9b17ad2b417be66c3710",
      "dfc9c58db67aada613c2dd08457941a6",
      0,
      0,
  };
  // encrypt
  plainp = ctr_vector;
  cipherp = ctr_vector + 1;
  memcpy(cbuf, fromhex("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), 16);
  aes_encrypt_key256(
      fromhex(
          "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
      &ctxe);
  while (*plainp && *cipherp) {
    memcpy(ibuf, fromhex(*plainp), 16);
    aes_ctr_encrypt(ibuf, obuf, 16, cbuf, aes_ctr_cbuf_inc, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
    plainp += 2;
    cipherp += 2;
  }
  // decrypt (uses encryption)
  plainp = ctr_vector;
  cipherp = ctr_vector + 1;
  memcpy(cbuf, fromhex("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), 16);
  aes_encrypt_key256(
      fromhex(
          "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"),
      &ctxe);
  while (*plainp && *cipherp) {
    memcpy(ibuf, fromhex(*cipherp), 16);
    aes_ctr_decrypt(ibuf, obuf, 16, cbuf, aes_ctr_cbuf_inc, &ctxe);
    ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
    plainp += 2;
    cipherp += 2;
  }
}
END_TEST

#define TEST1 "abc"
#define TEST2_1 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
#define TEST2_2a "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
#define TEST2_2b "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
#define TEST2_2 TEST2_2a TEST2_2b
#define TEST3 "a" /* times 1000000 */
#define TEST4a "01234567012345670123456701234567"
#define TEST4b "01234567012345670123456701234567"
/* an exact multiple of 512 bits */
#define TEST4 TEST4a TEST4b /* times 10 */

#define TEST7_1 "\x49\xb2\xae\xc2\x59\x4b\xbe\x3a\x3b\x11\x75\x42\xd9\x4a\xc8"
#define TEST8_1 \
  "\x9a\x7d\xfd\xf1\xec\xea\xd0\x6e\xd6\x46\xaa\x55\xfe\x75\x71\x46"
#define TEST9_1                                                      \
  "\x65\xf9\x32\x99\x5b\xa4\xce\x2c\xb1\xb4\xa2\xe7\x1a\xe7\x02\x20" \
  "\xaa\xce\xc8\x96\x2d\xd4\x49\x9c\xbd\x7c\x88\x7a\x94\xea\xaa\x10" \
  "\x1e\xa5\xaa\xbc\x52\x9b\x4e\x7e\x43\x66\x5a\x5a\xf2\xcd\x03\xfe" \
  "\x67\x8e\xa6\xa5\x00\x5b\xba\x3b\x08\x22\x04\xc2\x8b\x91\x09\xf4" \
  "\x69\xda\xc9\x2a\xaa\xb3\xaa\x7c\x11\xa1\xb3\x2a"
#define TEST10_1                                                     \
  "\xf7\x8f\x92\x14\x1b\xcd\x17\x0a\xe8\x9b\x4f\xba\x15\xa1\xd5\x9f" \
  "\x3f\xd8\x4d\x22\x3c\x92\x51\xbd\xac\xbb\xae\x61\xd0\x5e\xd1\x15" \
  "\xa0\x6a\x7c\xe1\x17\xb7\xbe\xea\xd2\x44\x21\xde\xd9\xc3\x25\x92" \
  "\xbd\x57\xed\xea\xe3\x9c\x39\xfa\x1f\xe8\x94\x6a\x84\xd0\xcf\x1f" \
  "\x7b\xee\xad\x17\x13\xe2\xe0\x95\x98\x97\x34\x7f\x67\xc8\x0b\x04" \
  "\x00\xc2\x09\x81\x5d\x6b\x10\xa6\x83\x83\x6f\xd5\x56\x2a\x56\xca" \
  "\xb1\xa2\x8e\x81\xb6\x57\x66\x54\x63\x1c\xf1\x65\x66\xb8\x6e\x3b" \
  "\x33\xa1\x08\xb0\x53\x07\xc0\x0a\xff\x14\xa7\x68\xed\x73\x50\x60" \
  "\x6a\x0f\x85\xe6\xa9\x1d\x39\x6f\x5b\x5c\xbe\x57\x7f\x9b\x38\x80" \
  "\x7c\x7d\x52\x3d\x6d\x79\x2f\x6e\xbc\x24\xa4\xec\xf2\xb3\xa4\x27" \
  "\xcd\xbb\xfb"
#define length(x) (sizeof(x) - 1)

// test vectors from rfc-4634
START_TEST(test_sha1) {
  struct {
    const char *test;
    int length;
    int repeatcount;
    int extrabits;
    int numberExtrabits;
    const char *result;
  } tests[] = {
      /* 1 */ {TEST1, length(TEST1), 1, 0, 0,
               "A9993E364706816ABA3E25717850C26C9CD0D89D"},
      /* 2 */
      {TEST2_1, length(TEST2_1), 1, 0, 0,
       "84983E441C3BD26EBAAE4AA1F95129E5E54670F1"},
      /* 3 */
      {TEST3, length(TEST3), 1000000, 0, 0,
       "34AA973CD4C4DAA4F61EEB2BDBAD27316534016F"},
      /* 4 */
      {TEST4, length(TEST4), 10, 0, 0,
       "DEA356A2CDDD90C7A7ECEDC5EBB563934F460452"},
      /* 5 */ {"", 0, 0, 0x98, 5, "29826B003B906E660EFF4027CE98AF3531AC75BA"},
      /* 6 */ {"\x5e", 1, 1, 0, 0, "5E6F80A34A9798CAFC6A5DB96CC57BA4C4DB59C2"},
      /* 7 */
      {TEST7_1, length(TEST7_1), 1, 0x80, 3,
       "6239781E03729919C01955B3FFA8ACB60B988340"},
      /* 8 */
      {TEST8_1, length(TEST8_1), 1, 0, 0,
       "82ABFF6605DBE1C17DEF12A394FA22A82B544A35"},
      /* 9 */
      {TEST9_1, length(TEST9_1), 1, 0xE0, 3,
       "8C5B2A5DDAE5A97FC7F9D85661C672ADBF7933D4"},
      /* 10 */
      {TEST10_1, length(TEST10_1), 1, 0, 0,
       "CB0082C8F197D260991BA6A460E76E202BAD27B3"}};

  for (int i = 0; i < 10; i++) {
    SHA1_CTX ctx;
    uint8_t digest[SHA1_DIGEST_LENGTH];
    sha1_Init(&ctx);
    /* extra bits are not supported */
    if (tests[i].numberExtrabits) continue;
    for (int j = 0; j < tests[i].repeatcount; j++) {
      sha1_Update(&ctx, (const uint8_t *)tests[i].test, tests[i].length);
    }
    sha1_Final(&ctx, digest);
    ck_assert_mem_eq(digest, fromhex(tests[i].result), SHA1_DIGEST_LENGTH);
  }
}
END_TEST

#define TEST7_256 "\xbe\x27\x46\xc6\xdb\x52\x76\x5f\xdb\x2f\x88\x70\x0f\x9a\x73"
#define TEST8_256 \
  "\xe3\xd7\x25\x70\xdc\xdd\x78\x7c\xe3\x88\x7a\xb2\xcd\x68\x46\x52"
#define TEST9_256                                                    \
  "\x3e\x74\x03\x71\xc8\x10\xc2\xb9\x9f\xc0\x4e\x80\x49\x07\xef\x7c" \
  "\xf2\x6b\xe2\x8b\x57\xcb\x58\xa3\xe2\xf3\xc0\x07\x16\x6e\x49\xc1" \
  "\x2e\x9b\xa3\x4c\x01\x04\x06\x91\x29\xea\x76\x15\x64\x25\x45\x70" \
  "\x3a\x2b\xd9\x01\xe1\x6e\xb0\xe0\x5d\xeb\xa0\x14\xeb\xff\x64\x06" \
  "\xa0\x7d\x54\x36\x4e\xff\x74\x2d\xa7\x79\xb0\xb3"
#define TEST10_256                                                   \
  "\x83\x26\x75\x4e\x22\x77\x37\x2f\x4f\xc1\x2b\x20\x52\x7a\xfe\xf0" \
  "\x4d\x8a\x05\x69\x71\xb1\x1a\xd5\x71\x23\xa7\xc1\x37\x76\x00\x00" \
  "\xd7\xbe\xf6\xf3\xc1\xf7\xa9\x08\x3a\xa3\x9d\x81\x0d\xb3\x10\x77" \
  "\x7d\xab\x8b\x1e\x7f\x02\xb8\x4a\x26\xc7\x73\x32\x5f\x8b\x23\x74" \
  "\xde\x7a\x4b\x5a\x58\xcb\x5c\x5c\xf3\x5b\xce\xe6\xfb\x94\x6e\x5b" \
  "\xd6\x94\xfa\x59\x3a\x8b\xeb\x3f\x9d\x65\x92\xec\xed\xaa\x66\xca" \
  "\x82\xa2\x9d\x0c\x51\xbc\xf9\x33\x62\x30\xe5\xd7\x84\xe4\xc0\xa4" \
  "\x3f\x8d\x79\xa3\x0a\x16\x5c\xba\xbe\x45\x2b\x77\x4b\x9c\x71\x09" \
  "\xa9\x7d\x13\x8f\x12\x92\x28\x96\x6f\x6c\x0a\xdc\x10\x6a\xad\x5a" \
  "\x9f\xdd\x30\x82\x57\x69\xb2\xc6\x71\xaf\x67\x59\xdf\x28\xeb\x39" \
  "\x3d\x54\xd6"

// test vectors from rfc-4634
START_TEST(test_sha256) {
  struct {
    const char *test;
    int length;
    int repeatcount;
    int extrabits;
    int numberExtrabits;
    const char *result;
  } tests[] = {
      /* 1 */ {TEST1, length(TEST1), 1, 0, 0,
               "BA7816BF8F01CFEA4141"
               "40DE5DAE2223B00361A396177A9CB410FF61F20015AD"},
      /* 2 */
      {TEST2_1, length(TEST2_1), 1, 0, 0,
       "248D6A61D20638B8"
       "E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1"},
      /* 3 */
      {TEST3, length(TEST3), 1000000, 0, 0,
       "CDC76E5C9914FB92"
       "81A1C7E284D73E67F1809A48A497200E046D39CCC7112CD0"},
      /* 4 */
      {TEST4, length(TEST4), 10, 0, 0,
       "594847328451BDFA"
       "85056225462CC1D867D877FB388DF0CE35F25AB5562BFBB5"},
      /* 5 */
      {"", 0, 0, 0x68, 5,
       "D6D3E02A31A84A8CAA9718ED6C2057BE"
       "09DB45E7823EB5079CE7A573A3760F95"},
      /* 6 */
      {"\x19", 1, 1, 0, 0,
       "68AA2E2EE5DFF96E3355E6C7EE373E3D"
       "6A4E17F75F9518D843709C0C9BC3E3D4"},
      /* 7 */
      {TEST7_256, length(TEST7_256), 1, 0x60, 3,
       "77EC1DC8"
       "9C821FF2A1279089FA091B35B8CD960BCAF7DE01C6A7680756BEB972"},
      /* 8 */
      {TEST8_256, length(TEST8_256), 1, 0, 0,
       "175EE69B02BA"
       "9B58E2B0A5FD13819CEA573F3940A94F825128CF4209BEABB4E8"},
      /* 9 */
      {TEST9_256, length(TEST9_256), 1, 0xA0, 3,
       "3E9AD646"
       "8BBBAD2AC3C2CDC292E018BA5FD70B960CF1679777FCE708FDB066E9"},
      /* 10 */
      {TEST10_256, length(TEST10_256), 1, 0, 0,
       "97DBCA7D"
       "F46D62C8A422C941DD7E835B8AD3361763F7E9B2D95F4F0DA6E1CCBC"},
  };

  for (int i = 0; i < 10; i++) {
    SHA256_CTX ctx;
    uint8_t digest[SHA256_DIGEST_LENGTH];
    sha256_Init(&ctx);
    /* extra bits are not supported */
    if (tests[i].numberExtrabits) continue;
    for (int j = 0; j < tests[i].repeatcount; j++) {
      sha256_Update(&ctx, (const uint8_t *)tests[i].test, tests[i].length);
    }
    sha256_Final(&ctx, digest);
    ck_assert_mem_eq(digest, fromhex(tests[i].result), SHA256_DIGEST_LENGTH);
  }
}
END_TEST

#define TEST7_512 "\x08\xec\xb5\x2e\xba\xe1\xf7\x42\x2d\xb6\x2b\xcd\x54\x26\x70"
#define TEST8_512 \
  "\x8d\x4e\x3c\x0e\x38\x89\x19\x14\x91\x81\x6e\x9d\x98\xbf\xf0\xa0"
#define TEST9_512                                                    \
  "\x3a\xdd\xec\x85\x59\x32\x16\xd1\x61\x9a\xa0\x2d\x97\x56\x97\x0b" \
  "\xfc\x70\xac\xe2\x74\x4f\x7c\x6b\x27\x88\x15\x10\x28\xf7\xb6\xa2" \
  "\x55\x0f\xd7\x4a\x7e\x6e\x69\xc2\xc9\xb4\x5f\xc4\x54\x96\x6d\xc3" \
  "\x1d\x2e\x10\xda\x1f\x95\xce\x02\xbe\xb4\xbf\x87\x65\x57\x4c\xbd" \
  "\x6e\x83\x37\xef\x42\x0a\xdc\x98\xc1\x5c\xb6\xd5\xe4\xa0\x24\x1b" \
  "\xa0\x04\x6d\x25\x0e\x51\x02\x31\xca\xc2\x04\x6c\x99\x16\x06\xab" \
  "\x4e\xe4\x14\x5b\xee\x2f\xf4\xbb\x12\x3a\xab\x49\x8d\x9d\x44\x79" \
  "\x4f\x99\xcc\xad\x89\xa9\xa1\x62\x12\x59\xed\xa7\x0a\x5b\x6d\xd4" \
  "\xbd\xd8\x77\x78\xc9\x04\x3b\x93\x84\xf5\x49\x06"
#define TEST10_512                                                   \
  "\xa5\x5f\x20\xc4\x11\xaa\xd1\x32\x80\x7a\x50\x2d\x65\x82\x4e\x31" \
  "\xa2\x30\x54\x32\xaa\x3d\x06\xd3\xe2\x82\xa8\xd8\x4e\x0d\xe1\xde" \
  "\x69\x74\xbf\x49\x54\x69\xfc\x7f\x33\x8f\x80\x54\xd5\x8c\x26\xc4" \
  "\x93\x60\xc3\xe8\x7a\xf5\x65\x23\xac\xf6\xd8\x9d\x03\xe5\x6f\xf2" \
  "\xf8\x68\x00\x2b\xc3\xe4\x31\xed\xc4\x4d\xf2\xf0\x22\x3d\x4b\xb3" \
  "\xb2\x43\x58\x6e\x1a\x7d\x92\x49\x36\x69\x4f\xcb\xba\xf8\x8d\x95" \
  "\x19\xe4\xeb\x50\xa6\x44\xf8\xe4\xf9\x5e\xb0\xea\x95\xbc\x44\x65" \
  "\xc8\x82\x1a\xac\xd2\xfe\x15\xab\x49\x81\x16\x4b\xbb\x6d\xc3\x2f" \
  "\x96\x90\x87\xa1\x45\xb0\xd9\xcc\x9c\x67\xc2\x2b\x76\x32\x99\x41" \
  "\x9c\xc4\x12\x8b\xe9\xa0\x77\xb3\xac\xe6\x34\x06\x4e\x6d\x99\x28" \
  "\x35\x13\xdc\x06\xe7\x51\x5d\x0d\x73\x13\x2e\x9a\x0d\xc6\xd3\xb1" \
  "\xf8\xb2\x46\xf1\xa9\x8a\x3f\xc7\x29\x41\xb1\xe3\xbb\x20\x98\xe8" \
  "\xbf\x16\xf2\x68\xd6\x4f\x0b\x0f\x47\x07\xfe\x1e\xa1\xa1\x79\x1b" \
  "\xa2\xf3\xc0\xc7\x58\xe5\xf5\x51\x86\x3a\x96\xc9\x49\xad\x47\xd7" \
  "\xfb\x40\xd2"

// test vectors from rfc-4634
START_TEST(test_sha512) {
  struct {
    const char *test;
    int length;
    int repeatcount;
    int extrabits;
    int numberExtrabits;
    const char *result;
  } tests[] = {/* 1 */ {TEST1, length(TEST1), 1, 0, 0,
                        "DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA2"
                        "0A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD"
                        "454D4423643CE80E2A9AC94FA54CA49F"},
               /* 2 */
               {TEST2_2, length(TEST2_2), 1, 0, 0,
                "8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7FA1"
                "7299AEADB6889018501D289E4900F7E4331B99DEC4B5433A"
                "C7D329EEB6DD26545E96E55B874BE909"},
               /* 3 */
               {TEST3, length(TEST3), 1000000, 0, 0,
                "E718483D0CE769644E2E42C7BC15B4638E1F98B13B204428"
                "5632A803AFA973EBDE0FF244877EA60A4CB0432CE577C31B"
                "EB009C5C2C49AA2E4EADB217AD8CC09B"},
               /* 4 */
               {TEST4, length(TEST4), 10, 0, 0,
                "89D05BA632C699C31231DED4FFC127D5A894DAD412C0E024"
                "DB872D1ABD2BA8141A0F85072A9BE1E2AA04CF33C765CB51"
                "0813A39CD5A84C4ACAA64D3F3FB7BAE9"},
               /* 5 */
               {"", 0, 0, 0xB0, 5,
                "D4EE29A9E90985446B913CF1D1376C836F4BE2C1CF3CADA0"
                "720A6BF4857D886A7ECB3C4E4C0FA8C7F95214E41DC1B0D2"
                "1B22A84CC03BF8CE4845F34DD5BDBAD4"},
               /* 6 */
               {"\xD0", 1, 1, 0, 0,
                "9992202938E882E73E20F6B69E68A0A7149090423D93C81B"
                "AB3F21678D4ACEEEE50E4E8CAFADA4C85A54EA8306826C4A"
                "D6E74CECE9631BFA8A549B4AB3FBBA15"},
               /* 7 */
               {TEST7_512, length(TEST7_512), 1, 0x80, 3,
                "ED8DC78E8B01B69750053DBB7A0A9EDA0FB9E9D292B1ED71"
                "5E80A7FE290A4E16664FD913E85854400C5AF05E6DAD316B"
                "7359B43E64F8BEC3C1F237119986BBB6"},
               /* 8 */
               {TEST8_512, length(TEST8_512), 1, 0, 0,
                "CB0B67A4B8712CD73C9AABC0B199E9269B20844AFB75ACBD"
                "D1C153C9828924C3DDEDAAFE669C5FDD0BC66F630F677398"
                "8213EB1B16F517AD0DE4B2F0C95C90F8"},
               /* 9 */
               {TEST9_512, length(TEST9_512), 1, 0x80, 3,
                "32BA76FC30EAA0208AEB50FFB5AF1864FDBF17902A4DC0A6"
                "82C61FCEA6D92B783267B21080301837F59DE79C6B337DB2"
                "526F8A0A510E5E53CAFED4355FE7C2F1"},
               /* 10 */
               {TEST10_512, length(TEST10_512), 1, 0, 0,
                "C665BEFB36DA189D78822D10528CBF3B12B3EEF726039909"
                "C1A16A270D48719377966B957A878E720584779A62825C18"
                "DA26415E49A7176A894E7510FD1451F5"}};

  for (int i = 0; i < 10; i++) {
    SHA512_CTX ctx;
    uint8_t digest[SHA512_DIGEST_LENGTH];
    sha512_Init(&ctx);
    /* extra bits are not supported */
    if (tests[i].numberExtrabits) continue;
    for (int j = 0; j < tests[i].repeatcount; j++) {
      sha512_Update(&ctx, (const uint8_t *)tests[i].test, tests[i].length);
    }
    sha512_Final(&ctx, digest);
    ck_assert_mem_eq(digest, fromhex(tests[i].result), SHA512_DIGEST_LENGTH);
  }
}
END_TEST

// test vectors from http://www.di-mgt.com.au/sha_testvectors.html
START_TEST(test_sha3_256) {
  uint8_t digest[SHA3_256_DIGEST_LENGTH];

  sha3_256((uint8_t *)"", 0, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"),
      SHA3_256_DIGEST_LENGTH);

  sha3_256((uint8_t *)"abc", 3, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532"),
      SHA3_256_DIGEST_LENGTH);

  sha3_256(
      (uint8_t *)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
      digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "41c0dba2a9d6240849100376a8235e2c82e1b9998a999e21db32dd97496d3376"),
      SHA3_256_DIGEST_LENGTH);

  sha3_256((uint8_t *)"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18"),
      SHA3_256_DIGEST_LENGTH);
}
END_TEST

// test vectors from http://www.di-mgt.com.au/sha_testvectors.html
START_TEST(test_sha3_512) {
  uint8_t digest[SHA3_512_DIGEST_LENGTH];

  sha3_512((uint8_t *)"", 0, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2"
          "123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"),
      SHA3_512_DIGEST_LENGTH);

  sha3_512((uint8_t *)"abc", 3, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e1"
          "16e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0"),
      SHA3_512_DIGEST_LENGTH);

  sha3_512(
      (uint8_t *)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
      digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "04a371e84ecfb5b8b77cb48610fca8182dd457ce6f326a0fd3d7ec2f1e91636dee69"
          "1fbe0c985302ba1b0d8dc78c086346b533b49c030d99a27daf1139d6e75e"),
      SHA3_512_DIGEST_LENGTH);

  sha3_512((uint8_t *)"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112, digest);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3"
          "261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185"),
      SHA3_512_DIGEST_LENGTH);
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/NemProject/nem-test-vectors/master/0.test-sha3-256.dat
START_TEST(test_keccak_256) {
  static const struct {
    const char *hash;
    size_t length;
    const char *data;
  } tests[] = {
      {
          "4e9e79ab7434f6c7401fb3305d55052ee829b9e46d5d05d43b59fefb32e9a619",
          293,
          "a6151d4904e18ec288243028ceda30556e6c42096af7150d6a7232ca5dba52bd2192"
          "e23daa5fa2bea3d4bd95efa2389cd193fcd3376e70a5c097b32c1c62c80af9d71021"
          "1545f7cdddf63747420281d64529477c61e721273cfd78f8890abb4070e97baa52ac"
          "8ff61c26d195fc54c077def7a3f6f79b36e046c1a83ce9674ba1983ec2fb58947de6"
          "16dd797d6499b0385d5e8a213db9ad5078a8e0c940ff0cb6bf92357ea5609f778c3d"
          "1fb1e7e36c35db873361e2be5c125ea7148eff4a035b0cce880a41190b2e22924ad9"
          "d1b82433d9c023924f2311315f07b88bfd42850047bf3be785c4ce11c09d7e02065d"
          "30f6324365f93c5e7e423a07d754eb314b5fe9db4614275be4be26af017abdc9c338"
          "d01368226fe9af1fb1f815e7317bdbb30a0f36dc69",
      },
      {
          "c1268babc42d00c3463dc388222100f7e525a74a64665c39f112f788ddb5da42",
          376,
          "9db801077952c2324e0044a4994edfb09b3edfcf669bfdd029f4bf42d5b0eab3056b"
          "0bf82708ca7bfadba43c9de806b10a19d0f00c2351ef1086b6b108f306e035c6b61b"
          "2e70fd7087ba848601c8a3f626a66666423717ef305a1068bfa3a1f7ffc1e5a78cb6"
          "182ffc8a577ca2a821630bf900d0fbba848bdf94b77c5946771b6c3f8c02269bc772"
          "ca56098f724536d96be68c284ee1d81697989d40029b8ea63ac1fd85f8b3cae8b194"
          "f6834ff65a5858f9498ddbb467995eb2d49cdfc6c05d92038c6e9aaeee85f8222b37"
          "84165f12a2c3df4c7a142e26dddfd831d07e22dfecc0eded48a69c8a9e1b97f1a4e0"
          "efcd4edd310de0edf82af38a6e4d5ab2a19da586e61210d4f75e7a07e2201f9c8154"
          "ca52a414a70d2eb2ac1c5b9a2900b4d871f62fa56f70d03b3dd3704bd644808c45a1"
          "3231918ea884645b8ec054e8bab2935a66811fe590ddc119ae901dfeb54fc2a87c1e"
          "0a236778baab2fa8843709c6676d3c1888ba19d75ec52d73a7d035c143179b938237"
          "26b7",
      },
      {
          "e83b50e8c83cb676a7dd64c055f53e5110d5a4c62245ceb8f683fd87b2b3ec77",
          166,
          "c070a957550b7b34113ee6543a1918d96d241f27123425db7f7b9004e047ffbe0561"
          "2e7fa8c54b23c83ea427e625e97b7a28b09a70bf6d91e478eeed01d7907931c29ea8"
          "6e70f2cdcfb243ccf7f24a1619abf4b5b9e6f75cbf63fc02baf4a820a9790a6b053e"
          "50fd94e0ed57037cfc2bab4d95472b97d3c25f434f1cc0b1ede5ba7f15907a42a223"
          "933e5e2dfcb518c3531975268c326d60fa911fbb7997eee3ba87656c4fe7",
      },
      {
          "8ebd2c9d4ff00e285a9b6b140bfc3cef672016f0098100e1f6f250220af7ce1a",
          224,
          "b502fbdce4045e49e147eff5463d4b3f37f43461518868368e2c78008c84c2db79d1"
          "2b58107034f67e7d0abfee67add0342dd23dce623f26b9156def87b1d7ac15a6e073"
          "01f832610fe869ada13a2b0e3d60aa6bb81bc04487e2e800f5106b0402ee0331df74"
          "5e021b5ea5e32faf1c7fc1322041d221a54191c0af19948b5f34411937182e30d5cd"
          "39b5a6c959d77d92d21bb1de51f1b3411cb6eec00600429916227fb62d2c88e69576"
          "f4ac8e5efcde8efa512cc80ce7fb0dfaa6c74d26e898cefe9d4f7dce232a69f2a6a9"
          "477aa08366efcdfca117c89cb79eba15a23755e0",
      },
      {
          "db3961fdddd0c314289efed5d57363459a6700a7bd015e7a03d3e1d03f046401",
          262,
          "22e203a98ba2c43d8bc3658f0a48a35766df356d6a5e98b0c7222d16d85a00b31720"
          "7d4aef3fc7cabb67b9d8f5838de0b733e1fd59c31f0667e53286972d7090421ad90d"
          "54db2ea40047d0d1700c86f53dbf48da532396307e68edad877dcae481848801b0a5"
          "db44dbdba6fc7c63b5cd15281d57ca9e6be96f530b209b59d6127ad2bd8750f3f807"
          "98f62521f0d5b42633c2f5a9aaefbed38779b7aded2338d66850b0bb0e33c48e040c"
          "99f2dcee7a7ebb3d7416e1c5bf038c19d09682dab67c96dbbfad472e45980aa27d1b"
          "301b15f7de4d4f549bad2501931c9d4f1a3b1692dcb4b1b834ddd4a636126702307d"
          "daeec61841693b21887d56e76cc2069dafb557fd6682160f",
      },
      {
          "25dd3acacd6bf688c0eace8d33eb7cc550271969142deb769a05b4012f7bb722",
          122,
          "99e7f6e0ed46ec866c43a1ab494998d47e9309a79fde2a629eb63bb2160a5ffd0f22"
          "06de9c32dd20e9b23e57ab7422cf82971cc2873ec0e173fe93281c7b33e1c76ac792"
          "23a6f435f230bdd30260c00d00986c72a399d3ba70f6e783d834bbf8a6127844def5"
          "59b8b6db742b2cfd715f7ff29e7b42bf7d567beb",
      },
      {
          "00d747c9045c093484290afc161437f11c2ddf5f8a9fc2acae9c7ef5fcf511e5",
          440,
          "50c392f97f8788377f0ab2e2aab196cb017ad157c6f9d022673d39072cc198b06622"
          "a5cbd269d1516089fa59e28c3373a92bd54b2ebf1a79811c7e40fdd7bce200e80983"
          "fda6e77fc44c44c1b5f87e01cef2f41e1141103f73364e9c2f25a4597e6517ef31b3"
          "16300b770c69595e0fa6d011df1566a8676a88c7698562273bbfa217cc69d4b5c89a"
          "8907b902f7dc14481fefc7da4a810c15a60f5641aae854d2f8cc50cbc393015560f0"
          "1c94e0d0c075dbcb150ad6eba29dc747919edcaf0231dba3eb3f2b1a87e136a1f0fd"
          "4b3d8ee61bad2729e9526a32884f7bcfa41e361add1b4c51dc81463528372b4ec321"
          "244de0c541ba00df22b8773cdf4cf898510c867829fa6b4ff11f9627338b9686d905"
          "cb7bcdf085080ab842146e0035c808be58cce97827d8926a98bd1ff7c529be3bc14f"
          "68c91b2ca4d2f6fc748f56bcf14853b7f8b9aa6d388f0fd82f53fdc4bacf9d9ba10a"
          "165f404cf427e199f51bf6773b7c82531e17933f6d8b8d9181e22f8921a2dbb20fc7"
          "c8023a87e716e245017c399d0942934f5e085219b3f8d26a196bf8b239438b8e561c"
          "28a61ff08872ecb052c5fcb19e2fdbc09565924a50ebee1461c4b414219d4257",
      },
      {
          "dadcde7c3603ef419d319ba3d50cf00ad57f3e81566fd11b9b6f461cbb9dcb0f",
          338,
          "18e1df97abccc91e07dc7b7ffab5ee8919d5610721453176aa2089fb96d9a477e147"
          "6f507fa1129f04304e960e8017ff41246cacc0153055fc4b1dc6168a74067ebb077c"
          "b5aa80a9df6e8b5b821e906531159668c4c164b9e511d8724aedbe17c1f41da88094"
          "17d3c30b79ea5a2e3c961f6bac5436d9af6be24a36eebcb17863fed82c0eb8962339"
          "eb612d58659dddd2ea06a120b3a2d8a17050be2de367db25a5bef4290c209bdb4c16"
          "c4df5a1fe1ead635169a1c35f0a56bc07bcf6ef0e4c2d8573ed7a3b58030fa268c1a"
          "5974b097288f01f34d5a1087946410688016882c6c7621aad680d9a25c7a3e5dbcbb"
          "07ffdb7243b91031c08a121b40785e96b7ee46770c760f84aca8f36b7c7da64d25c8"
          "f73b4d88ff3acb7eeefc0b75144dffea66d2d1f6b42b905b61929ab3f38538393ba5"
          "ca9d3c62c61f46fa63789cac14e4e1d8722bf03cceef6e3de91f783b0072616c",
      },
      {
          "d184e84a2507fc0f187b640dd5b849a366c0383d9cbdbc6fa30904f054111255",
          141,
          "13b8df9c1bcfddd0aa39b3055f52e2bc36562b6677535994b173f07041d141699db4"
          "2589d6091ef0e71b645b41ab57577f58c98da966562d24823158f8e1d43b54edea4e"
          "61dd66fe8c59ad8405f5a0d9a3eb509a77ae3d8ae4adf926fd3d8d31c3dcccfc1408"
          "14541010937024cc554e1daaee1b333a66316e7fbebb07ac8dfb134a918b9090b141"
          "68012c4824",
      },
      {
          "20c19635364a00b151d0168fe5ae03bac6dd7d06030475b40d2e8c577a192f53",
          84,
          "e1e96da4b7d8dcc2b316006503a990ea26a5b200cb7a7edfc14f5ce827f06d8d232e"
          "c95b1acdc1422ffc16da11d258f0c7b378f026d64c74b2fb41df8bfd3cd30066caec"
          "dc6f76c8163de9309d9fd0cf33d54a29",
      },
      {
          "86cc2c428d469e43fb4ee8d38dffbf5128d20d1659dbc45edf4a855399ca730e",
          319,
          "30391840ad14e66c53e1a5aaa03989ff059940b60c44c3b21295a93d023f2e6c7cdc"
          "f60208b7d87a7605fb5cee94630d94cad90bc6955328357fa37fea47c09f9cee759c"
          "31537187321c7d572e3554eeb90f441a9494575454dfbf8cfd86128da15de9418821"
          "ca158856eb84ff6a29a2c8380711e9e6d4955388374fcd3c1ca45b49e0679fc7157f"
          "96bc6e4f86ce20a89c12d4449b1ca7056e0b7296fc646f68f6ddbfa6a48e384d63ab"
          "68bc75fd69a2add59b8e41c4a0f753935df9a703d7df82a430798b0a67710a780614"
          "85a9d15de16f154582082459b4462485ce8a82d35ac6b9498ae40df3a23d5f00e0e8"
          "6661cb02c52f677fd374c32969ec63028b5dd2c1d4bce67a6d9f79ba5e7eeb5a2763"
          "dc9fe2a05aa2ebaad36aaec2541e343a677fb4e6b6a180eff33c93744a4624f6a79f"
          "054c6c9e9c5b6928dbe7ba5fca",
      },
      {
          "e80eee72a76e6957f7cb7f68c41b92f0ad9aac6e58aa8fc272c1e7364af11c70",
          108,
          "3c210ed15889ae938781d2cebd49d4a8007f163ffba1f7669bccdccf6ad5a1418299"
          "d5f4348f5cd03b0ba9e6999ab154e46836c3546feb395d17bcc60f23d7ba0e8efe6a"
          "a616c00b6bf552fe1cb5e28e3e7bc39dfc20c63ae3901035e91ddd110e43fe59ed74"
          "4beeedb6bc1e",
      },
      {
          "f971bbae97dd8a034835269fb246867de358a889de6de13672e771d6fb4c89b7",
          468,
          "64e9a3a99c021df8bea59368cfe1cd3b0a4aca33ffcd5cf6028d9307c0b904b8037d"
          "056a3c12803f196f74c4d360a3132452d365922b1157e5b0d76f91fb94bebfdcb4d5"
          "0fa23ed5be3d3c5712219e8666debc8abcd5e6c69a542761a6cbbd1b3c0f05248752"
          "04b64d2788465f90cb19b6f6da9f8bec6d6e684196e713549ec83e47cbaeff77838a"
          "c4936b312562e2de17c970449d49d214ec2597c6d4f642e6c94a613a0c53285abccd"
          "7794a3d72241808594fb4e6e4d5d2c310ef1cdcbfd34805ca2408f554797a6cfd49d"
          "0f25ed8927f206acb127e6436e1234902489ec2e7f3058e26c0eba80341bc7ad0da8"
          "b8bd80bd1b43c9099269e3f8b68445c69b79d8cf5693d4a0d47a44f9e9114dbb3399"
          "2d2ea9d3b5b86e4ea57a44a638848de4ac365bb6bb7855305ade62b07ebf0954d70b"
          "7c2fb5e6fcc154c7a36fb1756df5f20a84d35696627ebf22d44f40f805c0878ad110"
          "bc17dcd66821084ca87902e05bc0afa61161086956b85a6ea900d35c7784d4c361a4"
          "3fe294e267d5762408be58962cdb4f45a9c0efd7d2335916df3acb98ccfbcf5ee395"
          "30540e5f3d3c5f3326a9a536d7bfa37aae2b143e2499b81bf0670e3a418c26c7dc82"
          "b293d9bd182dd6435670514237df88d8286e19ce93e0a0db2790",
      },
      {
          "b97fd51f4e4eaa40c7a2853010fc46be5be2f43b9520ea0c533b68f728c978a2",
          214,
          "ced3a43193caceb269d2517f4ecb892bb7d57d7201869e28e669b0b17d1c44d286e0"
          "2734e2210ea9009565832975cc6303b9b6008fe1165b99ae5f1b29962ef042ebad8b"
          "676d7433ed2fe0d0d6f4f32b2cb4c519da61552328c2caea799bb2fd907308173a1c"
          "d2b798fb0df7d2eaf2ff0be733af74f42889e211843fc80b09952ae7eb246725b91d"
          "31c1f7a5503fdf3bc9c269c76519cf2dc3225e862436b587bb74adbad88c773056cf"
          "ea3bddb1f6533c01125eeae0986e5c817359912c9d0472bf8320b824ee097f82a8e0"
          "5b9f53a5be7d153225de",
      },
      {
          "f0fecf766e4f7522568b3be71843cce3e5fcb10ea96b1a236c8c0a71c9ad55c9",
          159,
          "8aca4de41275f5c4102f66266d70cff1a2d56f58df8d12061c64cb6cd8f616a5bf19"
          "c2bb3c91585c695326f561a2d0eb4eef2e202d82dcc9089e4bee82b62a199a11963c"
          "d08987d3abd5914def2cdd3c1e4748d46b654f338e3959121e869c18d5327e88090d"
          "0ba0ac6762a2b14514cc505af7499f1a22f421dbe978494f9ffe1e88f1c59228f21d"
          "a5bc9fcc911d022300a443bca17258bdd6cfbbf52fde61",
      },
      {
          "5c4f16043c0084bf98499fc7dc4d674ce9c730b7135210acdbf5e41d3dcf317b",
          87,
          "01bbc193d0ee2396a7d8267ad63f18149667b31d8f7f48c8bb0c634755febc9ef1a7"
          "9e93c475f6cd137ee37d4dc243ea2fdcdc0d098844af2208337b7bbf6930e39e74e2"
          "3952ac1a19b4d38b83810a10c3b069e4fafb06",
      },
      {
          "14b61fc981f7d9449b7b6a2d57eb48cc8f7896f4dced2005291b2a2f38cb4a63",
          358,
          "cbc1709a531438d5ead32cea20a9e4ddc0101ec555ab42b2e378145013cc05a97b9e"
          "2c43c89bfa63ae5e9e9ce1fc022035c6b68f0a906ee1f53396d9dbe41cb2bc4bfeb1"
          "44b005b0f40e0fec872d9c4aca9929ba3cbacd84c58ab43c26f10d345a24692bbd55"
          "a76506876768e8e32a461bf160cee953da88920d36ad4aff6eea7126aa6f44a7a6fc"
          "e770ce43f0f90a20590bdaad3ffcda30ca8e3700f832c62caa5df030c16bcf74aff4"
          "92466f781eb69863a80663535fc154abd7cfdd02eef1019221cf608b9780f807e507"
          "fbbf559b1dfe4e971b4d08fe45263a3c697ba90f9f71bec97e12438b4b12f6a84ab6"
          "6872b888097089d76c9c2502d9ed2eece6bef8eee1d439782e218f5cc75d38f98860"
          "12cdcb4bbe6caf812e97c5a336bcceae38b1109e3243a291ce23d097aaee7d9a711d"
          "e6886749a7a6d15d7e7cbc4a51b1b4da9fcf139e4a6fd7dc0bc017db624b17fc9b8f"
          "847592ed42467c25ad9fe96acbf20c0ffd18",
      },
      {
          "47ec7f3a362becbb110867995a0f066a66152603c4d433f11bf51870c67e2864",
          354,
          "0636983353c9ea3f75256ed00b70e8b7cfc6f4e4c0ba3aa9a8da59b6e6ad9dfb5bc2"
          "c49f48cc0b4237f87dedf34b888e54ecebf1d435bcd4aab72eb4ce39e5262fb68c6f"
          "86423dac123bf59e903989eda7df4a982822d0831521403cedcfe9a5bbea648bb2e7"
          "ef8cd81442ea5abe468b3ee8b06376ef8099447255c2fdc1b73af37fe0e0b852ffbc"
          "9339868db756680db99e6e9837dbd28c39a69f229044ad7ec772524a6e01f679d25f"
          "dc2e736a2418e5dfd7c2ab1348d0f821b777c975244c6cfc2fca5c36ccae7cf1d07b"
          "190a9d17a088a1276bd096250b92f53b29b6ef88ef69d744b56fb2ec5078cc0b68a9"
          "106943ef242b466097b9e29df11eb5cb0c06c29d7917410ba1097215d6aa4dafd90a"
          "dff0c3e7221b9e8832613bd9aca8bcc6b2aa7b43acedcbc11aee1b5ba56f77a210be"
          "7cf3485ee813e1126c3eeccd8419bbf22c412cad32cc0fc7a73aca4e379651caac3d"
          "13d6cf5ca05508fd2d96f3ad94e7",
      },
      {
          "73778e7f1943646a89d3c78909e0afbe584071ba5230546a39cd73e44e36d78a",
          91,
          "6217504a26b3395855eab6ddeb79f2e3490d74b80eff343721150ee0c1c02b071867"
          "43589f93c22a03dc5ed29fb5bf592de0a089763e83e5b95f9dd524d66c8da3e04c18"
          "14e65e68b2810c1b517648aabc266ad62896c51864a7f4",
      },
      {
          "35ef6868e750cf0c1d5285992c231d93ec644670fb79cf85324067a9f77fde78",
          185,
          "0118b7fb15f927a977e0b330b4fa351aeeec299d6ba090eb16e5114fc4a6749e5915"
          "434a123c112697390c96ea2c26dc613eb5c75f5ecfb6c419317426367e34da0ddc6d"
          "7b7612cefa70a22fea0025f5186593b22449dab71f90a49f7de7352e54e0c0bd8837"
          "e661ca2127c3313a7268cafdd5ccfbf3bdd7c974b0e7551a2d96766579ef8d2e1f37"
          "6af74cd1ab62162fc2dc61a8b7ed4163c1caccf20ed73e284da2ed257ec974eee96b"
          "502acb2c60a04886465e44debb0317",
      },
  };

  uint8_t hash[SHA3_256_DIGEST_LENGTH];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    keccak_256(fromhex(tests[i].data), tests[i].length, hash);
    ck_assert_mem_eq(hash, fromhex(tests[i].hash), SHA3_256_DIGEST_LENGTH);
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/monero-project/monero/master/tests/hash/tests-extra-blake.txt
START_TEST(test_blake256) {
  struct {
    const char *hash;
    const char *data;
  } tests[] = {
      {
          "716f6e863f744b9ac22c97ec7b76ea5f5908bc5b2f67c61510bfc4751384ea7a",
          "",
      },
      {
          "e104256a2bc501f459d03fac96b9014f593e22d30f4de525fa680c3aa189eb4f",
          "cc",
      },
      {
          "8f341148be7e354fdf38b693d8c6b4e0bd57301a734f6fd35cd85b8491c3ddcd",
          "41fb",
      },
      {
          "bc334d1069099f10c601883ac6f3e7e9787c6aa53171f76a21923cc5ad3ab937",
          "1f877c",
      },
      {
          "b672a16f53982bab1e77685b71c0a5f6703ffd46a1c834be69f614bd128d658e",
          "c1ecfdfc",
      },
      {
          "d9134b2899057a7d8d320cc99e3e116982bc99d3c69d260a7f1ed3da8be68d99",
          "21f134ac57",
      },
      {
          "637923bd29a35aa3ecbbd2a50549fc32c14cf0fdcaf41c3194dd7414fd224815",
          "c6f50bb74e29",
      },
      {
          "70c092fd5c8c21e9ef4bbc82a5c7819e262a530a748caf285ff0cba891954f1e",
          "119713cc83eeef",
      },
      {
          "fdf092993edbb7a0dc7ca67f04051bbd14481639da0808947aff8bfab5abed4b",
          "4a4f202484512526",
      },
      {
          "6f6fc234bf35beae1a366c44c520c59ad5aa70351b5f5085e21e1fe2bfcee709",
          "1f66ab4185ed9b6375",
      },
      {
          "4fdaf89e2a0e78c000061b59455e0ea93a4445b440e7562c8f0cfa165c93de2e",
          "eed7422227613b6f53c9",
      },
      {
          "d6b780eee9c811f664393dc2c58b5a68c92b3c9fe9ceb70371d33ece63b5787e",
          "eaeed5cdffd89dece455f1",
      },
      {
          "d0015071d3e7ed048c764850d76406eceae52b8e2e6e5a2c3aa92ae880485b34",
          "5be43c90f22902e4fe8ed2d3",
      },
      {
          "9b0207902f9932f7a85c24722e93e31f6ed2c75c406509aa0f2f6d1cab046ce4",
          "a746273228122f381c3b46e4f1",
      },
      {
          "258020d5b04a814f2b72c1c661e1f5a5c395d9799e5eee8b8519cf7300e90cb1",
          "3c5871cd619c69a63b540eb5a625",
      },
      {
          "4adae3b55baa907fefc253365fdd99d8398befd0551ed6bf9a2a2784d3c304d1",
          "fa22874bcc068879e8ef11a69f0722",
      },
      {
          "6dd10d772f8d5b4a96c3c5d30878cd9a1073fa835bfe6d2b924fa64a1fab1711",
          "52a608ab21ccdd8a4457a57ede782176",
      },
      {
          "0b8741ddf2259d3af2901eb1ae354f22836442c965556f5c1eb89501191cb46a",
          "82e192e4043ddcd12ecf52969d0f807eed",
      },
      {
          "f48a754ca8193a82643150ab94038b5dd170b4ebd1e0751b78cfb0a98fa5076a",
          "75683dcb556140c522543bb6e9098b21a21e",
      },
      {
          "5698409ab856b74d9fa5e9b259dfa46001f89041752da424e56e491577b88c86",
          "06e4efe45035e61faaf4287b4d8d1f12ca97e5",
      },
  };

  uint8_t hash[BLAKE256_DIGEST_LENGTH];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    blake256(fromhex(tests[i].data), i, hash);
    ck_assert_mem_eq(hash, fromhex(tests[i].hash), BLAKE256_DIGEST_LENGTH);
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/BLAKE2/BLAKE2/master/testvectors/blake2b-kat.txt
START_TEST(test_blake2b) {
  uint8_t key[BLAKE2B_KEY_LENGTH];
  memcpy(key,
         fromhex(
             "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2"
             "02122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"),
         BLAKE2B_KEY_LENGTH);

  uint8_t digest[BLAKE2B_DIGEST_LENGTH];

  blake2b_Key((uint8_t *)"", 0, key, BLAKE2B_KEY_LENGTH, digest,
              BLAKE2B_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e9"
          "96e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568"),
      BLAKE2B_DIGEST_LENGTH);

  blake2b_Key(fromhex("000102"), 3, key, BLAKE2B_KEY_LENGTH, digest,
              BLAKE2B_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "33d0825dddf7ada99b0e7e307104ad07ca9cfd9692214f1561356315e784f3e5a17e"
          "364ae9dbb14cb2036df932b77f4b292761365fb328de7afdc6d8998f5fc1"),
      BLAKE2B_DIGEST_LENGTH);

  blake2b_Key(
      fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
              "202122232425262728292a2b2c2d2e2f3031323334353637"),
      56, key, BLAKE2B_KEY_LENGTH, digest, BLAKE2B_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "f8f3726ac5a26cc80132493a6fedcb0e60760c09cfc84cad178175986819665e7684"
          "2d7b9fedf76dddebf5d3f56faaad4477587af21606d396ae570d8e719af2"),
      BLAKE2B_DIGEST_LENGTH);

  blake2b_Key(
      fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
              "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
              "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
              "606162636465666768696a6b6c6d6e6f"),
      112, key, BLAKE2B_KEY_LENGTH, digest, BLAKE2B_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "227e3aed8d2cb10b918fcb04f9de3e6d0a57e08476d93759cd7b2ed54a1cbf0239c5"
          "28fb04bbf288253e601d3bc38b21794afef90b17094a182cac557745e75f"),
      BLAKE2B_DIGEST_LENGTH);
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/BLAKE2/BLAKE2/master/testvectors/blake2s-kat.txt
START_TEST(test_blake2s) {
  uint8_t key[BLAKE2S_KEY_LENGTH];
  memcpy(
      key,
      fromhex(
          "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
      BLAKE2S_KEY_LENGTH);

  uint8_t digest[BLAKE2S_DIGEST_LENGTH];

  blake2s_Key((uint8_t *)"", 0, key, BLAKE2S_KEY_LENGTH, digest,
              BLAKE2S_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "48a8997da407876b3d79c0d92325ad3b89cbb754d86ab71aee047ad345fd2c49"),
      BLAKE2S_DIGEST_LENGTH);

  blake2s_Key(fromhex("000102"), 3, key, BLAKE2S_KEY_LENGTH, digest,
              BLAKE2S_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "1d220dbe2ee134661fdf6d9e74b41704710556f2f6e5a091b227697445dbea6b"),
      BLAKE2S_DIGEST_LENGTH);

  blake2s_Key(
      fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
              "202122232425262728292a2b2c2d2e2f3031323334353637"),
      56, key, BLAKE2S_KEY_LENGTH, digest, BLAKE2S_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "2966b3cfae1e44ea996dc5d686cf25fa053fb6f67201b9e46eade85d0ad6b806"),
      BLAKE2S_DIGEST_LENGTH);

  blake2s_Key(
      fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
              "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
              "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
              "606162636465666768696a6b6c6d6e6f"),
      112, key, BLAKE2S_KEY_LENGTH, digest, BLAKE2S_DIGEST_LENGTH);
  ck_assert_mem_eq(
      digest,
      fromhex(
          "90a83585717b75f0e9b725e055eeeeb9e7a028ea7e6cbc07b20917ec0363e38c"),
      BLAKE2S_DIGEST_LENGTH);
}
END_TEST

START_TEST(test_pbkdf2_hmac_sha256) {
  uint8_t k[64];

  // test vectors from
  // https://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors
  pbkdf2_hmac_sha256((const uint8_t *)"password", 8, (const uint8_t *)"salt", 4,
                     1, k, 32);
  ck_assert_mem_eq(
      k,
      fromhex(
          "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b"),
      32);

  pbkdf2_hmac_sha256((const uint8_t *)"password", 8, (const uint8_t *)"salt", 4,
                     2, k, 32);
  ck_assert_mem_eq(
      k,
      fromhex(
          "ae4d0c95af6b46d32d0adff928f06dd02a303f8ef3c251dfd6e2d85a95474c43"),
      32);

  pbkdf2_hmac_sha256((const uint8_t *)"password", 8, (const uint8_t *)"salt", 4,
                     4096, k, 32);
  ck_assert_mem_eq(
      k,
      fromhex(
          "c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a"),
      32);

  pbkdf2_hmac_sha256((const uint8_t *)"passwordPASSWORDpassword", 3 * 8,
                     (const uint8_t *)"saltSALTsaltSALTsaltSALTsaltSALTsalt",
                     9 * 4, 4096, k, 40);
  ck_assert_mem_eq(k,
                   fromhex("348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c4"
                           "e2a1fb8dd53e1c635518c7dac47e9"),
                   40);

  pbkdf2_hmac_sha256((const uint8_t *)"pass\x00word", 9,
                     (const uint8_t *)"sa\x00lt", 5, 4096, k, 16);
  ck_assert_mem_eq(k, fromhex("89b69d0516f829893c696226650a8687"), 16);

  // test vector from https://tools.ietf.org/html/rfc7914.html#section-11
  pbkdf2_hmac_sha256((const uint8_t *)"passwd", 6, (const uint8_t *)"salt", 4,
                     1, k, 64);
  ck_assert_mem_eq(
      k,
      fromhex(
          "55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca"
          "9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783"),
      64);
}
END_TEST

// test vectors from
// http://stackoverflow.com/questions/15593184/pbkdf2-hmac-sha-512-test-vectors
START_TEST(test_pbkdf2_hmac_sha512) {
  uint8_t k[64];

  pbkdf2_hmac_sha512((uint8_t *)"password", 8, (const uint8_t *)"salt", 4, 1, k,
                     64);
  ck_assert_mem_eq(
      k,
      fromhex(
          "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d"
          "470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce"),
      64);

  pbkdf2_hmac_sha512((uint8_t *)"password", 8, (const uint8_t *)"salt", 4, 2, k,
                     64);
  ck_assert_mem_eq(
      k,
      fromhex(
          "e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76c"
          "ab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e"),
      64);

  pbkdf2_hmac_sha512((uint8_t *)"password", 8, (const uint8_t *)"salt", 4, 4096,
                     k, 64);
  ck_assert_mem_eq(
      k,
      fromhex(
          "d197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5143f"
          "30602641b3d55cd335988cb36b84376060ecd532e039b742a239434af2d5"),
      64);

  pbkdf2_hmac_sha512((uint8_t *)"passwordPASSWORDpassword", 3 * 8,
                     (const uint8_t *)"saltSALTsaltSALTsaltSALTsaltSALTsalt",
                     9 * 4, 4096, k, 64);
  ck_assert_mem_eq(
      k,
      fromhex(
          "8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868c005174dc4ee71115b"
          "59f9e60cd9532fa33e0f75aefe30225c583a186cd82bd4daea9724a3d3b8"),
      64);
}
END_TEST

START_TEST(test_mnemonic) {
  static const char *vectors[] = {
      "00000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon about",
      "c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a698"
      "7599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "yellow",
      "2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe12"
      "96106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607",
      "80808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage above",
      "d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12"
      "eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8",
      "ffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
      "ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a1333257291"
      "7f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069",
      "000000000000000000000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon agent",
      "035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a"
      "565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal will",
      "f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c39"
      "2d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd",
      "808080808080808080808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter always",
      "107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ff"
      "b796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65",
      "ffffffffffffffffffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "when",
      "0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b433"
      "48d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528",
      "0000000000000000000000000000000000000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon art",
      "bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d"
      "73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal winner thank year wave sausage "
      "worth title",
      "bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad"
      "717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87",
      "8080808080808080808080808080808080808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter advice cage absurd "
      "amount doctor acoustic bless",
      "c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af"
      "0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f",
      "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "zoo zoo zoo zoo zoo vote",
      "dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a"
      "5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad",
      "77c2b00716cec7213839159e404db50d",
      "jelly better achieve collect unaware mountain thought cargo oxygen act "
      "hood bridge",
      "b5b6d0127db1a9d2226af0c3346031d77af31e918dba64287a1b44b8ebf63cdd52676f67"
      "2a290aae502472cf2d602c051f3e6f18055e84e4c43897fc4e51a6ff",
      "b63a9c59a6e641f288ebc103017f1da9f8290b3da6bdef7b",
      "renew stay biology evidence goat welcome casual join adapt armor "
      "shuffle fault little machine walk stumble urge swap",
      "9248d83e06f4cd98debf5b6f010542760df925ce46cf38a1bdb4e4de7d21f5c39366941c"
      "69e1bdbf2966e0f6e6dbece898a0e2f0a4c2b3e640953dfe8b7bbdc5",
      "3e141609b97933b66a060dcddc71fad1d91677db872031e85f4c015c5e7e8982",
      "dignity pass list indicate nasty swamp pool script soccer toe leaf "
      "photo multiply desk host tomato cradle drill spread actor shine dismiss "
      "champion exotic",
      "ff7f3184df8696d8bef94b6c03114dbee0ef89ff938712301d27ed8336ca89ef9635da20"
      "af07d4175f2bf5f3de130f39c9d9e8dd0472489c19b1a020a940da67",
      "0460ef47585604c5660618db2e6a7e7f",
      "afford alter spike radar gate glance object seek swamp infant panel "
      "yellow",
      "65f93a9f36b6c85cbe634ffc1f99f2b82cbb10b31edc7f087b4f6cb9e976e9faf76ff41f"
      "8f27c99afdf38f7a303ba1136ee48a4c1e7fcd3dba7aa876113a36e4",
      "72f60ebac5dd8add8d2a25a797102c3ce21bc029c200076f",
      "indicate race push merry suffer human cruise dwarf pole review arch "
      "keep canvas theme poem divorce alter left",
      "3bbf9daa0dfad8229786ace5ddb4e00fa98a044ae4c4975ffd5e094dba9e0bb289349dbe"
      "2091761f30f382d4e35c4a670ee8ab50758d2c55881be69e327117ba",
      "2c85efc7f24ee4573d2b81a6ec66cee209b2dcbd09d8eddc51e0215b0b68e416",
      "clutch control vehicle tonight unusual clog visa ice plunge glimpse "
      "recipe series open hour vintage deposit universe tip job dress radar "
      "refuse motion taste",
      "fe908f96f46668b2d5b37d82f558c77ed0d69dd0e7e043a5b0511c48c2f1064694a956f8"
      "6360c93dd04052a8899497ce9e985ebe0c8c52b955e6ae86d4ff4449",
      "eaebabb2383351fd31d703840b32e9e2",
      "turtle front uncle idea crush write shrug there lottery flower risk "
      "shell",
      "bdfb76a0759f301b0b899a1e3985227e53b3f51e67e3f2a65363caedf3e32fde42a66c40"
      "4f18d7b05818c95ef3ca1e5146646856c461c073169467511680876c",
      "7ac45cfe7722ee6c7ba84fbc2d5bd61b45cb2fe5eb65aa78",
      "kiss carry display unusual confirm curtain upgrade antique rotate hello "
      "void custom frequent obey nut hole price segment",
      "ed56ff6c833c07982eb7119a8f48fd363c4a9b1601cd2de736b01045c5eb8ab4f57b0794"
      "03485d1c4924f0790dc10a971763337cb9f9c62226f64fff26397c79",
      "4fa1a8bc3e6d80ee1316050e862c1812031493212b7ec3f3bb1b08f168cabeef",
      "exile ask congress lamp submit jacket era scheme attend cousin alcohol "
      "catch course end lucky hurt sentence oven short ball bird grab wing top",
      "095ee6f817b4c2cb30a5a797360a81a40ab0f9a4e25ecd672a3f58a0b5ba0687c096a6b1"
      "4d2c0deb3bdefce4f61d01ae07417d502429352e27695163f7447a8c",
      "18ab19a9f54a9274f03e5209a2ac8a91",
      "board flee heavy tunnel powder denial science ski answer betray cargo "
      "cat",
      "6eff1bb21562918509c73cb990260db07c0ce34ff0e3cc4a8cb3276129fbcb300bddfe00"
      "5831350efd633909f476c45c88253276d9fd0df6ef48609e8bb7dca8",
      "18a2e1d81b8ecfb2a333adcb0c17a5b9eb76cc5d05db91a4",
      "board blade invite damage undo sun mimic interest slam gaze truly "
      "inherit resist great inject rocket museum chief",
      "f84521c777a13b61564234bf8f8b62b3afce27fc4062b51bb5e62bdfecb23864ee6ecf07"
      "c1d5a97c0834307c5c852d8ceb88e7c97923c0a3b496bedd4e5f88a9",
      "15da872c95a13dd738fbf50e427583ad61f18fd99f628c417a61cf8343c90419",
      "beyond stage sleep clip because twist token leaf atom beauty genius "
      "food business side grid unable middle armed observe pair crouch tonight "
      "away coconut",
      "b15509eaa2d09d3efd3e006ef42151b30367dc6e3aa5e44caba3fe4d3e352e65101fbdb8"
      "6a96776b91946ff06f8eac594dc6ee1d3e82a42dfe1b40fef6bcc3fd",
      0,
      0,
      0,
  };

  const char **a, **b, **c, *m;
  uint8_t seed[64];

  a = vectors;
  b = vectors + 1;
  c = vectors + 2;
  while (*a && *b && *c) {
    m = mnemonic_from_data(fromhex(*a), strlen(*a) / 2);
    ck_assert_str_eq(m, *b);
    mnemonic_to_seed(m, "TREZOR", seed, 0);
    ck_assert_mem_eq(seed, fromhex(*c), strlen(*c) / 2);
#if USE_BIP39_CACHE
    // try second time to check whether caching results work
    mnemonic_to_seed(m, "TREZOR", seed, 0);
    ck_assert_mem_eq(seed, fromhex(*c), strlen(*c) / 2);
#endif
    a += 3;
    b += 3;
    c += 3;
  }
}
END_TEST

START_TEST(test_mnemonic_check) {
  static const char *vectors_ok[] = {
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon about",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "yellow",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage above",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon agent",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal will",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter always",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "when",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon art",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal winner thank year wave sausage "
      "worth title",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter advice cage absurd "
      "amount doctor acoustic bless",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "zoo zoo zoo zoo zoo vote",
      "jelly better achieve collect unaware mountain thought cargo oxygen act "
      "hood bridge",
      "renew stay biology evidence goat welcome casual join adapt armor "
      "shuffle fault little machine walk stumble urge swap",
      "dignity pass list indicate nasty swamp pool script soccer toe leaf "
      "photo multiply desk host tomato cradle drill spread actor shine dismiss "
      "champion exotic",
      "afford alter spike radar gate glance object seek swamp infant panel "
      "yellow",
      "indicate race push merry suffer human cruise dwarf pole review arch "
      "keep canvas theme poem divorce alter left",
      "clutch control vehicle tonight unusual clog visa ice plunge glimpse "
      "recipe series open hour vintage deposit universe tip job dress radar "
      "refuse motion taste",
      "turtle front uncle idea crush write shrug there lottery flower risk "
      "shell",
      "kiss carry display unusual confirm curtain upgrade antique rotate hello "
      "void custom frequent obey nut hole price segment",
      "exile ask congress lamp submit jacket era scheme attend cousin alcohol "
      "catch course end lucky hurt sentence oven short ball bird grab wing top",
      "board flee heavy tunnel powder denial science ski answer betray cargo "
      "cat",
      "board blade invite damage undo sun mimic interest slam gaze truly "
      "inherit resist great inject rocket museum chief",
      "beyond stage sleep clip because twist token leaf atom beauty genius "
      "food business side grid unable middle armed observe pair crouch tonight "
      "away coconut",
      0,
  };
  static const char *vectors_fail[] = {
      "above abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon about",
      "above winner thank year wave sausage worth useful legal winner thank "
      "yellow",
      "above advice cage absurd amount doctor acoustic avoid letter advice "
      "cage above",
      "above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
      "above abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon agent",
      "above winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal will",
      "above advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter always",
      "above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "when",
      "above abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon art",
      "above winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal winner thank year wave sausage "
      "worth title",
      "above advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter advice cage absurd "
      "amount doctor acoustic bless",
      "above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "zoo zoo zoo zoo zoo zoo vote",
      "above better achieve collect unaware mountain thought cargo oxygen act "
      "hood bridge",
      "above stay biology evidence goat welcome casual join adapt armor "
      "shuffle fault little machine walk stumble urge swap",
      "above pass list indicate nasty swamp pool script soccer toe leaf photo "
      "multiply desk host tomato cradle drill spread actor shine dismiss "
      "champion exotic",
      "above alter spike radar gate glance object seek swamp infant panel "
      "yellow",
      "above race push merry suffer human cruise dwarf pole review arch keep "
      "canvas theme poem divorce alter left",
      "above control vehicle tonight unusual clog visa ice plunge glimpse "
      "recipe series open hour vintage deposit universe tip job dress radar "
      "refuse motion taste",
      "above front uncle idea crush write shrug there lottery flower risk "
      "shell",
      "above carry display unusual confirm curtain upgrade antique rotate "
      "hello void custom frequent obey nut hole price segment",
      "above ask congress lamp submit jacket era scheme attend cousin alcohol "
      "catch course end lucky hurt sentence oven short ball bird grab wing top",
      "above flee heavy tunnel powder denial science ski answer betray cargo "
      "cat",
      "above blade invite damage undo sun mimic interest slam gaze truly "
      "inherit resist great inject rocket museum chief",
      "above stage sleep clip because twist token leaf atom beauty genius food "
      "business side grid unable middle armed observe pair crouch tonight away "
      "coconut",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon about",
      "winner thank year wave sausage worth useful legal winner thank yellow",
      "advice cage absurd amount doctor acoustic avoid letter advice cage "
      "above",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon agent",
      "winner thank year wave sausage worth useful legal winner thank year "
      "wave sausage worth useful legal will",
      "advice cage absurd amount doctor acoustic avoid letter advice cage "
      "absurd amount doctor acoustic avoid letter always",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon art",
      "winner thank year wave sausage worth useful legal winner thank year "
      "wave sausage worth useful legal winner thank year wave sausage worth "
      "title",
      "advice cage absurd amount doctor acoustic avoid letter advice cage "
      "absurd amount doctor acoustic avoid letter advice cage absurd amount "
      "doctor acoustic bless",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "zoo zoo zoo zoo vote",
      "better achieve collect unaware mountain thought cargo oxygen act hood "
      "bridge",
      "stay biology evidence goat welcome casual join adapt armor shuffle "
      "fault little machine walk stumble urge swap",
      "pass list indicate nasty swamp pool script soccer toe leaf photo "
      "multiply desk host tomato cradle drill spread actor shine dismiss "
      "champion exotic",
      "alter spike radar gate glance object seek swamp infant panel yellow",
      "race push merry suffer human cruise dwarf pole review arch keep canvas "
      "theme poem divorce alter left",
      "control vehicle tonight unusual clog visa ice plunge glimpse recipe "
      "series open hour vintage deposit universe tip job dress radar refuse "
      "motion taste",
      "front uncle idea crush write shrug there lottery flower risk shell",
      "carry display unusual confirm curtain upgrade antique rotate hello void "
      "custom frequent obey nut hole price segment",
      "ask congress lamp submit jacket era scheme attend cousin alcohol catch "
      "course end lucky hurt sentence oven short ball bird grab wing top",
      "flee heavy tunnel powder denial science ski answer betray cargo cat",
      "blade invite damage undo sun mimic interest slam gaze truly inherit "
      "resist great inject rocket museum chief",
      "stage sleep clip because twist token leaf atom beauty genius food "
      "business side grid unable middle armed observe pair crouch tonight away "
      "coconut",
      0,
  };

  const char **m;
  int r;
  m = vectors_ok;
  while (*m) {
    r = mnemonic_check(*m);
    ck_assert_int_eq(r, 1);
    m++;
  }
  m = vectors_fail;
  while (*m) {
    r = mnemonic_check(*m);
    ck_assert_int_eq(r, 0);
    m++;
  }
}
END_TEST

START_TEST(test_mnemonic_to_entropy) {
  static const char *vectors[] = {
      "00000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon about",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "yellow",
      "80808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage above",
      "ffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
      "000000000000000000000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon agent",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal will",
      "808080808080808080808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter always",
      "ffffffffffffffffffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "when",
      "0000000000000000000000000000000000000000000000000000000000000000",
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon abandon abandon abandon abandon "
      "abandon abandon abandon abandon abandon art",
      "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
      "legal winner thank year wave sausage worth useful legal winner thank "
      "year wave sausage worth useful legal winner thank year wave sausage "
      "worth title",
      "8080808080808080808080808080808080808080808080808080808080808080",
      "letter advice cage absurd amount doctor acoustic avoid letter advice "
      "cage absurd amount doctor acoustic avoid letter advice cage absurd "
      "amount doctor acoustic bless",
      "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
      "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo "
      "zoo zoo zoo zoo zoo vote",
      "77c2b00716cec7213839159e404db50d",
      "jelly better achieve collect unaware mountain thought cargo oxygen act "
      "hood bridge",
      "b63a9c59a6e641f288ebc103017f1da9f8290b3da6bdef7b",
      "renew stay biology evidence goat welcome casual join adapt armor "
      "shuffle fault little machine walk stumble urge swap",
      "3e141609b97933b66a060dcddc71fad1d91677db872031e85f4c015c5e7e8982",
      "dignity pass list indicate nasty swamp pool script soccer toe leaf "
      "photo multiply desk host tomato cradle drill spread actor shine dismiss "
      "champion exotic",
      "0460ef47585604c5660618db2e6a7e7f",
      "afford alter spike radar gate glance object seek swamp infant panel "
      "yellow",
      "72f60ebac5dd8add8d2a25a797102c3ce21bc029c200076f",
      "indicate race push merry suffer human cruise dwarf pole review arch "
      "keep canvas theme poem divorce alter left",
      "2c85efc7f24ee4573d2b81a6ec66cee209b2dcbd09d8eddc51e0215b0b68e416",
      "clutch control vehicle tonight unusual clog visa ice plunge glimpse "
      "recipe series open hour vintage deposit universe tip job dress radar "
      "refuse motion taste",
      "eaebabb2383351fd31d703840b32e9e2",
      "turtle front uncle idea crush write shrug there lottery flower risk "
      "shell",
      "7ac45cfe7722ee6c7ba84fbc2d5bd61b45cb2fe5eb65aa78",
      "kiss carry display unusual confirm curtain upgrade antique rotate hello "
      "void custom frequent obey nut hole price segment",
      "4fa1a8bc3e6d80ee1316050e862c1812031493212b7ec3f3bb1b08f168cabeef",
      "exile ask congress lamp submit jacket era scheme attend cousin alcohol "
      "catch course end lucky hurt sentence oven short ball bird grab wing top",
      "18ab19a9f54a9274f03e5209a2ac8a91",
      "board flee heavy tunnel powder denial science ski answer betray cargo "
      "cat",
      "18a2e1d81b8ecfb2a333adcb0c17a5b9eb76cc5d05db91a4",
      "board blade invite damage undo sun mimic interest slam gaze truly "
      "inherit resist great inject rocket museum chief",
      "15da872c95a13dd738fbf50e427583ad61f18fd99f628c417a61cf8343c90419",
      "beyond stage sleep clip because twist token leaf atom beauty genius "
      "food business side grid unable middle armed observe pair crouch tonight "
      "away coconut",
      0,
      0,
  };

  const char **a, **b;
  uint8_t entropy[64];

  a = vectors;
  b = vectors + 1;
  while (*a && *b) {
    int seed_len = mnemonic_to_entropy(*b, entropy);
    ck_assert_int_eq(seed_len % 33, 0);
    seed_len = seed_len * 4 / 33;
    ck_assert_int_eq(seed_len, strlen(*a) / 2);
    ck_assert_mem_eq(entropy, fromhex(*a), seed_len);
    a += 2;
    b += 2;
  }
}
END_TEST

START_TEST(test_shamir) {
#define SHAMIR_MAX_COUNT 16
  static const struct {
    const uint8_t result[SHAMIR_MAX_LEN];
    uint8_t result_index;
    const uint8_t share_indices[SHAMIR_MAX_COUNT];
    const uint8_t share_values[SHAMIR_MAX_COUNT][SHAMIR_MAX_LEN];
    uint8_t share_count;
    size_t len;
    bool ret;
  } vectors[] = {{{7,   151, 168, 57,  186, 104, 218, 21, 209, 96,  106,
                   152, 252, 35,  210, 208, 43,  47,  13, 21,  142, 122,
                   24,  42,  149, 192, 95,  24,  240, 24, 148, 110},
                  0,
                  {2},
                  {
                      {7,   151, 168, 57,  186, 104, 218, 21, 209, 96,  106,
                       152, 252, 35,  210, 208, 43,  47,  13, 21,  142, 122,
                       24,  42,  149, 192, 95,  24,  240, 24, 148, 110},
                  },
                  1,
                  32,
                  true},

                 {{53},
                  255,
                  {14, 10, 1, 13, 8, 7, 3, 11, 9, 4, 6, 0, 5, 12, 15, 2},
                  {
                      {114},
                      {41},
                      {116},
                      {67},
                      {198},
                      {109},
                      {232},
                      {39},
                      {90},
                      {241},
                      {156},
                      {75},
                      {46},
                      {181},
                      {144},
                      {175},
                  },
                  16,
                  1,
                  true},

                 {{91, 188, 226, 91, 254, 197, 225},
                  1,
                  {5, 1, 10},
                  {
                      {129, 18, 104, 86, 236, 73, 176},
                      {91, 188, 226, 91, 254, 197, 225},
                      {69, 53, 151, 204, 224, 37, 19},
                  },
                  3,
                  7,
                  true},

                 {{0},
                  1,
                  {5, 1, 1},
                  {
                      {129, 18, 104, 86, 236, 73, 176},
                      {91, 188, 226, 91, 254, 197, 225},
                      {69, 53, 151, 204, 224, 37, 19},
                  },
                  3,
                  7,
                  false},

                 {{0},
                  255,
                  {3, 12, 3},
                  {
                      {100, 176, 99, 142, 115, 192, 138},
                      {54, 139, 99, 172, 29, 137, 58},
                      {216, 119, 222, 40, 87, 25, 147},
                  },
                  3,
                  7,
                  false},

                 {{163, 120, 30, 243, 179, 172, 196, 137, 119, 17},
                  3,
                  {1, 0, 12},
                  {{80, 180, 198, 131, 111, 251, 45, 181, 2, 242},
                   {121, 9, 79, 98, 132, 164, 9, 165, 19, 230},
                   {86, 52, 173, 138, 189, 223, 122, 102, 248, 157}},
                  3,
                  10,
                  true}};

  for (size_t i = 0; i < (sizeof(vectors) / sizeof(*vectors)); ++i) {
    uint8_t result[SHAMIR_MAX_LEN];
    const uint8_t *share_values[SHAMIR_MAX_COUNT];
    for (size_t j = 0; j < vectors[i].share_count; ++j) {
      share_values[j] = vectors[i].share_values[j];
    }
    ck_assert_int_eq(shamir_interpolate(result, vectors[i].result_index,
                                        vectors[i].share_indices, share_values,
                                        vectors[i].share_count, vectors[i].len),
                     vectors[i].ret);
    if (vectors[i].ret == true) {
      ck_assert_mem_eq(result, vectors[i].result, vectors[i].len);
    }
  }
}
END_TEST

START_TEST(test_address) {
  char address[36];
  uint8_t pub_key[65];

  memcpy(
      pub_key,
      fromhex(
          "0226659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"),
      33);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "139MaMHp3Vjo8o4x8N1ZLWEtovLGvBsg6s");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mhfJsQNnrXB3uuYZqvywARTDfuvyjg4RBh");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "MxiimznnxsqMfLKTQBL8Z2PoY9jKpjgkCu");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LMNJqZbe89yrPbm7JVzrcXJf28hZ1rKPaH");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FXK52G2BbzRLaQ651U12o23DU5cEQdhvU6");
  ecdsa_get_address_segwit_p2sh(pub_key, 5, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                                address, sizeof(address));
  ck_assert_str_eq(address, "34PyTHn74syS796eTgsyoLfwoBC3cwLn6p");

  memcpy(
      pub_key,
      fromhex(
          "025b1654a0e78d28810094f6c5a96b8efb8a65668b578f170ac2b1f83bc63ba856"),
      33);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "19Ywfm3witp6C1yBMy4NRYHY2347WCRBfQ");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mp4txp8vXvFLy8So5Y2kFTVrt2epN6YzdP");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "N58JsQYveGueiZDgdnNwe4SSkGTAToutAY");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LTmtvyMmoZ49SpfLY73fhZMJEFRPdyohKh");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "Fdif7fnKHPVddczJF53qt45rgCL51yWN6x");
  ecdsa_get_address_segwit_p2sh(pub_key, 5, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                                address, sizeof(address));
  ck_assert_str_eq(address, "35trq6eeuHf6VL9L8pQv46x3vegHnHoTuB");

  memcpy(
      pub_key,
      fromhex(
          "03433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7fe"),
      33);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "1FWE2bn3MWhc4QidcF6AvEWpK77sSi2cAP");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mv2BKes2AY8rqXCFKp4Yk9j9B6iaMfWRLN");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "NB5bEFH2GtoAawy8t4Qk8kfj3LWvQs3MhB");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LZjBHp5sSAwfKDQnnP5UCFaaXKV9YheGxQ");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FjfwUWWQv1P9W1jkVM5eNkK8yGPq5XyZZy");
  ecdsa_get_address_segwit_p2sh(pub_key, 5, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                                address, sizeof(address));
  ck_assert_str_eq(address, "3456DYaKUWuY6RWWw8Hp5CftHLcQN29h9Y");

  memcpy(
      pub_key,
      fromhex(
          "03aeb03abeee0f0f8b4f7a5d65ce31f9570cef9f72c2dd8a19b4085a30ab033d48"),
      33);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "1yrZb8dhdevoqpUEGi2tUccUEeiMKeLcs");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mgVoreDcWf6BaxJ5wqgQiPpwLEFRLSr8U8");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "MwZDmEdcd1kVLP4yW62c6zmXCU3mNbveDo");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LLCopoSTnHtz4eWdQQhLAVgNgT1zTi4QBK");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FW9a1Vs1G8LUFSqb7NhWLzQw8PvfwAxmxA");
  ecdsa_get_address_segwit_p2sh(pub_key, 5, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                                address, sizeof(address));
  ck_assert_str_eq(address, "3DBU4tJ9tkMR9fnmCtjW48kjvseoNLQZXd");

  memcpy(
      pub_key,
      fromhex(
          "0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054"
          "201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"),
      65);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "194SZbL75xCCGBbKtMsyWLE5r9s2V6mhVM");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "moaPreR5tydT3J4wbvrMLFSQi9TjPCiZc6");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "N4domEq61LHkniqqABCYirNzaPG5NRU8GH");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LTHPpodwAcSFWzHV4VsGnMHr4NEJajMnKX");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FdEA1W4UeSsjhncSmTsSxr2QWK8z2xGkjc");

  memcpy(
      pub_key,
      fromhex(
          "0498010f8a687439ff497d3074beb4519754e72c4b6220fb669224749591dde416f3"
          "961f8ece18f8689bb32235e436874d2174048b86118a00afbd5a4f33a24f0f"),
      65);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "1A2WfBD4BJFwYHFPc5KgktqtbdJLBuVKc4");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mpYTxEJ2zKhCKPj1KeJ4ap4DTcu39T3uzD");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "N5bsrpi36gMW4pVtsteFyQzoKrhPE7nkxK");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LUFTvPWtFxVzo5wYnDJz2uueoqfcMYiuxH");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FeCE75wRjnwUytGWVBKADQeDFnaHpJ8t3B");

  memcpy(
      pub_key,
      fromhex(
          "04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2"
          "a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf19b77a4d"),
      65);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "19J81hrPnQxg9UGx45ibTieCkb2ttm8CLL");
  ecdsa_get_address(pub_key, 111, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "mop5JkwNbSPvvakZmegyHdrXcadbjLazww");
  ecdsa_get_address(pub_key, 52, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "N4sVDMMNho4Eg1XTKu3AgEo7UpRwq3aNbn");
  ecdsa_get_address(pub_key, 48, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "LTX5GvADs5CjQGy7EDhtjjhxxoQB2Uhicd");
  ecdsa_get_address(pub_key, 36, HASHER_SHA2_RIPEMD, HASHER_GROESTLD_TRUNC,
                    address, sizeof(address));
  ck_assert_str_eq(address, "FdTqTcamLueDb5J4wBi4vESXQkJrS54H6k");
}
END_TEST

START_TEST(test_pubkey_validity) {
  uint8_t pub_key[65];
  curve_point pub;
  int res;
  const ecdsa_curve *curve = &secp256k1;

  memcpy(
      pub_key,
      fromhex(
          "0226659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"),
      33);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "025b1654a0e78d28810094f6c5a96b8efb8a65668b578f170ac2b1f83bc63ba856"),
      33);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "03433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7fe"),
      33);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "03aeb03abeee0f0f8b4f7a5d65ce31f9570cef9f72c2dd8a19b4085a30ab033d48"),
      33);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054"
          "201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"),
      65);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "0498010f8a687439ff497d3074beb4519754e72c4b6220fb669224749591dde416f3"
          "961f8ece18f8689bb32235e436874d2174048b86118a00afbd5a4f33a24f0f"),
      65);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2"
          "a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf19b77a4d"),
      65);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 1);

  memcpy(
      pub_key,
      fromhex(
          "04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2"
          "a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf00000000"),
      65);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 0);

  memcpy(
      pub_key,
      fromhex(
          "04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2"
          "a59ebddbdac9e87b816307a7ed5b8211111111111111111111111111111111"),
      65);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 0);

  memcpy(pub_key, fromhex("00"), 1);
  res = ecdsa_read_pubkey(curve, pub_key, &pub);
  ck_assert_int_eq(res, 0);
}
END_TEST

START_TEST(test_pubkey_uncompress) {
  uint8_t pub_key[65];
  uint8_t uncompressed[65];
  int res;
  const ecdsa_curve *curve = &secp256k1;

  memcpy(
      pub_key,
      fromhex(
          "0226659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"),
      33);
  res = ecdsa_uncompress_pubkey(curve, pub_key, uncompressed);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      uncompressed,
      fromhex(
          "0426659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37b3"
          "cfbad6b39a8ce8cb3a675f53b7b57e120fe067b8035d771fd99e3eba7cf4de"),
      65);

  memcpy(
      pub_key,
      fromhex(
          "03433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7fe"),
      33);
  res = ecdsa_uncompress_pubkey(curve, pub_key, uncompressed);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      uncompressed,
      fromhex(
          "04433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7feeb"
          "4c25bcb840f720a16e8857a011e6b91e0ab2d03dbb5f9762844bb21a7b8ca7"),
      65);

  memcpy(
      pub_key,
      fromhex(
          "0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054"
          "201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"),
      65);
  res = ecdsa_uncompress_pubkey(curve, pub_key, uncompressed);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      uncompressed,
      fromhex(
          "0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054"
          "201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"),
      65);

  memcpy(pub_key, fromhex("00"), 1);
  res = ecdsa_uncompress_pubkey(curve, pub_key, uncompressed);
  ck_assert_int_eq(res, 0);
}
END_TEST

START_TEST(test_wif) {
  uint8_t priv_key[32];
  char wif[53];

  memcpy(
      priv_key,
      fromhex(
          "1111111111111111111111111111111111111111111111111111111111111111"),
      32);
  ecdsa_get_wif(priv_key, 0x80, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "KwntMbt59tTsj8xqpqYqRRWufyjGunvhSyeMo3NTYpFYzZbXJ5Hp");
  ecdsa_get_wif(priv_key, 0xEF, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "cN9spWsvaxA8taS7DFMxnk1yJD2gaF2PX1npuTpy3vuZFJdwavaw");

  memcpy(
      priv_key,
      fromhex(
          "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"),
      32);
  ecdsa_get_wif(priv_key, 0x80, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "L4ezQvyC6QoBhxB4GVs9fAPhUKtbaXYUn8YTqoeXwbevQq4U92vN");
  ecdsa_get_wif(priv_key, 0xEF, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "cV1ysqy3XUVSsPeKeugH2Utm6ZC1EyeArAgvxE73SiJvfa6AJng7");

  memcpy(
      priv_key,
      fromhex(
          "47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"),
      32);
  ecdsa_get_wif(priv_key, 0x80, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "KydbzBtk6uc7M6dXwEgTEH2sphZxSPbmDSz6kUUHi4eUpSQuhEbq");
  ecdsa_get_wif(priv_key, 0xEF, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "cPzbT6tbXyJNWY6oKeVabbXwSvsN6qhTHV8ZrtvoDBJV5BRY1G5Q");
}
END_TEST

START_TEST(test_address_decode) {
  int res;
  uint8_t decode[MAX_ADDR_RAW_SIZE];

  res = ecdsa_address_decode("1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("00c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);

  res = ecdsa_address_decode("myTPjxggahXyAzuMcYp5JTkbybANyLsYBW", 111,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("6fc4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);

  res = ecdsa_address_decode("NEWoeZ6gh4CGvRgFAoAGh4hBqpxizGT6gZ", 52,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("34c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);

  res = ecdsa_address_decode("LdAPi7uXrLLmeh7u57pzkZc3KovxEDYRJq", 48,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("30c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);

  res = ecdsa_address_decode("1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("0079fbfc3f34e7745860d76137da68f362380c606c"), 21);

  res = ecdsa_address_decode("mrdwvWkma2D6n9mGsbtkazedQQuoksnqJV", 111,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("6f79fbfc3f34e7745860d76137da68f362380c606c"), 21);

  res = ecdsa_address_decode("N7hMq7AmgNsQXaYARrEwybbDGei9mcPNqr", 52,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("3479fbfc3f34e7745860d76137da68f362380c606c"), 21);

  res = ecdsa_address_decode("LWLwtfycqf1uFqypLAug36W4kdgNwrZdNs", 48,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("3079fbfc3f34e7745860d76137da68f362380c606c"), 21);

  // invalid char
  res = ecdsa_address_decode("1JwSSubhmg6i000jtyqhUYYH7bZg3Lfy1T", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);

  // invalid address
  res = ecdsa_address_decode("1111Subhmg6iPtRjtyqhUYYH7bZg3Lfy1T", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);

  // invalid version
  res = ecdsa_address_decode("LWLwtfycqf1uFqypLAug36W4kdgNwrZdNs", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);
}
END_TEST

START_TEST(test_ecdsa_der) {
  uint8_t sig[64], der[72];
  int res;

  memcpy(
      sig,
      fromhex(
          "9a0b7be0d4ed3146ee262b42202841834698bb3ee39c24e7437df208b8b70771"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "2b79ab1e7736219387dffe8d615bbdba87e11477104b867ef47afed1a5ede781"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 71);
  ck_assert_mem_eq(der,
                   fromhex("30450221009a0b7be0d4ed3146ee262b42202841834698bb3ee"
                           "39c24e7437df208b8b7077102202b79ab1e7736219387dffe8d"
                           "615bbdba87e11477104b867ef47afed1a5ede781"),
                   71);

  memcpy(
      sig,
      fromhex(
          "6666666666666666666666666666666666666666666666666666666666666666"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "7777777777777777777777777777777777777777777777777777777777777777"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 70);
  ck_assert_mem_eq(der,
                   fromhex("304402206666666666666666666666666666666666666666666"
                           "666666666666666666666022077777777777777777777777777"
                           "77777777777777777777777777777777777777"),
                   70);

  memcpy(
      sig,
      fromhex(
          "6666666666666666666666666666666666666666666666666666666666666666"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 71);
  ck_assert_mem_eq(der,
                   fromhex("304502206666666666666666666666666666666666666666666"
                           "666666666666666666666022100eeeeeeeeeeeeeeeeeeeeeeee"
                           "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
                   71);

  memcpy(
      sig,
      fromhex(
          "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "7777777777777777777777777777777777777777777777777777777777777777"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 71);
  ck_assert_mem_eq(der,
                   fromhex("3045022100eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
                           "eeeeeeeeeeeeeeeeeeeeeee0220777777777777777777777777"
                           "7777777777777777777777777777777777777777"),
                   71);

  memcpy(
      sig,
      fromhex(
          "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 72);
  ck_assert_mem_eq(der,
                   fromhex("3046022100eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
                           "eeeeeeeeeeeeeeeeeeeeeee022100ffffffffffffffffffffff"
                           "ffffffffffffffffffffffffffffffffffffffffff"),
                   72);

  memcpy(
      sig,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000066"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000077"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 8);
  ck_assert_mem_eq(der, fromhex("3006020166020177"), 8);

  memcpy(
      sig,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000066"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000ee"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 9);
  ck_assert_mem_eq(der, fromhex("3007020166020200ee"), 9);

  memcpy(
      sig,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000ee"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "0000000000000000000000000000000000000000000000000000000000000077"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 9);
  ck_assert_mem_eq(der, fromhex("3007020200ee020177"), 9);

  memcpy(
      sig,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000ee"),
      32);
  memcpy(
      sig + 32,
      fromhex(
          "00000000000000000000000000000000000000000000000000000000000000ff"),
      32);
  res = ecdsa_sig_to_der(sig, der);
  ck_assert_int_eq(res, 10);
  ck_assert_mem_eq(der, fromhex("3008020200ee020200ff"), 10);
}
END_TEST

static void test_codepoints_curve(const ecdsa_curve *curve) {
  int i, j;
  bignum256 a;
  curve_point p, p1;
  for (i = 0; i < 64; i++) {
    for (j = 0; j < 8; j++) {
      bn_zero(&a);
      a.val[(4 * i) / 30] = (uint32_t)(2 * j + 1) << (4 * i % 30);
      bn_normalize(&a);
      // note that this is not a trivial test.  We add 64 curve
      // points in the table to get that particular curve point.
      scalar_multiply(curve, &a, &p);
      ck_assert_mem_eq(&p, &curve->cp[i][j], sizeof(curve_point));
      bn_zero(&p.y);  // test that point_multiply curve, is not a noop
      point_multiply(curve, &a, &curve->G, &p);
      ck_assert_mem_eq(&p, &curve->cp[i][j], sizeof(curve_point));
      // mul 2 test. this should catch bugs
      bn_lshift(&a);
      bn_mod(&a, &curve->order);
      p1 = curve->cp[i][j];
      point_double(curve, &p1);
      // note that this is not a trivial test.  We add 64 curve
      // points in the table to get that particular curve point.
      scalar_multiply(curve, &a, &p);
      ck_assert_mem_eq(&p, &p1, sizeof(curve_point));
      bn_zero(&p.y);  // test that point_multiply curve, is not a noop
      point_multiply(curve, &a, &curve->G, &p);
      ck_assert_mem_eq(&p, &p1, sizeof(curve_point));
    }
  }
}

START_TEST(test_codepoints_secp256k1) { test_codepoints_curve(&secp256k1); }
END_TEST
START_TEST(test_codepoints_nist256p1) { test_codepoints_curve(&nist256p1); }
END_TEST

static void test_mult_border_cases_curve(const ecdsa_curve *curve) {
  bignum256 a;
  curve_point p;
  curve_point expected;
  bn_zero(&a);  // a == 0
  scalar_multiply(curve, &a, &p);
  ck_assert(point_is_infinity(&p));
  point_multiply(curve, &a, &p, &p);
  ck_assert(point_is_infinity(&p));
  point_multiply(curve, &a, &curve->G, &p);
  ck_assert(point_is_infinity(&p));

  bn_addi(&a, 1);  // a == 1
  scalar_multiply(curve, &a, &p);
  ck_assert_mem_eq(&p, &curve->G, sizeof(curve_point));
  point_multiply(curve, &a, &curve->G, &p);
  ck_assert_mem_eq(&p, &curve->G, sizeof(curve_point));

  bn_subtract(&curve->order, &a, &a);  // a == -1
  expected = curve->G;
  bn_subtract(&curve->prime, &expected.y, &expected.y);
  scalar_multiply(curve, &a, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
  point_multiply(curve, &a, &curve->G, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));

  bn_subtract(&curve->order, &a, &a);
  bn_addi(&a, 1);  // a == 2
  expected = curve->G;
  point_add(curve, &expected, &expected);
  scalar_multiply(curve, &a, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
  point_multiply(curve, &a, &curve->G, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));

  bn_subtract(&curve->order, &a, &a);  // a == -2
  expected = curve->G;
  point_add(curve, &expected, &expected);
  bn_subtract(&curve->prime, &expected.y, &expected.y);
  scalar_multiply(curve, &a, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
  point_multiply(curve, &a, &curve->G, &p);
  ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
}

START_TEST(test_mult_border_cases_secp256k1) {
  test_mult_border_cases_curve(&secp256k1);
}
END_TEST
START_TEST(test_mult_border_cases_nist256p1) {
  test_mult_border_cases_curve(&nist256p1);
}
END_TEST

static void test_scalar_mult_curve(const ecdsa_curve *curve) {
  int i;
  // get two "random" numbers
  bignum256 a = curve->G.x;
  bignum256 b = curve->G.y;
  curve_point p1, p2, p3;
  for (i = 0; i < 1000; i++) {
    /* test distributivity: (a + b)G = aG + bG */
    bn_mod(&a, &curve->order);
    bn_mod(&b, &curve->order);
    scalar_multiply(curve, &a, &p1);
    scalar_multiply(curve, &b, &p2);
    bn_addmod(&a, &b, &curve->order);
    bn_mod(&a, &curve->order);
    scalar_multiply(curve, &a, &p3);
    point_add(curve, &p1, &p2);
    ck_assert_mem_eq(&p2, &p3, sizeof(curve_point));
    // new "random" numbers
    a = p3.x;
    b = p3.y;
  }
}

START_TEST(test_scalar_mult_secp256k1) { test_scalar_mult_curve(&secp256k1); }
END_TEST
START_TEST(test_scalar_mult_nist256p1) { test_scalar_mult_curve(&nist256p1); }
END_TEST

static void test_point_mult_curve(const ecdsa_curve *curve) {
  int i;
  // get two "random" numbers and a "random" point
  bignum256 a = curve->G.x;
  bignum256 b = curve->G.y;
  curve_point p = curve->G;
  curve_point p1, p2, p3;
  for (i = 0; i < 200; i++) {
    /* test distributivity: (a + b)P = aP + bP */
    bn_mod(&a, &curve->order);
    bn_mod(&b, &curve->order);
    point_multiply(curve, &a, &p, &p1);
    point_multiply(curve, &b, &p, &p2);
    bn_addmod(&a, &b, &curve->order);
    bn_mod(&a, &curve->order);
    point_multiply(curve, &a, &p, &p3);
    point_add(curve, &p1, &p2);
    ck_assert_mem_eq(&p2, &p3, sizeof(curve_point));
    // new "random" numbers and a "random" point
    a = p1.x;
    b = p1.y;
    p = p3;
  }
}

START_TEST(test_point_mult_secp256k1) { test_point_mult_curve(&secp256k1); }
END_TEST
START_TEST(test_point_mult_nist256p1) { test_point_mult_curve(&nist256p1); }
END_TEST

static void test_scalar_point_mult_curve(const ecdsa_curve *curve) {
  int i;
  // get two "random" numbers
  bignum256 a = curve->G.x;
  bignum256 b = curve->G.y;
  curve_point p1, p2;
  for (i = 0; i < 200; i++) {
    /* test commutativity and associativity:
     * a(bG) = (ab)G = b(aG)
     */
    bn_mod(&a, &curve->order);
    bn_mod(&b, &curve->order);
    scalar_multiply(curve, &a, &p1);
    point_multiply(curve, &b, &p1, &p1);

    scalar_multiply(curve, &b, &p2);
    point_multiply(curve, &a, &p2, &p2);

    ck_assert_mem_eq(&p1, &p2, sizeof(curve_point));

    bn_multiply(&a, &b, &curve->order);
    bn_mod(&b, &curve->order);
    scalar_multiply(curve, &b, &p2);

    ck_assert_mem_eq(&p1, &p2, sizeof(curve_point));

    // new "random" numbers
    a = p1.x;
    b = p1.y;
  }
}

START_TEST(test_scalar_point_mult_secp256k1) {
  test_scalar_point_mult_curve(&secp256k1);
}
END_TEST
START_TEST(test_scalar_point_mult_nist256p1) {
  test_scalar_point_mult_curve(&nist256p1);
}
END_TEST

START_TEST(test_ed25519) {
  // test vectors from
  // https://github.com/torproject/tor/blob/master/src/test/ed25519_vectors.inc
  static const char *vectors[] = {
      "26c76712d89d906e6672dafa614c42e5cb1caac8c6568e4d2493087db51f0d3"
      "6",  // secret
      "c2247870536a192d142d056abefca68d6193158e7c1a59c1654c954eccaff89"
      "4",  // public
      "d23188eac3773a316d46006fa59c095060be8b1a23582a0dd99002a82a0662bd"
      "246d8449e172e04c5f46ac0d1404cebe4aabd8a75a1457aa06cae41f3334f10"
      "4",  // selfsig
      "fba7a5366b5cb98c2667a18783f5cf8f4f8d1a2ce939ad22a6e685edde85128"
      "d",
      "1519a3b15816a1aafab0b213892026ebf5c0dc232c58b21088d88cb90e9b940"
      "d",
      "3a785ac1201c97ee5f6f0d99323960d5f264c7825e61aa7cc81262f15bef75eb"
      "4fa5723add9b9d45b12311b6d403eb3ac79ff8e4e631fc3cd51e4ad2185b200"
      "b",
      "67e3aa7a14fac8445d15e45e38a523481a69ae35513c9e4143eb1c2196729a0"
      "e",
      "081faa81992e360ea22c06af1aba096e7a73f1c665bc8b3e4e531c46455fd1d"
      "d",
      "cf431fd0416bfbd20c9d95ef9b723e2acddffb33900edc72195dea95965d52d8"
      "88d30b7b8a677c0bd8ae1417b1e1a0ec6700deadd5d8b54b6689275e04a0450"
      "9",
      "d51385942033a76dc17f089a59e6a5a7fe80d9c526ae8ddd8c3a506b99d3d0a"
      "6",
      "73cfa1189a723aad7966137cbffa35140bb40d7e16eae4c40b79b5f0360dd65"
      "a",
      "2375380cd72d1a6c642aeddff862be8a5804b916acb72c02d9ed052c1561881a"
      "a658a5af856fcd6d43113e42f698cd6687c99efeef7f2ce045824440d26c5d0"
      "0",
      "5c8eac469bb3f1b85bc7cd893f52dc42a9ab66f1b02b5ce6a68e9b175d3bb43"
      "3",
      "66c1a77104d86461b6f98f73acf3cd229c80624495d2d74d6fda1e940080a96"
      "b",
      "2385a472f599ca965bbe4d610e391cdeabeba9c336694b0d6249e551458280be"
      "122c2441dd9746a81bbfb9cd619364bab0df37ff4ceb7aefd24469c39d3bc50"
      "8",
      "eda433d483059b6d1ff8b7cfbd0fe406bfb23722c8f3c8252629284573b61b8"
      "6",
      "d21c294db0e64cb2d8976625786ede1d9754186ae8197a64d72f68c792eecc1"
      "9",
      "e500cd0b8cfff35442f88008d894f3a2fa26ef7d3a0ca5714ae0d3e2d40caae5"
      "8ba7cdf69dd126994dad6be536fcda846d89dd8138d1683cc144c8853dce760"
      "7",
      "4377c40431c30883c5fbd9bc92ae48d1ed8a47b81d13806beac5351739b5533"
      "d",
      "c4d58b4cf85a348ff3d410dd936fa460c4f18da962c01b1963792b9dcc8a6ea"
      "6",
      "d187b9e334b0050154de10bf69b3e4208a584e1a65015ec28b14bcc252cf84b8"
      "baa9c94867daa60f2a82d09ba9652d41e8dde292b624afc8d2c26441b95e3c0"
      "e",
      "c6bbcce615839756aed2cc78b1de13884dd3618f48367a17597a16c1cd7a290"
      "b",
      "95126f14d86494020665face03f2d42ee2b312a85bc729903eb17522954a1c4"
      "a",
      "815213640a643d198bd056e02bba74e1c8d2d931643e84497adf3347eb485079"
      "c9afe0afce9284cdc084946b561abbb214f1304ca11228ff82702185cf28f60"
      "d",
      0,
      0,
      0,
  };
  const char **ssk, **spk, **ssig;
  ssk = vectors;
  spk = vectors + 1;
  ssig = vectors + 2;
  ed25519_public_key pk;
  ed25519_secret_key sk;
  ed25519_signature sig;
  while (*ssk && *spk && *ssig) {
    memcpy(sk, fromhex(*ssk), 32);
    MARK_SECRET_DATA(sk, sizeof(sk));

    ed25519_publickey(sk, pk);
    UNMARK_SECRET_DATA(pk, sizeof(pk));
    ck_assert_mem_eq(pk, fromhex(*spk), 32);

    ed25519_sign(pk, 32, sk, pk, sig);
    UNMARK_SECRET_DATA(sig, sizeof(sig));
    ck_assert_mem_eq(sig, fromhex(*ssig), 64);

    ssk += 3;
    spk += 3;
    ssig += 3;

    UNMARK_SECRET_DATA(sk, sizeof(sk));
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/NemProject/nem-test-vectors/master/2.test-sign.dat
START_TEST(test_ed25519_keccak) {
  static const struct {
    const char *private_key;
    const char *public_key;
    const char *signature;
    size_t length;
    const char *data;
  } tests[] = {
      {
          "abf4cf55a2b3f742d7543d9cc17f50447b969e6e06f5ea9195d428ab12b7318d",
          "8a558c728c21c126181e5e654b404a45b4f0137ce88177435a69978cc6bec1f4",
          "d9cec0cc0e3465fab229f8e1d6db68ab9cc99a18cb0435f70deb6100948576cd5c0a"
          "a1feb550bdd8693ef81eb10a556a622db1f9301986827b96716a7134230c",
          41,
          "8ce03cd60514233b86789729102ea09e867fc6d964dea8c2018ef7d0a2e0e24bf7e3"
          "48e917116690b9",
      },
      {
          "6aa6dad25d3acb3385d5643293133936cdddd7f7e11818771db1ff2f9d3f9215",
          "bbc8cbb43dda3ecf70a555981a351a064493f09658fffe884c6fab2a69c845c6",
          "98bca58b075d1748f1c3a7ae18f9341bc18e90d1beb8499e8a654c65d8a0b4fbd2e0"
          "84661088d1e5069187a2811996ae31f59463668ef0f8cb0ac46a726e7902",
          49,
          "e4a92208a6fc52282b620699191ee6fb9cf04daf48b48fd542c5e43daa9897763a19"
          "9aaa4b6f10546109f47ac3564fade0",
      },
      {
          "8e32bc030a4c53de782ec75ba7d5e25e64a2a072a56e5170b77a4924ef3c32a9",
          "72d0e65f1ede79c4af0ba7ec14204e10f0f7ea09f2bc43259cd60ea8c3a087e2",
          "ef257d6e73706bb04878875c58aa385385bf439f7040ea8297f7798a0ea30c1c5eff"
          "5ddc05443f801849c68e98111ae65d088e726d1d9b7eeca2eb93b677860c",
          40,
          "13ed795344c4448a3b256f23665336645a853c5c44dbff6db1b9224b5303b6447fbf"
          "8240a2249c55",
      },
      {
          "c83ce30fcb5b81a51ba58ff827ccbc0142d61c13e2ed39e78e876605da16d8d7",
          "3ec8923f9ea5ea14f8aaa7e7c2784653ed8c7de44e352ef9fc1dee81fc3fa1a3",
          "0c684e71b35fed4d92b222fc60561db34e0d8afe44bdd958aaf4ee965911bef59912"
          "36f3e1bced59fc44030693bcac37f34d29e5ae946669dc326e706e81b804",
          49,
          "a2704638434e9f7340f22d08019c4c8e3dbee0df8dd4454a1d70844de11694f4c8ca"
          "67fdcb08fed0cec9abb2112b5e5f89",
      },
      {
          "2da2a0aae0f37235957b51d15843edde348a559692d8fa87b94848459899fc27",
          "d73d0b14a9754eec825fcb25ef1cfa9ae3b1370074eda53fc64c22334a26c254",
          "6f17f7b21ef9d6907a7ab104559f77d5a2532b557d95edffd6d88c073d87ac00fc83"
          "8fc0d05282a0280368092a4bd67e95c20f3e14580be28d8b351968c65e03",
          40,
          "d2488e854dbcdfdb2c9d16c8c0b2fdbc0abb6bac991bfe2b14d359a6bc99d66c00fd"
          "60d731ae06d0",
      },
      {
          "0c066261fb1b18ebf2a9bcdeda81eb47d5a3745438b3d0b9d19b75885ad0a154",
          "2e5773f0e725024bc0359ce93a44e15d6507e7b160b6c592200385fee4a269cf",
          "13b5d2dd1b04f62cc2ec1544fed256423684f2dbca4538ceddda1d15c59dc7196c87"
          "840ea303ea30f4f6914a6ec9167841980c1d717f47fd641225068de88507",
          41,
          "f15cb706e29fcfbcb324e38cbac62bb355deddb845c142e970f0c029ea4d05e59fd6"
          "adf85573cf1775",
      },
      {
          "ef3d8e22a592f04c3a31aa736e10901757a821d053f1a49a525b4ec91eacdee3",
          "72a2b4910a502b30e13a96aba643c59c79328c1ba1462be6f254e817ef157fee",
          "95f2437a0210d2d2f125a3c377ed666c0d596cd104185e70204924a182a11a6eb3bd"
          "ba4395bbfc3f4e827d38805752657ee52d1ce0f17e70f59bfd4999282509",
          50,
          "6c3e4387345740b8d62cf0c9dec48f98c292539431b2b54020d8072d9cb55f0197f7"
          "d99ff066afcf9e41ea8b7aea78eb082d",
      },
      {
          "f7fb79743e9ba957d2a4f1bd95ceb1299552abecaf758bf840d2dc2c09f3e3cb",
          "8b7d7531280f76a8abac8293d87508e3953894087112ae01b6ad32485d4e9b67",
          "c868ecf31cee783fe8799ac7e6a662431c822967351d8b79687f4ddf608f79a080c4"
          "ff9eed4fdee8c99fe1be905f734cae2a172f1cfdb00771625c0695a5260e",
          42,
          "55d8e60c307ee533b1af9ff677a2de40a6eace722bcc9eb5d79907b420e533bc06db"
          "674dafbd9f43d672",
      },
      {
          "8cc9a2469a77fad18b44b871b2b6932cd354641d2d1e84403f746c4fff829791",
          "aed5da202d4983dac560faf6704dc76ac111616318570e244043e82ed1bbcd2b",
          "aee9616db4135150818eaffa3e4503c2d7e9e834847a4c7d0a8856e952761d361a65"
          "7104d36950c9b75770ded00d56a96e06f383fa2406bc935dcf51f272300e",
          42,
          "d9b8be2f71b83261304e333d6e35563dc3c36c2eb5a23e1461b6e95aa7c6f381f9c3"
          "bd39deaa1b6df2f9",
      },
      {
          "a247abbef0c1affbf021d1aff128888550532fc0edd77bc39f6ef5312317ec47",
          "98ededbad1e5ad7a0d5a0cf4fcd7a794eb5c6900a65e7e921884a636f19b131d",
          "f8cc02933851432f0c5df0b70f2067f740ccb72de7d6fa1e9a9b0d6de1402b9c6c52"
          "5fd848e45aaaac1423b52880ec3474a2f64b38db6fc8e008d95a310e6e0c",
          47,
          "4a5f07eb713932532fc3132c96efdc45862fe7a954c1d2ae4640afdf4728fb58c65e"
          "8a4ebfe0d53d5797d5146442b9",
      },
      {
          "163d69079ddad1f16695c47d81c3b72f869b2fdd50e6e47113db6c85051a6ede",
          "93fe602642ee5773f4aaf6a3bc21e98e354035225353f419e78e43c3ec36c88a",
          "da747fa2cb47aae1effc1e4cfde0e39fa79937948592a712a7665bf948b8311e7f3f"
          "80f966301679520d5c2afa3eadd60e061f0d264887500d8d03a17e10fd02",
          41,
          "65fe5c1a0214a59644892e5ac4216f09fbb4e191b89bfb63d6540177d25ef9e37148"
          "50b8453bd6b2b6",
      },
      {
          "7b061bf90eb760971b9ec66a96fd6609635ca4b531f33e3c126b9ae6fdb3d491",
          "cb392ebb6912df4111efeeb1278160daf9da396e9291b83979a5ac479f7276d2",
          "f6eebe86f7ea672e0707ee518e1798d6fbd118c11b2aa30be07d10e3882e3721f203"
          "0f9f044b77c3a7a9a2f1feba7e7ce75d1f7f3807a96a764fded35d341d02",
          45,
          "a17f5ce39b9ba7b7cf1147e515d6aa84b22fd0e2d8323a91367198fc6c3aff04ebb2"
          "1fc2bdbe7bc0364e8040a9",
      },
      {
          "c9f8ccbf761cec00ab236c52651e76b5f46d90f8936d44d40561ed5c277104de",
          "a3192641e343b669ffd43677c2e5cd4efaed174e876141f1d773bd6cfe30d875",
          "d44f884ec9eae2e99e74194b5acc769b7aa369aaad359e92ba6ff0fe629af2a9a715"
          "6c19b720e7de8c7f03c039563f160948073cab6f99b26a56a8bb1023ba08",
          47,
          "3d7e33b0ecead8269966e9dcd192b73eb8a12573fc8a5fdfbe5753541026ef2e49f5"
          "280cba9bc2515a049b3a1c1b49",
      },
      {
          "ebfa409ac6f987df476858dd35310879bf564eeb62984a52115d2e6c24590124",
          "7bb1601fe7215f3f4da9c8ab5e804dc58f57ba41b03223f57ec80d9c9a2dd0e1",
          "f3e7c1abfcc9f35556cb1e4c5a2b34445177ac188312d9148f1d1d8467ea8411fa3c"
          "da031d023034e45bbe407ef7d1b937bfb098266138857d35cb4efe407306",
          52,
          "0c37564f718eda683aa6f3e9ab2487620b1a8b5c8f20adb3b2d7550af0d635371e53"
          "1f27cebe76a2abcc96de0875bdae987a45ac",
      },
      {
          "f993f61902b7da332f2bb001baa7accaf764d824eb0cd073315f7ec43158b8fb",
          "55fc8e0da1b454cab6ddefb235311db2b01504bf9ac3f71c7e3f3d0d1f09f80b",
          "178bd147673c0ca330e45da63cbd1f1811906bd5284bb44e4bb00f7d7163d1f39697"
          "5610b6f71c1ae4686466fad4c5e7bb9685099e21ca4f1a45bb3fcf56ae0c",
          42,
          "b7dd613bc9c364d9eeb9a52636d72bc881dfc81a836b6537bbb928bff5b738313589"
          "47ea9edea1570550",
      },
      {
          "05188c09c31b4bb63f0d49b47ccc1654c2aba907b8c6c0a82ee403e950169167",
          "e096d808dfabe8e44eb74950199dadcd586f9de6b141a0ce85ab94b3d97866eb",
          "669491c8eb7cedbbc0252f3eafb048b39a2a37f60ac87837777c72c879ac8b726c39"
          "e10060750c2f539102999b71889746111bc5f71ec8c158cc81cf566aef03",
          44,
          "bb8e22469d1c7f1d5418563e8781f69eccb56678bd36d8919f358c2778562ff6b50d"
          "e916c12d44f1a778a7f3",
      },
      {
          "eabe57e1a916ebbffa4ba7abc7f23e83d4deb1338816cc1784d7495d92e98d0b",
          "3aad275642f48a46ed1032f3de9f4053e0fd35cf217e065d2e4579c3683932f7",
          "b2e9dac2c83942ca374f29c8eff5a30c377c3db3c1c645e593e524d17484e7705b11"
          "f79573e2d63495fc3ce3bf216a209f0cb7bea477ae0f8bd297f193af8805",
          44,
          "3f2c2d6682ee597f2a92d7e560ac53d5623550311a4939d68adfb904045ed8d215a9"
          "fdb757a2368ea4d89f5f",
      },
      {
          "fef7b893b4b517fab68ca12d36b603bc00826bf3c9b31a05149642ae10bb3f55",
          "b3fb891868708dfa5da5b9b5234058767ab42c117f12c3228c02a1976d1c0f83",
          "6243e289314b7c7587802909a9be6173a916b36f9de1e164954dfe5d1ebd57c869a7"
          "9552d770e13b51855502be6b15e7be42a3675298a81284df58e609b06503",
          47,
          "38c69f884045cdbeebe4478fdbd1ccc6cf00a08d8a3120c74e7167d3a2e26a67a043"
          "b8e5bd198f7b0ce0358cef7cf9",
      },
      {
          "16228bec9b724300a37e88e535fc1c58548d34d7148b57c226f2b3af974c1822",
          "3c92423a8360c9a5d9a093730d72831bec4601dcadfe84de19fc8c8f91fc3d4b",
          "6aebfa9a4294ec888d54bcb517fcb6821e4c16d2708a2afe701f431a28149ff4f139"
          "f9d16a52a63f1f91baf4c8dea37710c73f25c263a8035a39cc118ad0280f",
          44,
          "a3d7b122cd4431b396b20d8cc46cc73ed4a5253a44a76fc83db62cdc845a2bf7081d"
          "069a857955a161cccf84",
      },
      {
          "2dc3f5f0a0bc32c6632534e1e8f27e59cbe0bf7617d31aff98098e974c828be7",
          "b998a416edc28ded988dcacb1caf2bd96c87354b0d1eeccb6980e54a3104f21f",
          "76a2ddfc4bea48c47e0c82bcbfee28a37c61ec626af39a468e643e0ef9f6533056a5"
          "a0b44e64d614ba3c641a40e5b003a99463445ae2c3c8e1e9882092d74b07",
          42,
          "bdae276d738b9758ea3d322b54fd12fe82b767e8d817d8ef3d41f78705748e28d15e"
          "9c506962a1b85901",
      },
  };

  ed25519_secret_key private_key;
  ed25519_public_key public_key;
  ed25519_signature signature;

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    nem_private_key(tests[i].private_key, private_key);
    MARK_SECRET_DATA(private_key, sizeof(private_key));

    ed25519_publickey_keccak(private_key, public_key);
    UNMARK_SECRET_DATA(public_key, sizeof(public_key));
    ck_assert_mem_eq(public_key, fromhex(tests[i].public_key), 32);

    ed25519_sign_keccak(fromhex(tests[i].data), tests[i].length, private_key,
                        public_key, signature);
    UNMARK_SECRET_DATA(signature, sizeof(signature));
    ck_assert_mem_eq(signature, fromhex(tests[i].signature), 64);

    UNMARK_SECRET_DATA(private_key, sizeof(private_key));
  }
}
END_TEST

START_TEST(test_ed25519_cosi) {
  const int MAXN = 10;
  ed25519_secret_key keys[MAXN];
  ed25519_public_key pubkeys[MAXN];
  ed25519_secret_key nonces[MAXN];
  ed25519_public_key Rs[MAXN];
  ed25519_cosi_signature sigs[MAXN];
  uint8_t msg[32];
  rfc6979_state rng;
  int res;

  init_rfc6979(
      fromhex(
          "26c76712d89d906e6672dafa614c42e5cb1caac8c6568e4d2493087db51f0d36"),
      fromhex(
          "26659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"),
      &rng);

  for (int N = 1; N < 11; N++) {
    ed25519_public_key pk;
    ed25519_public_key R;
    ed25519_signature sig;
    /* phase 0: create priv/pubkeys and combine pubkeys */
    for (int j = 0; j < N; j++) {
      generate_rfc6979(keys[j], &rng);
      ed25519_publickey(keys[j], pubkeys[j]);
    }
    res = ed25519_cosi_combine_publickeys(pk, pubkeys, N);
    ck_assert_int_eq(res, 0);

    generate_rfc6979(msg, &rng);

    /* phase 1: create nonces, commitments (R values) and combine commitments */
    for (int j = 0; j < N; j++) {
      generate_rfc6979(nonces[j], &rng);
      ed25519_publickey(nonces[j], Rs[j]);
    }
    res = ed25519_cosi_combine_publickeys(R, Rs, N);
    ck_assert_int_eq(res, 0);

    MARK_SECRET_DATA(keys, sizeof(keys));
    /* phase 2: sign and combine signatures */
    for (int j = 0; j < N; j++) {
      ed25519_cosi_sign(msg, sizeof(msg), keys[j], nonces[j], R, pk, sigs[j]);
    }
    UNMARK_SECRET_DATA(sigs, sizeof(sigs));

    ed25519_cosi_combine_signatures(sig, R, sigs, N);

    /* check signature */
    res = ed25519_sign_open(msg, sizeof(msg), pk, sig);
    ck_assert_int_eq(res, 0);

    UNMARK_SECRET_DATA(keys, sizeof(keys));
  }
}
END_TEST

START_TEST(test_ed25519_modl_add) {
  char tests[][3][65] = {
      {
          "0000000000000000000000000000000000000000000000000000000000000000",
          "0000000000000000000000000000000000000000000000000000000000000000",
          "0000000000000000000000000000000000000000000000000000000000000000",
      },

      {"eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a",
       "0000000000000000000000000000000000000000000000000000000000000000",
       "eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a",
       "eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a"},

      {"0100000000000000000000000000000000000000000000000000000000000000",
       "0200000000000000000000000000000000000000000000000000000000000000",
       "0300000000000000000000000000000000000000000000000000000000000000"},

      {"e3d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0a00000000000000000000000000000000000000000000000000000000000000",
       "0000000000000000000000000000000000000000000000000000000000000000"},

      {"f7bb3bf42b3e58e2edd06f173fc7bfbc7aaf657217946b75648447101136aa08",
       "3c16b013109cc27ff39805be2abe04ba4cd6a8526a1d3023047693e950936c06",
       "33d2eb073cda1a62e16975d56985c476c7850ec581b19b9868fadaf961c9160f"},
  };

  unsigned char buff[32];
  bignum256modm a = {0}, b = {0}, c = {0};

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    expand256_modm(a, fromhex(tests[i][0]), 32);
    expand256_modm(b, fromhex(tests[i][1]), 32);
    add256_modm(c, a, b);
    contract256_modm(buff, c);
    ck_assert_mem_eq(buff, fromhex(tests[i][2]), 32);
  }
}
END_TEST

START_TEST(test_ed25519_modl_neg) {
  char tests[][2][65] = {
      {"05d0f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "e803000000000000000000000000000000000000000000000000000000000000"},

      {"4d4df45c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "a086010000000000000000000000000000000000000000000000000000000000"},

      {"25958944a1b7d4073975ca48996a1d740d0ed98ceec366760c5358da681e9608",
       "c83e6c1879ab3d509d272d5a458fc1a0f2f12673113c9989f3aca72597e16907"},

      {"0100000000000000000000000000000000000000000000000000000000000000",
       "ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010"},

      {"ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0100000000000000000000000000000000000000000000000000000000000000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "0000000000000000000000000000000000000000000000000000000000000000"},
  };

  unsigned char buff[32];
  bignum256modm a = {0}, b = {0};

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    expand256_modm(a, fromhex(tests[i][0]), 32);
    neg256_modm(b, a);
    contract256_modm((unsigned char *)buff, b);
    ck_assert_mem_eq(buff, fromhex(tests[i][1]), 32);
  }
}
END_TEST

START_TEST(test_ed25519_modl_sub) {
  char tests[][3][65] = {
      {
          "0000000000000000000000000000000000000000000000000000000000000000",
          "0000000000000000000000000000000000000000000000000000000000000000",
          "0000000000000000000000000000000000000000000000000000000000000000",
      },

      {"eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a",
       "53732f60e51ee3a48d21d2d526548c0dadbb79a185678fd7710613d0e76aad0c",
       "8859d1d1deee0767a4ff1b72a3e0d0327573c69bbff5fc07cfa61414e6ef3b0e"},

      {"9d91e26dbe7a14fdca9f5b20d13e828dc8c1ffe03fe90136a6bba507436ce500",
       "9ca406705ccce65eb8cbf63706d3df09fcc67216c0dc3990270731aacbb2e607",
       "eec0d15a7c1140f6e8705c8ba9658198ccfa8cca7f0cc8a57eb4745d77b9fe08"},

      {"eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a",
       "0000000000000000000000000000000000000000000000000000000000000000",
       "eef80ad5a9aad8b35b84f6a4eb3a7e2b222f403d455d8cdf40ad27e4cd5ae90a"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "39897fbebf137a34572b014b0638ac0186d17874e3cc142ebdfe24327f5b8509",
       "b44a769e5a4f98237f71f657d8c132137a2e878b1c33ebd14201dbcd80a47a06"},

      {"0200000000000000000000000000000000000000000000000000000000000000",
       "e3d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0c00000000000000000000000000000000000000000000000000000000000000"},

      {"e3d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0800000000000000000000000000000000000000000000000000000000000000",
       "dbd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010"},

      {"ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0000000000000000000000000000000000000000000000000000000000000000",
       "ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010",
       "0100000000000000000000000000000000000000000000000000000000000000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "0000000000000000000000000000000000000000000000000000000000000010",
       "edd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "ffffff3f00000000000000000000000000000000000000000000000000000010",
       "eed3f51c1a631258d69cf7a2def9de1400000000000000000000000000000000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "edd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000000",
       "0000000000000000000000000000000000000000000000000000000000000010"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "e75f947f11d49d25a137fac8757538a980dec23811235cf63c48ee6bc6e4ed03",
       "067461dd088f74323565fdd96884a66b7f213dc7eedca309c3b71194391b120c"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "ecd3f55c1a631258d69cf7a2def9de140000000000000000000000000000ff0f",
       "0100000000000000000000000000000000000000000000000000000000000100"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "edd3f55c1a631258d69cf7a2def9de140000000000000000000004000000ff0f",
       "0000000000000000000000000000000000000000000000000000fcffffff0000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "edd3f55c1a631258d69cf7a2def9de150000c0ffffffffffffffffffffffff0f",
       "000000000000000000000000000000ffffff3f00000000000000000000000000"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "edd3f55c1a631258d69cf7a2def9de1200000000000000000000000000000110",
       "edd3f55c1a631258d69cf7a2def9de160000000000000000000000000000ff0f"},

      {"0000000000000000000000000000000000000000000000000000000000000000",
       "edd3f55c1a631258d69cf7a2def9de1300000000000000000000000000000010",
       "0000000000000000000000000000000100000000000000000000000000000000"},
  };

  unsigned char buff[32];
  bignum256modm a = {0}, b = {0}, c = {0};

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    expand256_modm(a, fromhex(tests[i][0]), 32);
    expand256_modm(b, fromhex(tests[i][1]), 32);
    sub256_modm(c, a, b);
    contract256_modm(buff, c);
    ck_assert_mem_eq(buff, fromhex(tests[i][2]), 32);
  }
}
END_TEST

START_TEST(test_ge25519_double_scalarmult_vartime2) {
  char tests[][5][65] = {
      {"c537208ed4985e66e9f7a35c9a69448a732ba93960bbbd2823604f7ae9e3ed08",
       "365233e5af17c8888d5ce508787464f4642e91a6212b1b104e6c3769535601b1",
       "a84f871580176708b4ac21843cb197ad96e8456034442b50859c83c5807b9901",
       "f022360d1bce903fa3ac58ae42f997328b31f477b8d576a9f6d26fc1d08f14ea",
       "bf25da82c6b210948b823ae48422a2dcd205d3c94842e68ac27e5cbeaa704ebc"},
      {"4abfabc0dda33588a98127ef3bfe724fed286395fe15932e898b5621661ea102",
       "e5fd79d03f5df8edfc8def663dcb96bba6cadf857f2ae6f6f51f52f8d14079b7",
       "4754c286b23e3c1b50054fe3937ebdc4ec01b28da5d05fb6111798b42fc5bf06",
       "b7e7f9464b98de5bfcf6b02c1b7053cc359df407ad59d943523c6d2ee773b2f6",
       "6d7d5f729bfa4882dbff8e477cd2b4c354ba347f10e7b178a24f3f16a4e0fec6"},
      {"19f2af4d04cb8181f1fe0d01fe9bb9ecc476c67ceb4a9830dae1bc7fe5fe3b04",
       "d3c462f4f30991220387a1fbbd1ba1dc45ce058c70a8fb1475071e7b4f0fc463",
       "577790e025c1fd2014db44a8d613c4e2ab1f248a4a6d14b5d39cbbafd7b20f06",
       "1376c6837f131f6cd1a45b1056297d2314aa0ac5f7d581d2d878261eb3259b4d",
       "ce790760ada87dd819b59e4f6765d836d346567ec34f02bbcfcae0585c1d758f"},
      {"cf209db9e7ee85f1e648924ec97edd86b56a833b25707519d4fbe64fd50e150a",
       "804f0806087dc665a26230ed5fd44c062980ee182a6bd7dbdb33df018c983778",
       "30d3c448cb08935309753b3051366f52328ca1d9a0b63c72b989edee0da32b0e",
       "98e3c973a7e85b5eab8111521c66ca584bed5597f060ab0c6b5cdeece502ac48",
       "2646276e1305396a1b2473690066011a39789570a09e10ce1a013c8f32cd5bea"},
      {"b0a0ffeea67b656c4c585ba58ff528a6f45d2f915db98e4a14a8ff17f27fc105",
       "4fabe16274f6af526ee053028485db6acd13804e02dcdddccc4183a319ab9e1c",
       "1e140bb08a936ac6b7437644ca0769f3c165c7aa5501d49f064a0346179b4008",
       "68fc1be64fb68761542a655b8dbebf50980f1fbc1845528df8d8a06bf89a1495",
       "7dab86994b47014efe38493fc2b62ffcead806da6e0d73c992db8cb5618a19dc"},
      {"0fee422c2294b06ca83bc3704384dffc580e7ff5921881e51a755e5f9b80af03",
       "4359a663ead3f7ffc3a0ead5c3c2bde348017e7bfa620f21759c32e469a16dfe",
       "532066e3eec29334fffc37b17178dfbac3bee15f7845f01449ddbaf5e57a7b0c",
       "32e46c2fb99402837631c8175db31cdd334c145f922be9070d62e6d9c493c3ea",
       "8c7b7d2d61cdb648960434d894787426a76d16dd46949c7aa4b85dcf1054b4d5"},
      {"3a712d5b7ceb5257dcf6e6bb06548de6ef3deba5d456cd91fc305a12b46b5d01",
       "5e7da62e3ec42cf3e554639dd4d2006754ee6839b720cadba94a26b73b1665ee",
       "2a518ecab17a2d9dde219c775bcf4f2306b190bef2dea34fb65b8e4dccc13405",
       "3b5d66a4dfb068923b3bc21cc8b40b59e12f845e0b85a86d394db0fa310bf185",
       "2ec17f1cc0be093e9cdb741a991c0f417230dea275cd7babdad35e949e250521"},
      {"5f815f2d65cef584c5e5d48b2d3d3e4cae310d70b328f88af6e9f63c52b4c90d",
       "8a539a8c6b2339922b31cf4bc064f1fedeb3912fd89585d79dfcff2a60aee295",
       "385f7132b72db04146b9e472736b32adfca29556b4775a743c18e2bfab939007",
       "884aaf96d625968ddb2582922a87abca131272884c47f6b86890ebccf0a79d5b",
       "a7afdaf24fe8472d8b89e95c3ce4a40bdf700af7cedee44ed3aa5ccca09839bd"},
      {"a043340d072df16a8ab5135f8c1d601bff14c5aba01b9212b886ad71fe164506",
       "52f6de5fa0fae32d4020a54d395319509d6b92092a0bf849fb34e73f8e71fc99",
       "37d7472d360164da29e6dcb8f9796976022571c5df4ddf7e30e9a579ba13d509",
       "8c369e3fd5b1112e4437b1f09e987acca4966f2f8c5227eb15ace240a2c64cc7",
       "fc795fe7baff5c3ac98366e6882f25874ea2b0a649d16f139e5c54ea47042a1e"},
      {"97a3268db03fa184c8cba020bf216fc789292fa9615a28962385b86870ffd70f",
       "a76c215587022bb9252ece4c5afeb0e65b820834cd41ac76e6c062d3eea75dc6",
       "8310271017154cbddf7005e24eb9a9a86777b3f42fa5e35095eafaac4eb24802",
       "b822665c2406083c851ecaa91ea67aa740c057e7679b5755cee60a6c63f17fd6",
       "f83e2444527056eba595d49bde40b2e8da76d2c145f203331d26e94560993fbc"},
      {"edaad13efad39f26298e86ba8d06a46e59122232c9529bd22f2f656595421e00",
       "f38e56a79f5159eb3b581dea537ec12c9c6fac381b2cf6073e27fc621197cb62",
       "1eea79485954b5958d9d5478f86133af1088806d923535d483b115ab23099a0f",
       "b32c5e57d57db7a349f4ab845f12a5045c52b4a7a5bce7fd54a1a255b0118185",
       "3bfb42b4ffd2c6cfc8cce9e4187dc6fbcaecd9d44a4ca1d2b68b97410bb25b81"},
      {"b15eaebe0fc83cb11d755a6f067b710204d4a59101078d8286454b652879080a",
       "4667a2e61d9df1690f5c33c4168e480f7e26d2f0998168ebdc0a39712946f741",
       "125379da1a88bfdf5b928f8795d3ea5415ef8c3d9106eb16934c3842873fd707",
       "8727a692a25e38b1afa98e3dd5bf88815dec6d9810c1fd8a31b56b3de8630f1e",
       "540883dde400b909e9955a276c20e13d99252ebe542750b8bfbbe5c3b87c51e3"},
      {"e42bdd4af3121bea644a90a76b2007615621ee5b842b9a74c4334ac309478706",
       "6dc4ab715d3bb975ebfd0f08e2b6f3f39922d0121ae518a8f8d2952ea2fe0b5d",
       "0285059b0095c97f4a50d43c7726c64c2830bf2b55dfa934ebba7ad71064dc07",
       "f738c0a3cee31fd8f438f282aa6c823fccfa49cf7b5c86fbf9d56bf0394b6d8d",
       "a1bd106841e55010decd95a170a1d0dd11780fd00759819e024b15ea3a83b4be"},
      {"5077c30fd08795dbdc7a230c050ca07e316fa3b040fd0dac45907036ab25dd0e",
       "96f0897f000e49e2439a9166cab40ebc125a31b82851f0541516c19683e7bfaf",
       "2b67d79a2efdc6451508e7f3c97c4a61b135bb839c02338bb444ef8208dd970b",
       "7ef4cd7cdc29c2b88ccff49898b5d0b7be5993f93c5772476feec9dc57d7b6e3",
       "62449b901b25760c964704b28efc184fbd5947e83851ebaf3bbfeb6f742f679f"},
      {"a4b3ce6928fe8f77d13e65ae255eee8310ab0d75bca47028b4570f0511a66006",
       "4e9da8d77ee337e3bcce3730ccfff2121728641c7bb4fdeb2155890f998af09a",
       "ff01a5075569d0f6afee45da065c72f5841f46ce772917ef75eb4d230473580f",
       "36ca32da8a10f4083f5a60ee21868d9d448548d49c56f19cbe6005005e34f816",
       "99df362a3b762cc1cbb70bc5ddff3c8614ed306037013102e387ef32e7f2494f"},
      {"074aa76351dceb752aa09887d9aca932d5821f58eedb4988fd64d8548e3f2c09",
       "588b4552f3b98b2f77aee2ef8cc72f88acd424c4373b3e3626393ed2ea24cbda",
       "f2d9175633f2e3c661b01172b4b4176850cd5b3098ffb0f927e0a5e19c1c8a02",
       "a6c34868736b2517fd46f57a4e30805ffd475e44a8b1413078f43d9cb3d6edd6",
       "46e1e7d7b1e939dd5c07c8363af01f4f9dae7c3d10f237ff9776ddc4a1903771"},
      {"ae1c8abd5a542208ee0aa93ffbf0b8e5a957edc4854fe2b48153c5c85bbf3d08",
       "5e084b9541a70bd5bef400be6525c5a806a5b7fb12de38b07dcd35a22c57edbe",
       "d95f179a215fb322d81720bf3aecde78d6d676d6f941455d0e0920f1e3619707",
       "c3e5d43221824de51d8f95705de69c80a2440c0483ca88549d639aee15390429",
       "df9fea42d3b5ac243244abb4ca4948a69493becddc5d5906f9a4e4c5645b0eab"},
      {"2f1c5adedb7341dc7638bafacc6024bd48255197ea2347fc05714b9341dd4403",
       "47f55263001542f796c928988f641f59d0cd43294fc8d8616b184bfe9dddf368",
       "aa5e884e782ab116151c609680c37b1a49b52f23bce5e2ebf28dd8532510d20b",
       "ef2d6d97ad1a18edfce6450c1e70295b2c7ed2bc749ea8b438a523eae078d1f3",
       "2396a355c6ae8e2ac24da8f55a674c96fc4cc69b38678b2bd8eb91b96f462bca"},
      {"0242e14105ced74e91cf4d4dcd22a9c09279018901d2fb8319eb54c2a1c4900a",
       "fcb62a6c520d31fa46efeb4a1000330653b3402f575c2ddc0c688f527e7b97be",
       "73a7e2e0602e5345f040dedc4db67f6d8e37c5fca3bbb124fa43963d76dbbb08",
       "152bf4a3305c656f77e292b1256cc470da4d3f6efc3667199db4316d7f431174",
       "c21ba2080013dfb225e06378d9ac27df623df552526cfddbf9e71bb1d4705dd9"},
      {"07fab4fc7b02fbcf868ffb0326cf60425fef2af1fbad83a8926cc62c2b5dff05",
       "29ff12c5e052eb5829e8334e0e082c5edde1f293d2b4ed499a79bcca20e48010",
       "97afb3dd9167877b432a23503aad1ab39188b9be07cc124ceb3fbdbd8d8b890a",
       "ed121240a2f4591eeedbfd880305ccd17e522673900b03279fb66e73583514ae",
       "b27f209e88ce5701766565e231e8123adb1df9c9f1dc461920acbc2b38d9f6d7"},
  };

  unsigned char buff[32];
  bignum256modm a = {0}, b = {0};
  ge25519 A, B, R;

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    expand256_modm(a, fromhex(tests[i][0]), 32);
    expand256_modm(b, fromhex(tests[i][2]), 32);
    ge25519_unpack_negative_vartime(&A, fromhex(tests[i][1]));
    curve25519_neg(A.x, A.x);
    curve25519_neg(A.t, A.t);
    ge25519_unpack_negative_vartime(&B, fromhex(tests[i][3]));
    curve25519_neg(B.x, B.x);
    curve25519_neg(B.t, B.t);
    ge25519_double_scalarmult_vartime2(&R, &A, a, &B, b);
    ge25519_pack(buff, &R);
    ck_assert_mem_eq(buff, fromhex(tests[i][4]), 32);
  }
}
END_TEST

static void test_bip32_ecdh_init_node(HDNode *node, const char *seed_str,
                                      const char *curve_name) {
  hdnode_from_seed((const uint8_t *)seed_str, strlen(seed_str), curve_name,
                   node);
  hdnode_fill_public_key(node);
  if (node->public_key[0] == 1) {
    node->public_key[0] = 0x40;  // Curve25519 public keys start with 0x40 byte
  }
}

static void test_bip32_ecdh(const char *curve_name, int expected_key_size,
                            const uint8_t *expected_key) {
  int res, key_size;
  HDNode alice, bob;
  uint8_t session_key1[expected_key_size], session_key2[expected_key_size];

  test_bip32_ecdh_init_node(&alice, "Alice", curve_name);
  test_bip32_ecdh_init_node(&bob, "Bob", curve_name);

  // Generate shared key from Alice's secret key and Bob's public key
  res = hdnode_get_shared_key(&alice, bob.public_key, session_key1, &key_size);
  ck_assert_int_eq(res, 0);
  ck_assert_int_eq(key_size, expected_key_size);
  ck_assert_mem_eq(session_key1, expected_key, key_size);

  // Generate shared key from Bob's secret key and Alice's public key
  res = hdnode_get_shared_key(&bob, alice.public_key, session_key2, &key_size);
  ck_assert_int_eq(res, 0);
  ck_assert_int_eq(key_size, expected_key_size);
  ck_assert_mem_eq(session_key2, expected_key, key_size);
}

START_TEST(test_bip32_ecdh_nist256p1) {
  test_bip32_ecdh(
      NIST256P1_NAME, 65,
      fromhex(
          "044aa56f917323f071148cd29aa423f6bee96e7fe87f914d0b91a0f95388c6631646"
          "ea92e882773d7b0b1bec356b842c8559a1377673d3965fb931c8fe51e64873"));
}
END_TEST

START_TEST(test_bip32_ecdh_curve25519) {
  test_bip32_ecdh(CURVE25519_NAME, 33,
                  fromhex("04f34e35516325bb0d4a58507096c444a05ba13524ccf66910f1"
                          "1ce96c62224169"));
}
END_TEST

START_TEST(test_bip32_ecdh_errors) {
  HDNode node;
  const uint8_t peer_public_key[65] = {0};  // invalid public key
  uint8_t session_key[65];
  int res, key_size = 0;

  test_bip32_ecdh_init_node(&node, "Seed", ED25519_NAME);
  res = hdnode_get_shared_key(&node, peer_public_key, session_key, &key_size);
  ck_assert_int_eq(res, 1);
  ck_assert_int_eq(key_size, 0);

  test_bip32_ecdh_init_node(&node, "Seed", CURVE25519_NAME);
  res = hdnode_get_shared_key(&node, peer_public_key, session_key, &key_size);
  ck_assert_int_eq(res, 1);
  ck_assert_int_eq(key_size, 0);

  test_bip32_ecdh_init_node(&node, "Seed", NIST256P1_NAME);
  res = hdnode_get_shared_key(&node, peer_public_key, session_key, &key_size);
  ck_assert_int_eq(res, 1);
  ck_assert_int_eq(key_size, 0);
}
END_TEST

START_TEST(test_output_script) {
  static const char *vectors[] = {
      "76A914010966776006953D5567439E5E39F86A0D273BEE88AC",
      "16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM",
      "A914010966776006953D5567439E5E39F86A0D273BEE87",
      "31nVrspaydBz8aMpxH9WkS2DuhgqS1fCuG",
      "0014010966776006953D5567439E5E39F86A0D273BEE",
      "p2xtZoXeX5X8BP8JfFhQK2nD3emtjch7UeFm",
      "00200102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20",
      "7XhPD7te3C6CVKnJWUhrTJbFTwudhHqfrjpS59AS6sMzL4RYFiCNg",
      0,
      0,
  };
  const char **scr, **adr;
  scr = vectors;
  adr = vectors + 1;
  char address[60];
  while (*scr && *adr) {
    int r =
        script_output_to_address(fromhex(*scr), strlen(*scr) / 2, address, 60);
    ck_assert_int_eq(r, (int)(strlen(*adr) + 1));
    ck_assert_str_eq(address, *adr);
    scr += 2;
    adr += 2;
  }
}
END_TEST

START_TEST(test_ethereum_pubkeyhash) {
  uint8_t pubkeyhash[20];
  int res;
  HDNode node;

  // init m
  hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16,
                   SECP256K1_NAME, &node);

  // [Chain m]
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("056db290f8ba3250ca64a45d16284d04bc6f5fbf"), 20);

  // [Chain m/0']
  hdnode_private_ckd_prime(&node, 0);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("bf6e48966d0dcf553b53e7b56cb2e0e72dca9e19"), 20);

  // [Chain m/0'/1]
  hdnode_private_ckd(&node, 1);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("29379f45f515c494483298225d1b347f73d1babf"), 20);

  // [Chain m/0'/1/2']
  hdnode_private_ckd_prime(&node, 2);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("d8e85fbbb4b3b3c71c4e63a5580d0c12fb4d2f71"), 20);

  // [Chain m/0'/1/2'/2]
  hdnode_private_ckd(&node, 2);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("1d3462d2319ac0bfc1a52e177a9d372492752130"), 20);

  // [Chain m/0'/1/2'/2/1000000000]
  hdnode_private_ckd(&node, 1000000000);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("73659c60270d326c06ac204f1a9c63f889a3d14b"), 20);

  // init m
  hdnode_from_seed(
      fromhex(
          "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c"
          "999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"),
      64, SECP256K1_NAME, &node);

  // [Chain m]
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("6dd2a6f3b05fd15d901fbeec61b87a34bdcfb843"), 20);

  // [Chain m/0]
  hdnode_private_ckd(&node, 0);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("abbcd4471a0b6e76a2f6fdc44008fe53831e208e"), 20);

  // [Chain m/0/2147483647']
  hdnode_private_ckd_prime(&node, 2147483647);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("40ef2cef1b2588ae862e7a511162ec7ff33c30fd"), 20);

  // [Chain m/0/2147483647'/1]
  hdnode_private_ckd(&node, 1);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("3f2e8905488f795ebc84a39560d133971ccf9b50"), 20);

  // [Chain m/0/2147483647'/1/2147483646']
  hdnode_private_ckd_prime(&node, 2147483646);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("a5016fdf975f767e4e6f355c7a82efa69bf42ea7"), 20);

  // [Chain m/0/2147483647'/1/2147483646'/2]
  hdnode_private_ckd(&node, 2);
  res = hdnode_get_ethereum_pubkeyhash(&node, pubkeyhash);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(pubkeyhash,
                   fromhex("8ff2a9f7e7917804e8c8ec150d931d9c5a6fbc50"), 20);
}
END_TEST

START_TEST(test_ethereum_address) {
  static const char *vectors[] = {"52908400098527886E0F7030069857D2E4169EE7",
                                  "8617E340B3D01FA5F11F306F4090FD50E238070D",
                                  "de709f2102306220921060314715629080e2fb77",
                                  "27b1fdb04752bbc536007a920d24acb045561c26",
                                  "5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
                                  "fB6916095ca1df60bB79Ce92cE3Ea74c37c5d359",
                                  "dbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB",
                                  "D1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",
                                  "5A4EAB120fB44eb6684E5e32785702FF45ea344D",
                                  "5be4BDC48CeF65dbCbCaD5218B1A7D37F58A0741",
                                  "a7dD84573f5ffF821baf2205745f768F8edCDD58",
                                  "027a49d11d118c0060746F1990273FcB8c2fC196",
                                  "CD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
                                  0};
  uint8_t addr[20];
  char address[41];
  const char **vec = vectors;
  while (*vec) {
    memcpy(addr, fromhex(*vec), 20);
    ethereum_address_checksum(addr, address, false, 0);
    ck_assert_str_eq(address, *vec);
    vec++;
  }
}
END_TEST

// test vectors from
// https://github.com/rsksmart/RSKIPs/blob/master/IPs/RSKIP60.md
START_TEST(test_rsk_address) {
  uint8_t addr[20];
  char address[41];

  static const char *rskip60_chain30[] = {
      "5aaEB6053f3e94c9b9a09f33669435E7ef1bEAeD",
      "Fb6916095cA1Df60bb79ce92cE3EA74c37c5d359",
      "DBF03B407c01E7CD3cBea99509D93F8Dddc8C6FB",
      "D1220A0Cf47c7B9BE7a2e6ba89F429762E7B9adB", 0};
  const char **vec = rskip60_chain30;
  while (*vec) {
    memcpy(addr, fromhex(*vec), 20);
    ethereum_address_checksum(addr, address, true, 30);
    ck_assert_str_eq(address, *vec);
    vec++;
  }

  static const char *rskip60_chain31[] = {
      "5aAeb6053F3e94c9b9A09F33669435E7EF1BEaEd",
      "Fb6916095CA1dF60bb79CE92ce3Ea74C37c5D359",
      "dbF03B407C01E7cd3cbEa99509D93f8dDDc8C6fB",
      "d1220a0CF47c7B9Be7A2E6Ba89f429762E7b9adB", 0};
  vec = rskip60_chain31;
  while (*vec) {
    memcpy(addr, fromhex(*vec), 20);
    ethereum_address_checksum(addr, address, true, 31);
    ck_assert_str_eq(address, *vec);
    vec++;
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/NemProject/nem-test-vectors/master/1.test-keys.dat
START_TEST(test_nem_address) {
  static const struct {
    const char *private_key;
    const char *public_key;
    const char *address;
  } tests[] = {
      {
          "575dbb3062267eff57c970a336ebbc8fbcfe12c5bd3ed7bc11eb0481d7704ced",
          "c5f54ba980fcbb657dbaaa42700539b207873e134d2375efeab5f1ab52f87844",
          "NDD2CT6LQLIYQ56KIXI3ENTM6EK3D44P5JFXJ4R4",
      },
      {
          "5b0e3fa5d3b49a79022d7c1e121ba1cbbf4db5821f47ab8c708ef88defc29bfe",
          "96eb2a145211b1b7ab5f0d4b14f8abc8d695c7aee31a3cfc2d4881313c68eea3",
          "NABHFGE5ORQD3LE4O6B7JUFN47ECOFBFASC3SCAC",
      },
      {
          "738ba9bb9110aea8f15caa353aca5653b4bdfca1db9f34d0efed2ce1325aeeda",
          "2d8425e4ca2d8926346c7a7ca39826acd881a8639e81bd68820409c6e30d142a",
          "NAVOZX4HDVOAR4W6K4WJHWPD3MOFU27DFHC7KZOZ",
      },
      {
          "e8bf9bc0f35c12d8c8bf94dd3a8b5b4034f1063948e3cc5304e55e31aa4b95a6",
          "4feed486777ed38e44c489c7c4e93a830e4c4a907fa19a174e630ef0f6ed0409",
          "NBZ6JK5YOCU6UPSSZ5D3G27UHAPHTY5HDQMGE6TT",
      },
      {
          "c325ea529674396db5675939e7988883d59a5fc17a28ca977e3ba85370232a83",
          "83ee32e4e145024d29bca54f71fa335a98b3e68283f1a3099c4d4ae113b53e54",
          "NCQW2P5DNZ5BBXQVGS367DQ4AHC3RXOEVGRCLY6V",
      },
      {
          "a811cb7a80a7227ae61f6da536534ee3c2744e3c7e4b85f3e0df3c6a9c5613df",
          "6d34c04f3a0e42f0c3c6f50e475ae018cfa2f56df58c481ad4300424a6270cbb",
          "NA5IG3XFXZHIPJ5QLKX2FBJPEZYPMBPPK2ZRC3EH",
      },
      {
          "9c66de1ec77f4dfaaebdf9c8bc599ca7e8e6f0bc71390ffee2c9dd3f3619242a",
          "a8fefd72a3b833dc7c7ed7d57ed86906dac22f88f1f4331873eb2da3152a3e77",
          "NAABHVFJDBM74XMJJ52R7QN2MTTG2ZUXPQS62QZ7",
      },
      {
          "c56bc16ecf727878c15e24f4ae68569600ac7b251218a44ef50ce54175776edc",
          "c92f761e6d83d20068fd46fe4bd5b97f4c6ba05d23180679b718d1f3e4fb066e",
          "NCLK3OLMHR3F2E3KSBUIZ4K5PNWUDN37MLSJBJZP",
      },
      {
          "9dd73599283882fa1561ddfc9be5830b5dd453c90465d3fe5eeb646a3606374e",
          "eaf16a4833e59370a04ccd5c63395058de34877b48c17174c71db5ed37b537ed",
          "ND3AHW4VTI5R5QE5V44KIGPRU5FBJ5AFUCJXOY5H",
      },
      {
          "d9639dc6f49dad02a42fd8c217f1b1b4f8ce31ccd770388b645e639c72ff24fa",
          "0f74a2f537cd9c986df018994dde75bdeee05e35eb9fe27adf506ca8475064f7",
          "NCTZ4YAP43ONK3UYTASQVNDMBO24ZHJE65F3QPYE",
      },
      {
          "efc1992cd50b70ca55ac12c07aa5d026a8b78ffe28a7dbffc9228b26e02c38c1",
          "2ebff201255f6cf948c78f528658b99a7c13ac791942fa22d59af610558111f5",
          "NDQ2TMCMXBSFPZQPE2YKH6XLC24HD6LUMN6Z4GIC",
      },
      {
          "143a815e92e43f3ed1a921ee48cd143931b88b7c3d8e1e981f743c2a5be3c5ba",
          "419ed11d48730e4ae2c93f0ea4df853b8d578713a36dab227517cf965861af4e",
          "NA32IDDW2C53BDSBJNFL3Z6UU3J5CJZJMCZDXCF4",
      },
      {
          "bc1a082f5ac6fdd3a83ade211e5986ac0551bad6c7da96727ec744e5df963e2a",
          "a160e6f9112233a7ce94202ed7a4443e1dac444b5095f9fecbb965fba3f92cac",
          "NADUCEQLC3FTGB25GTA5HOUTB53CBVQNVOIP7NTJ",
      },
      {
          "4e47b4c6f4c7886e49ec109c61f4af5cfbb1637283218941d55a7f9fe1053f72",
          "fbb91b16df828e21a9802980a44fc757c588bc1382a4cea429d6fa2ae0333f56",
          "NBAF3BFLLPWH33MYE6VUPP5T6DQBZBKIDEQKZQOE",
      },
      {
          "efc4389da48ce49f85365cfa578c746530e9eac42db1b64ec346119b1becd347",
          "2232f24dda0f2ded3ecd831210d4e8521a096b50cadd5a34f3f7083374e1ec12",
          "NBOGTK2I2ATOGGD7ZFJHROG5MWL7XCKAUKSWIVSA",
      },
      {
          "bdba57c78ca7da16a3360efd13f06276284db8c40351de7fcd38ba0c35ac754d",
          "c334c6c0dad5aaa2a0d0fb4c6032cb6a0edd96bf61125b5ea9062d5a00ee0eee",
          "NCLERTEFYXKLK7RA4MVACEFMXMK3P7QMWTM7FBW2",
      },
      {
          "20694c1ec3c4a311bcdb29ed2edc428f6d4f9a4c429ad6a5bf3222084e35695f",
          "518c4de412efa93de06a55947d11f697639443916ec8fcf04ebc3e6d17d0bd93",
          "NB5V4BPIJHXVONO7UGMJDPFARMFA73BOBNOOYCOV",
      },
      {
          "e0d4f3760ac107b33c22c2cac24ab2f520b282684f5f66a4212ff95d926323ce",
          "b3d16f4ead9de67c290144da535a0ed2504b03c05e5f1ceb8c7863762f786857",
          "NC4PBAO5TPCAVQKBVOC4F6DMZP3CFSQBU46PSKBD",
      },
      {
          "efa9afc617412093c9c7a7c211a5332dd556f941e1a88c494ec860608610eea2",
          "7e7716e4cebceb731d6f1fd28676f34888e9a0000fcfa1471db1c616c2ddf559",
          "NCFW2LPXIWLBWAQN2QVIWEOD7IVDO3HQBD2OU56K",
      },
      {
          "d98499b3db61944684ce06a91735af4e14105338473fcf6ebe2b0bcada3dfd21",
          "114171230ad6f8522a000cdc73fbc5c733b30bb71f2b146ccbdf34499f79a810",
          "NCUKWDY3J3THKQHAKOK5ALF6ANJQABZHCH7VN6DP",
      },
  };

  HDNode node;
  ed25519_secret_key private_key;
  uint8_t chain_code[32];
  char address[41];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    nem_private_key(tests[i].private_key, private_key);

    ck_assert(hdnode_from_xprv(0, 0, chain_code, private_key,
                               ED25519_KECCAK_NAME, &node));

    ck_assert(hdnode_get_nem_address(&node, NEM_NETWORK_MAINNET, address));
    ck_assert_str_eq(address, tests[i].address);

    ck_assert_mem_eq(&node.public_key[1], fromhex(tests[i].public_key), 32);
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/NemProject/nem-test-vectors/master/3.test-derive.dat
START_TEST(test_nem_derive) {
  static const struct {
    const char *salt;
    const char *private_key;
    const char *public_key;
    const char *mul;
    const char *shared_key;
  } tests[] = {
      {
          "ad63ac08f9afc85eb0bf4f8881ca6eaa0215924c87aa2f137d56109bb76c6f98",
          "e8857f8e488d4e6d4b71bcd44bb4cff49208c32651e1f6500c3b58cafeb8def6",
          "9d8e5f200b05a2638fb084a375408cabd6d5989590d96e3eea5f2cb34668178e",
          "a8352060ba5718745ee4d78b9df564e0fbe13f50d50ab15a8dd524159d81d18b",
          "990a5f611c65fbcde735378bdec38e1039c5466503511e8c645bbe42795c752b",
      },
      {
          "96104f0a28f9cca40901c066cd435134662a3b053eb6c8df80ee0d05dc941963",
          "d7f67b5f52cbcd1a1367e0376a8eb1012b634acfcf35e8322bae8b22bb9e8dea",
          "9735c92d150dcee0ade5a8d1822f46a4db22c9cda25f33773ae856fe374a3e8a",
          "ea14d521d83328dba70982d42094300585818cc2da609fdb1f73bb32235576ff",
          "b498aa21d4ba4879ea9fd4225e93bacc760dcd9c119f8f38ab0716457d1a6f85",
      },
      {
          "d8f94a0bbb1de80aea17aab42e2ffb982e73fc49b649a318479e951e392d8728",
          "d026ddb445fb3bbf3020e4b55ed7b5f9b7fd1278c34978ca1a6ed6b358dadbae",
          "d19e6beca3b26b9d1abc127835ebeb7a6c19c33dec8ec472e1c4d458202f4ec8",
          "0d561f54728ad837ae108ec66c2ece2bb3b26041d3ee9b77fdc6d36d9ebfb2e3",
          "d012afe3d1d932304e613c91545bf571cf2c7281d6cafa8e81393a551f675540",
      },
      {
          "3f8c969678a8abdbfb76866a142c284a6f01636c1c1607947436e0d2c30d5245",
          "c522b38c391d1c3fa539cc58802bc66ac34bb3c73accd7f41b47f539bedcd016",
          "ea5b6a0053237f7712b1d2347c447d3e83e0f2191762d07e1f53f8eb7f2dfeaa",
          "23cccd3b63a9456e4425098b6df36f28c8999461a85e4b2b0c8d8f53c62c9ea9",
          "7e27efa50eed1c2ac51a12089cbab6a192624709c7330c016d5bc9af146584c1",
      },
      {
          "e66415c58b981c7f1f2b8f45a42149e9144616ff6de49ff83d97000ac6f6f992",
          "2f1b82be8e65d610a4e588f000a89a733a9de98ffc1ac9d55e138b3b0a855da0",
          "65aeda1b47f66c978a4a41d4dcdfbd8eab5cdeb135695c2b0c28f54417b1486d",
          "43e5b0a5cc8146c03ac63e6f8cf3d8825a9ca1ed53ea4a88304af4ddf5461b33",
          "bb4ab31c334e55d378937978c90bb33779b23cd5ef4c68342a394f4ec8fa1ada",
      },
      {
          "58487c9818c9d28ddf97cb09c13331941e05d0b62bf4c35ee368de80b552e4d1",
          "f3869b68183b2e4341307653e8f659bd7cd20e37ea5c00f5a9e203a8fa92359a",
          "c7e4153a18b4162f5c1f60e1ba483264aa5bb3f4889dca45b434fcd30b9cf56f",
          "5ae9408ab3156b8828c3e639730bd5e5db93d7afe2cee3fcda98079316c5bb3a",
          "0224d85ae8f17bfe127ec24b8960b7639a0dbde9c8c39a0575b939448687bb14",
      },
      {
          "ad66f3b654844e53d6fb3568134fae75672ba63868c113659d3ca58c2c39d24f",
          "d38f2ef8dfdc7224fef596130c3f4ff68ac83d3f932a56ee908061466ac28572",
          "d0c79d0340dc66f0a895ce5ad60a933cf6be659569096fb9d4b81e5d32292372",
          "1ea22db4708ed585ab541a4c70c3069f8e2c0c1faa188ddade3efaa53c8329f6",
          "886a7187246934aedf2794748deadfe038c9fd7e78d4b7be76c5a651440ac843",
      },
      {
          "eed48604eab279c6ad8128aa83483a3da0928271a4cae1a5745671284e1fb89d",
          "e2342a8450fc0adfa0ea2fbd0b1d28f100f0a3a905a3da29de34d1353afa7df7",
          "d2dbe07e0f2dbc3dbb01c70092e3c4247d12827ddcd8d76534fd740a65c30de2",
          "4c4b30eb6a2bfa17312f5729b4212cb51c2eee8fbfaea82a0e957ca68f4f6a30",
          "dcae613ac5641ff9d4c3ca58632245f93b0b8657fe4d48bac7b062cc53dd21ad",
      },
      {
          "f35b315287b268c0d0b386fb5b31810f65e1c4497cffae24527f69a3abac3884",
          "049016230dbef7a14a439e5ab2f6d12e78cb8df127db4e0c312673b3c361e350",
          "1b3b1925a8a535cd7d78725d25298f45bba8ca3dee2cdaabf14241c9b51b37c4",
          "04c9685dae1f8eb72a6438f24a87dc83a56d79c9024edf7e01aa1ae34656f29e",
          "b48469d0428c223b93cd1fe34bb2cafd3fb78a8fa15f98f89f1ac9c0ce7c9001",
      },
      {
          "d6cf082c5d9a96e756a94a2e27703138580a7c7c1af505c96c3abf7ab6802e1d",
          "67cd02b0b8b0adcf6fdd4d4d64a1f4193ced68bb8605d0ec941a62011326d140",
          "a842d5127c93a435e4672dcadd9fccbfd0e9208c79c5404848b298597eccdbdb",
          "d5c6bd6d81b99659d0bafe91025b6ecf73b16c6b07931cf44718b13f00fde3f7",
          "8aa160795b587f4be53aa35d26e9b618b4cd6ec765b523bc908e53c258ca8fd4",
      },
      {
          "dda32c91c95527a645b00dd05d13f0b98ed612a726ce5f5221431430b7660944",
          "eba026f92a8ffb5e95060a22e15d597fe838a99a0b2bbcb423c933b6bc718c50",
          "7dbaf9c313a1ff9128c54d6cd740c7d0cc46bca588e7910d438dd619ca4fd69a",
          "5bb20a145de83ba27a0c261e1f54bfd7dcea61888fc2eebbe6166876f7b000b8",
          "3a96f152ad8bf355cccb307e4a40108aa17f8e925522a2b5bb0b3f1e1a262914",
      },
      {
          "63c500acbd4ff747f7dadde7d3286482894ac4d7fe68f396712bca29879aa65c",
          "9663cd3c2030a5fe4a3ea3cc9a1d182b3a63ade68616aaeb4caf40b495f6f227",
          "b1e7d9070ac820d986d839b79f7aa594dcf708473529dad87af8682cc6197374",
          "1f7a97584d8db9f395b9ac4447de4b33c5c1f5020187cd4996286a49b07eb8a7",
          "4d2a974ec12dcf525b5654d31053460850c3092648b7e15598b7131d2930e9fb",
      },
      {
          "91f340961029398cc8bcd906388044a6801d24328efdf919d8ed0c609862a073",
          "45a588500d00142e2226231c01fd11ac6f842ab6a85872418f5b6a1999f8bd98",
          "397233c96069b6f4a57d6e93f759fa327222eaef71fc981afa673b248206df3f",
          "062123ef9782e3893f7b2e1d557b4ecce92b9f9aa8577e76380f228b75152f84",
          "235848cb04230a16d8978aa7c19fe7fbff3ebe29389ea6eb24fb8bc3cb50afc6",
      },
      {
          "46120b4da6ba4eb54fb65213cfef99b812c86f7c42a1de1107f8e8c12c0c3b6b",
          "cc19a97a99ad71ce348bcf831c0218e6a1f0a8d52186cabe6298b56f24e640f9",
          "c54631bb62f0f9d86b3301fcb2a671621e655e578c95504af5f78da83f7fec4f",
          "ab73cc20c75260ff3a7cefea8039291d4d15114a07a9250375628cca32225bb6",
          "70040a360b6a2dfa881272ef4fa6616e2e8fcc45194fa2a21a1eef1160271cd5",
      },
      {
          "f0a69ded09f1d731ab9561d0c3a40b7ef30bcb2bf60f92beccd8734e2441403d",
          "ea732822a381c46a7ac9999bf5ef85e16b7460b26aaf6c1a1c6ffa8c8c82c923",
          "110decbff79c382b1e60af4259564a3c473087792350b24fca98ae9a74ba9dd9",
          "81bdee95aecdcf821a9d682f79056f1abdcf1245d2f3b55244447881a283e0d4",
          "1bc29d4470ccf97d4e35e8d3cd4b12e3ebf2cb0a82425d35984aeedf7ad0f6f9",
      },
      {
          "e79cf4536fb1547e57626c0f1a87f71a396fdfb985b00731c0c2876a00645eda",
          "04213fc02b59c372e3e7f53faa71a2f73b31064102cb6fc8b68432ba7cdf7eb4",
          "ca1c750aaed53bc30dac07d0696ed86bcd7cdbbcbd3d15bb90d90cb5c6117bac",
          "c68cd0872a42a3a64e8a229ef7fcad3d722047d5af966f7dda4d4e32d0d57203",
          "bfdd3d07563d966d95afe4b8abea4b567265fceea8c4ecddb0946256c33e07b2",
      },
      {
          "81a40db4cddaf076e0206bd2b0fa7470a72cc456bad34aa3a0469a4859f286be",
          "52156799fd86cc63345cdbffd65ef4f5f8df0ffd9906a40af5f41d269bbcff5d",
          "54d61aa0b0b17a87f1376fe89cd8cd6b314827c1f1b9e5e7b20e7a7eee2a8335",
          "4553fb2cab8555068c32f86ceb692bbf1c2beeaf21627ef1b1be57344b52eea8",
          "55096b6710ade3bbe38702458ee13faa10c24413261bc076f17675dcbf2c4ee6",
      },
      {
          "d28e4a9e6832a3a4dad014a2bf1f666f01093cbba8b9ad4d1dcad3ea10cb42b9",
          "8ca134404c8fa199b0c72cb53cfa0adcf196dfa560fb521017cce5cbace3ba59",
          "3a6c39a1e5f9f550f1debedd9a0bc84210cce5f9834797db8f14122bf5817e45",
          "eb632ca818b4f659630226a339a3ce536b31c8e1e686fea8da3760e8abc20b8e",
          "9fbb3fbaf1cd54ee0cd90685f59b082545983f1f662ef701332379306a6ad546",
      },
      {
          "f9c4bfad9e2a3d98c44c12734881a6f217d6c9523cc210772fad1297993454b4",
          "b85960fcadda8d0a0960559b6b7818a0d8d4574b4e928b17c9b498fa9ffab4ef",
          "6a1d0ef23ce0b40a7077ecb7b7264945054e3bdb58ee25e1b0ee8b3e19dbfcdc",
          "bb145dddcb75074a6a03249fca1aa7d6fa9549e3ed965f138ca5e7071b7878f2",
          "87d3faea4a98e41009eb8625611ea0fc12094c295af540c126c14a0f55afa76e",
      },
      {
          "656df4789a369d220aceb7b318517787d27004ecccedea019d623bcb2d79f5ff",
          "acf83e30afb2a5066728ec5d93564c08abe5e68e3a2a2ff953bdcf4d44f9da06",
          "bdda65efe56d7890286aada1452f62f85ba157d0b4621ba641de15d8d1c9e331",
          "958beef5dc6babc6de383c32ad7dd3a6d6eb8bb3236ed5558eec0f9eb31e5458",
          "6f6d4ee36d9d76e462c9635adfbb6073134a276cfc7cb86762004ec47197afa0",
      },
  };

  HDNode node;
  ed25519_secret_key private_key;
  uint8_t chain_code[32];
  ed25519_public_key public_key, mul;
  uint8_t shared_key[SHA3_256_DIGEST_LENGTH];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    nem_private_key(tests[i].private_key, private_key);

    ck_assert(hdnode_from_xprv(0, 0, chain_code, private_key,
                               ED25519_KECCAK_NAME, &node));
    memcpy(public_key, fromhex(tests[i].public_key), 32);

    ck_assert(hdnode_get_nem_shared_key(
        &node, public_key, fromhex(tests[i].salt), mul, shared_key));
    ck_assert_mem_eq(mul, fromhex(tests[i].mul), sizeof(mul));
    ck_assert_mem_eq(shared_key, fromhex(tests[i].shared_key),
                     sizeof(shared_key));
  }
}
END_TEST

// test vectors from
// https://raw.githubusercontent.com/NemProject/nem-test-vectors/master/4.test-cipher.dat
START_TEST(test_nem_cipher) {
  static const struct {
    const char *private_key;
    const char *public_key;
    const char *salt;
    const char *iv;
    const char *input;
    const char *output;
  } tests[] = {
      {
          "3140f94c79f249787d1ec75a97a885980eb8f0a7d9b7aa03e7200296e422b2b6",
          "57a70eb553a7b3fd621f0dba6abf51312ea2e2a2a1e19d0305516730f4bcbd21",
          "83616c67f076d356fd1288a6e0fd7a60488ba312a3adf0088b1b33c7655c3e6a",
          "a73ff5c32f8fd055b09775817a6a3f95",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "70815da779b1b954d7a7f00c16940e9917a0412a06a444b539bf147603eef87f",
      },
      {
          "3140f94c79f249787d1ec75a97a885980eb8f0a7d9b7aa03e7200296e422b2b6",
          "57a70eb553a7b3fd621f0dba6abf51312ea2e2a2a1e19d0305516730f4bcbd21",
          "703ce0b1d276b10eef35672df03234385a903460db18ba9d4e05b3ad31abb284",
          "91246c2d5493867c4fa3e78f85963677",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "564b2f40d42c0efc1bd6f057115a5abd1564cae36d7ccacf5d825d38401aa894",
      },
      {
          "3140f94c79f249787d1ec75a97a885980eb8f0a7d9b7aa03e7200296e422b2b6",
          "57a70eb553a7b3fd621f0dba6abf51312ea2e2a2a1e19d0305516730f4bcbd21",
          "b22e8e8e7373ac31ca7f0f6eb8b93130aba5266772a658593f3a11792e7e8d92",
          "9f8e33d82374dad6aac0e3dbe7aea704",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "7cab88d00a3fc656002eccbbd966e1d5d14a3090d92cf502cdbf843515625dcf",
      },
      {
          "3140f94c79f249787d1ec75a97a885980eb8f0a7d9b7aa03e7200296e422b2b6",
          "57a70eb553a7b3fd621f0dba6abf51312ea2e2a2a1e19d0305516730f4bcbd21",
          "af646c54cd153dffe453b60efbceeb85c1e95a414ea0036c4da94afb3366f5d9",
          "6acdf8e01acc8074ddc807281b6af888",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "aa70543a485b63a4dd141bb7fd78019092ac6fad731e914280a287c7467bae1a",
      },
      {
          "3140f94c79f249787d1ec75a97a885980eb8f0a7d9b7aa03e7200296e422b2b6",
          "57a70eb553a7b3fd621f0dba6abf51312ea2e2a2a1e19d0305516730f4bcbd21",
          "d9c0d386636c8a024935c024589f9cd39e820a16485b14951e690a967830e269",
          "f2e9f18aeb374965f54d2f4e31189a8f",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "33d97c216ea6498dfddabf94c2e2403d73efc495e9b284d9d90aaff840217d25",
      },
      {
          "d5c0762ecea2cd6b5c56751b58debcb32713aab348f4a59c493e38beb3244f3a",
          "66a35941d615b5644d19c2a602c363ada8b1a8a0dac3682623852dcab4afac04",
          "06c227baac1ae3b0b1dc583f4850f13f9ba5d53be4a98fa5c3ea16217847530d",
          "3735123e78c44895df6ea33fa57e9a72",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "d5b5d66ba8cee0eb7ecf95b143fa77a46d6de13749e12eff40f5a7e649167ccb",
      },
      {
          "d5c0762ecea2cd6b5c56751b58debcb32713aab348f4a59c493e38beb3244f3a",
          "66a35941d615b5644d19c2a602c363ada8b1a8a0dac3682623852dcab4afac04",
          "92f55ba5bc6fc2f23e3eedc299357c71518e36ba2447a4da7a9dfe9dfeb107b5",
          "1cbc4982e53e370052af97ab088fa942",
          "86ddb9e713a8ebf67a51830eff03b837e147c20d75e67b2a54aa29e98c",
          "d48ef1ef526d805656cfc932aff259eadb17aa3391dde1877a722cba31d935b2",
      },
      {
          "d5c0762ecea2cd6b5c56751b58debcb32713aab348f4a59c493e38beb3244f3a",
          "66a35941d615b5644d19c2a602c363ada8b1a8a0dac3682623852dcab4afac04",
          "10f15a39ba49866292a43b7781bc71ca8bbd4889f1616461caf056bcb91b0158",
          "c40d531d92bfee969dce91417346c892",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "e6d75afdb542785669b42198577c5b358d95397d71ec6f5835dca46d332cc08dbf73"
          "ea790b7bcb169a65719c0d55054c",
      },
      {
          "d5c0762ecea2cd6b5c56751b58debcb32713aab348f4a59c493e38beb3244f3a",
          "66a35941d615b5644d19c2a602c363ada8b1a8a0dac3682623852dcab4afac04",
          "9c01ed42b219b3bbe1a43ae9d7af5c1dd09363baacfdba8f4d03d1046915e26e",
          "059a35d5f83249e632790015ed6518b9",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "5ef11aadff2eccee8b712dab968fa842eb770818ec0e6663ed242ea8b6bbc1c66d62"
          "85ee5b5f03d55dfee382fb4fa25d",
      },
      {
          "d5c0762ecea2cd6b5c56751b58debcb32713aab348f4a59c493e38beb3244f3a",
          "66a35941d615b5644d19c2a602c363ada8b1a8a0dac3682623852dcab4afac04",
          "bc1067e2a7415ea45ff1ca9894338c591ff15f2e57ae2789ae31b9d5bea0f11e",
          "8c73f0d6613898daeefa3cf8b0686d37",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "6d220213b1878cd40a458f2a1e6e3b48040455fdf504dcd857f4f2ca1ad642e3a44f"
          "c401d04e339d302f66a9fad3d919",
      },
      {
          "9ef87ba8aa2e664bdfdb978b98bc30fb61773d9298e7b8c72911683eeff41921",
          "441e76d7e53be0a967181076a842f69c20fd8c0e3f0ce3aa421b490b059fe094",
          "cf4a21cb790552165827b678ca9695fcaf77566d382325112ff79483455de667",
          "bfbf5482e06f55b88bdd9e053b7eee6e",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "1198a78c29c215d5c450f7b8513ead253160bc9fde80d9cc8e6bee2efe9713cf5a09"
          "d6293c41033271c9e8c22036a28b",
      },
      {
          "9ef87ba8aa2e664bdfdb978b98bc30fb61773d9298e7b8c72911683eeff41921",
          "441e76d7e53be0a967181076a842f69c20fd8c0e3f0ce3aa421b490b059fe094",
          "eba5eae8aef79114082c3e70baef95bb02edf13b3897e8be7a70272962ef8838",
          "af9a56da3da18e2fbd2948a16332532b",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "1062ab5fbbdee9042ad35bdadfd3047c0a2127fe0f001da1be1b0582185edfc9687b"
          "e8d68f85795833bb04af9cedd3bb",
      },
      {
          "9ef87ba8aa2e664bdfdb978b98bc30fb61773d9298e7b8c72911683eeff41921",
          "441e76d7e53be0a967181076a842f69c20fd8c0e3f0ce3aa421b490b059fe094",
          "518f8dfd0c138f1ffb4ea8029db15441d70abd893c3d767dc668f23ba7770e27",
          "42d28307974a1b2a2d921d270cfce03b",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "005e49fb7c5da540a84b034c853fc9f78a6b901ea495aed0c2abd4f08f1a96f9ffef"
          "c6a57f1ac09e0aea95ca0f03ffd8",
      },
      {
          "9ef87ba8aa2e664bdfdb978b98bc30fb61773d9298e7b8c72911683eeff41921",
          "441e76d7e53be0a967181076a842f69c20fd8c0e3f0ce3aa421b490b059fe094",
          "582fdf58b53715c26e10ba809e8f2ab70502e5a3d4e9a81100b7227732ab0bbc",
          "91f2aad3189bb2edc93bc891e73911ba",
          "49de3cd5890e0cd0559f143807ff688ff62789b7236a332b7d7255ec0b4e73e6b3a"
          "4",
          "821a69cb16c57f0cb866e590b38069e35faec3ae18f158bb067db83a11237d29ab1e"
          "6b868b3147236a0958f15c2e2167",
      },
      {
          "9ef87ba8aa2e664bdfdb978b98bc30fb61773d9298e7b8c72911683eeff41921",
          "441e76d7e53be0a967181076a842f69c20fd8c0e3f0ce3aa421b490b059fe094",
          "a415b4c006118fb72fc37b2746ef288e23ac45c8ff7ade5f368a31557b6ac93a",
          "2b7c5f75606c0b8106c6489ea5657a9e",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "2781d5ee8ef1cb1596f8902b33dfae5045f84a987ca58173af5830dbce386062",
      },
      {
          "ed93c5a101ab53382ceee4f7e6b5aa112621d3bb9d18891509b1834ede235bcc",
          "5a5e14c633d7d269302849d739d80344ff14db51d7bcda86045723f05c4e4541",
          "47e73ec362ea82d3a7c5d55532ad51d2cdf5316b981b2b2bd542b0efa027e8ea",
          "b2193f59030c8d05a7d3577b7f64dd33",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "3f43912db8dd6672b9996e5272e18c4b88fec9d7e8372db9c5f4709a4af1d86f",
      },
      {
          "ed93c5a101ab53382ceee4f7e6b5aa112621d3bb9d18891509b1834ede235bcc",
          "5a5e14c633d7d269302849d739d80344ff14db51d7bcda86045723f05c4e4541",
          "aaa006c57b6d1e402650577fe9787d8d285f4bacd7c01f998be49c766f8860c7",
          "130304ddb9adc8870cf56bcae9487b7f",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "878cc7d8c0ef8dac0182a78eedc8080a402f59d8062a6b4ca8f4a74f3c3b3de7",
      },
      {
          "ed93c5a101ab53382ceee4f7e6b5aa112621d3bb9d18891509b1834ede235bcc",
          "5a5e14c633d7d269302849d739d80344ff14db51d7bcda86045723f05c4e4541",
          "28dc7ccd6c2a939eef64b8be7b9ae248295e7fcd8471c22fa2f98733fea97611",
          "cb13890d3a11bc0a7433738263006710",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "e74ded846bebfa912fa1720e4c1415e6e5df7e7a1a7fedb5665d68f1763209a4",
      },
      {
          "ed93c5a101ab53382ceee4f7e6b5aa112621d3bb9d18891509b1834ede235bcc",
          "5a5e14c633d7d269302849d739d80344ff14db51d7bcda86045723f05c4e4541",
          "79974fa2cad95154d0873902c153ccc3e7d54b17f2eeb3f29b6344cad9365a9a",
          "22123357979d20f44cc8eb0263d84e0e",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "eb14dec7b8b64d81a2ee4db07b0adf144d4f79a519bbf332b823583fa2d45405",
      },
      {
          "ed93c5a101ab53382ceee4f7e6b5aa112621d3bb9d18891509b1834ede235bcc",
          "5a5e14c633d7d269302849d739d80344ff14db51d7bcda86045723f05c4e4541",
          "3409a6f8c4dcd9bd04144eb67e55a98696b674735b01bf1196191f29871ef966",
          "a823a0965969380ea1f8659ea5fd8fdd",
          "24512b714aefd5cbc4bcc4ef44ce6c67ffc447c65460a6c6e4a92e85",
          "00a7eb708eae745847173f8217efb05be13059710aee632e3f471ac3c6202b51",
      },
      {
          "a73a0b2686f7d699c018b6b08a352856e556070caa329c26241aec889eefde10",
          "9b493403bee45ae6277430ef8d0c4163ffd81ace2db6c7821205da09a664a86c",
          "c25701b9b7328c4ac3d23223d10623bd527c0a98e38ae9c62fbc403c80ab20ae",
          "4b4ee0e4443779f3af429a749212f476",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "f39f7d66e0fde39ecdf58be2c0ef361a17cfd6843e310adbe0ec3118cd72800d",
      },
      {
          "a73a0b2686f7d699c018b6b08a352856e556070caa329c26241aec889eefde10",
          "9b493403bee45ae6277430ef8d0c4163ffd81ace2db6c7821205da09a664a86c",
          "31d18fdffc480310828778496ff817039df5d6f30bf6d9edd0b4396863d05f93",
          "418bcbdf52860a450bfacc96920d02cf",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "0e6ce9889fe7b3cd82794b0ae27c1f5985d2f2a1f398371a138f8db1df1f54de",
      },
      {
          "e2e4dee102fad0f47f60202269605589cd9cf70f816b34016796c74b766f3041",
          "c5ce283033a3255ae14d42dff1e4c18a224ac79d084b285123421b105ee654c9",
          "56b4c645f81dbfb6ba0c6d3f1626e1e5cd648eeb36562715f7cd7e9ea86a0d7f",
          "dc9bdce76d68d2e4d72267cf4e72b022",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "dc6f046c3008002041517a7c4f3ababe609cf02616fcccda39c075d1be4175f5",
      },
      {
          "e2e4dee102fad0f47f60202269605589cd9cf70f816b34016796c74b766f3041",
          "c5ce283033a3255ae14d42dff1e4c18a224ac79d084b285123421b105ee654c9",
          "df180b91986c8c7000792f96d1faa61e30138330430a402322be1855089b0e7f",
          "ccf9b77341c866465b474e2f4a3b1cf8",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "94e4ae89041437f39826704f02cb5d775226f34344635e592846417497a5020b",
      },
      {
          "e2e4dee102fad0f47f60202269605589cd9cf70f816b34016796c74b766f3041",
          "c5ce283033a3255ae14d42dff1e4c18a224ac79d084b285123421b105ee654c9",
          "a0eee7e84c76e63fdae6e938b43330775eaf17d260e40b98c9e6616b668102a7",
          "662c681cfec6f6d052ff0e2c1255f2c2",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "70bba3c48be9c75a144b1888ca3d21a6b21f52eec133981a024390a6a0ba36f9",
      },
      {
          "e2e4dee102fad0f47f60202269605589cd9cf70f816b34016796c74b766f3041",
          "c5ce283033a3255ae14d42dff1e4c18a224ac79d084b285123421b105ee654c9",
          "c6acd2d90eb782c3053b366680ffa0e148de81fea198c87bb643869fd97e5cb0",
          "908dc33ba80520f2f0f04e7890e3a3c0",
          "b6926d0ec82cec86c0d27ec9a33a0e0f",
          "f6efe1d76d270aac264aa35d03049d9ce63be1996d543aef00559219c8666f71",
      },
  };

  HDNode node;
  ed25519_secret_key private_key;
  uint8_t chain_code[32];
  ed25519_public_key public_key;
  uint8_t salt[sizeof(public_key)];

  uint8_t iv[AES_BLOCK_SIZE];
  uint8_t buffer[FROMHEX_MAXLEN];

  uint8_t input[FROMHEX_MAXLEN];
  uint8_t output[FROMHEX_MAXLEN];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    nem_private_key(tests[i].private_key, private_key);

    ck_assert(hdnode_from_xprv(0, 0, chain_code, private_key,
                               ED25519_KECCAK_NAME, &node));
    memcpy(public_key, fromhex(tests[i].public_key), 32);
    memcpy(salt, fromhex(tests[i].salt), sizeof(salt));

    size_t input_size = strlen(tests[i].input) / 2;
    size_t output_size = strlen(tests[i].output) / 2;

    memcpy(input, fromhex(tests[i].input), input_size);
    memcpy(output, fromhex(tests[i].output), output_size);

    memcpy(iv, fromhex(tests[i].iv), sizeof(iv));
    ck_assert(hdnode_nem_encrypt(&node, public_key, iv, salt, input, input_size,
                                 buffer));
    ck_assert_int_eq(output_size, NEM_ENCRYPTED_SIZE(input_size));
    ck_assert_mem_eq(buffer, output, output_size);

    memcpy(iv, fromhex(tests[i].iv), sizeof(iv));
    ck_assert(hdnode_nem_decrypt(&node, public_key, iv, salt, output,
                                 output_size, buffer));
    ck_assert_int_eq(input_size, NEM_DECRYPTED_SIZE(buffer, output_size));
    ck_assert_mem_eq(buffer, input, input_size);
  }
}
END_TEST

START_TEST(test_nem_transaction_transfer) {
  nem_transaction_ctx ctx;

  uint8_t buffer[1024], hash[SHA3_256_DIGEST_LENGTH];

  // http://bob.nem.ninja:8765/#/transfer/0acbf8df91e6a65dc56c56c43d65f31ff2a6a48d06fc66e78c7f3436faf3e74f

  nem_transaction_start(
      &ctx,
      fromhex(
          "e59ef184a612d4c3c4d89b5950eb57262c69862b2f96e59c5043bf41765c482f"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_transfer(
      &ctx, NEM_NETWORK_TESTNET, 0, NULL, 0, 0,
      "TBGIMRE4SBFRUJXMH7DVF2IBY36L2EDWZ37GVSC4", 50000000000000, NULL, 0,
      false, 0));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "0acbf8df91e6a65dc56c56c43d65f31ff2a6a48d06fc66e78c7f3436faf3e74f"),
      sizeof(hash));

  // http://bob.nem.ninja:8765/#/transfer/3409d9ece28d6296d6d5e220a7e3cb8641a3fb235ffcbd20c95da64f003ace6c

  nem_transaction_start(
      &ctx,
      fromhex(
          "994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_transfer(
      &ctx, NEM_NETWORK_TESTNET, 14072100, NULL, 194000000, 14075700,
      "TBLOODPLWOWMZ2TARX4RFPOSOWLULHXMROBN2WXI", 3000000,
      (uint8_t *)"sending you 3 pairs of paddles\n", 31, false, 2));

  ck_assert(
      nem_transaction_write_mosaic(&ctx, "gimre.games.pong", "paddles", 2));

  ck_assert(nem_transaction_write_mosaic(&ctx, "nem", "xem", 44000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "3409d9ece28d6296d6d5e220a7e3cb8641a3fb235ffcbd20c95da64f003ace6c"),
      sizeof(hash));

  // http://chain.nem.ninja/#/transfer/e90e98614c7598fbfa4db5411db1b331d157c2f86b558fb7c943d013ed9f71cb

  nem_transaction_start(
      &ctx,
      fromhex(
          "8d07f90fb4bbe7715fa327c926770166a11be2e494a970605f2e12557f66c9b9"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_transfer(
      &ctx, NEM_NETWORK_MAINNET, 0, NULL, 0, 0,
      "NBT3WHA2YXG2IR4PWKFFMO772JWOITTD2V4PECSB", 5175000000000,
      (uint8_t *)"Good luck!", 10, false, 0));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "e90e98614c7598fbfa4db5411db1b331d157c2f86b558fb7c943d013ed9f71cb"),
      sizeof(hash));

  // http://chain.nem.ninja/#/transfer/40e89160e6f83d37f7c82defc0afe2c1605ae8c919134570a51dd27ea1bb516c

  nem_transaction_start(
      &ctx,
      fromhex(
          "f85ab43dad059b9d2331ddacc384ad925d3467f03207182e01296bacfb242d01"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_transfer(
      &ctx, NEM_NETWORK_MAINNET, 77229, NULL, 30000000, 80829,
      "NALICEPFLZQRZGPRIJTMJOCPWDNECXTNNG7QLSG3", 30000000,
      fromhex("4d9dcf9186967d30be93d6d5404ded22812dbbae7c3f0de5"
              "01bcd7228cba45bded13000eec7b4c6215fc4d3588168c92"
              "18167cec98e6977359153a4132e050f594548e61e0dc61c1"
              "53f0f53c5e65c595239c9eb7c4e7d48e0f4bb8b1dd2f5ddc"),
      96, true, 0));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "40e89160e6f83d37f7c82defc0afe2c1605ae8c919134570a51dd27ea1bb516c"),
      sizeof(hash));

  // http://chain.nem.ninja/#/transfer/882dca18dcbe075e15e0ec5a1d7e6ccd69cc0f1309ffd3fde227bfbc107b3f6e

  nem_transaction_start(
      &ctx,
      fromhex(
          "f85ab43dad059b9d2331ddacc384ad925d3467f03207182e01296bacfb242d01"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_transfer(
      &ctx, NEM_NETWORK_MAINNET, 26730750, NULL, 179500000, 26734350,
      "NBE223WPKEBHQPCYUC4U4CDUQCRRFMPZLOQLB5OP", 1000000,
      (uint8_t *)"enjoy! :)", 9, false, 1));

  ck_assert(nem_transaction_write_mosaic(&ctx, "imre.g", "tokens", 1));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "882dca18dcbe075e15e0ec5a1d7e6ccd69cc0f1309ffd3fde227bfbc107b3f6e"),
      sizeof(hash));
}
END_TEST

START_TEST(test_nem_transaction_multisig) {
  nem_transaction_ctx ctx, other_trans;

  uint8_t buffer[1024], inner[1024];
  const uint8_t *signature;

  // http://bob.nem.ninja:8765/#/multisig/7d3a7087023ee29005262016706818579a2b5499eb9ca76bad98c1e6f4c46642

  nem_transaction_start(
      &other_trans,
      fromhex(
          "abac2ee3d4aaa7a3bfb65261a00cc04c761521527dd3f2cf741e2815cbba83ac"),
      inner, sizeof(inner));

  ck_assert(nem_transaction_create_aggregate_modification(
      &other_trans, NEM_NETWORK_TESTNET, 3939039, NULL, 16000000, 3960639, 1,
      false));

  ck_assert(nem_transaction_write_cosignatory_modification(
      &other_trans, 2,
      fromhex(
          "e6cff9b3725a91f31089c3acca0fac3e341c00b1c8c6e9578f66c4514509c3b3")));

  nem_transaction_start(
      &ctx,
      fromhex(
          "59d89076964742ef2a2089d26a5aa1d2c7a7bb052a46c1de159891e91ad3d76e"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_multisig(&ctx, NEM_NETWORK_TESTNET, 3939039,
                                            NULL, 6000000, 3960639,
                                            &other_trans));

  signature = fromhex(
      "933930a8828b560168bddb3137df9252048678d829aa5135fa27bb306ff6562efb927554"
      "62988b852b0314bde058487d00e47816b6fb7df6bcfd7e1f150d1d00");
  ck_assert_int_eq(ed25519_sign_open_keccak(ctx.buffer, ctx.offset,
                                            ctx.public_key, signature),
                   0);

  nem_transaction_start(
      &ctx,
      fromhex(
          "71cba4f2a28fd19f902ba40e9937994154d9eeaad0631d25d525ec37922567d4"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_multisig_signature(&ctx, NEM_NETWORK_TESTNET,
                                                      3939891, NULL, 6000000,
                                                      3961491, &other_trans));

  signature = fromhex(
      "a849f13bfeeba808a8a4a79d579febe584d831a3a6ad03da3b9d008530b3d7a79fcf7156"
      "121cd7ee847029d94af7ea7a683ca8e643dc5e5f489557c2054b830b");
  ck_assert_int_eq(ed25519_sign_open_keccak(ctx.buffer, ctx.offset,
                                            ctx.public_key, signature),
                   0);

  // http://chain.nem.ninja/#/multisig/1016cf3bdd61bd57b9b2b07b6ff2dee390279d8d899265bdc23d42360abe2e6c

  nem_transaction_start(
      &other_trans,
      fromhex(
          "a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"),
      inner, sizeof(inner));

  ck_assert(nem_transaction_create_provision_namespace(
      &other_trans, NEM_NETWORK_MAINNET, 59414272, NULL, 20000000, 59500672,
      "dim", NULL, "NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA", 5000000000));

  nem_transaction_start(
      &ctx,
      fromhex(
          "cfe58463f0eaebceb5d00717f8aead49171a5d7c08f6b1299bd534f11715acc9"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_multisig(&ctx, NEM_NETWORK_MAINNET, 59414272,
                                            NULL, 6000000, 59500672,
                                            &other_trans));

  signature = fromhex(
      "52a876a37511068fe214bd710b2284823921ec7318c01e083419a062eae5369c9c11c3ab"
      "fdb590f65c717fab82873431d52be62e10338cb5656d1833bbdac70c");
  ck_assert_int_eq(ed25519_sign_open_keccak(ctx.buffer, ctx.offset,
                                            ctx.public_key, signature),
                   0);

  nem_transaction_start(
      &ctx,
      fromhex(
          "1b49b80203007117d034e45234ffcdf402c044aeef6dbb06351f346ca892bce2"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_multisig_signature(&ctx, NEM_NETWORK_MAINNET,
                                                      59414342, NULL, 6000000,
                                                      59500742, &other_trans));

  signature = fromhex(
      "b9a59239e5d06992c28840034ff7a7f13da9c4e6f4a6f72c1b1806c3b602f83a7d727a34"
      "5371f5d15abf958208a32359c6dd77bde92273ada8ea6fda3dc76b00");
  ck_assert_int_eq(ed25519_sign_open_keccak(ctx.buffer, ctx.offset,
                                            ctx.public_key, signature),
                   0);

  nem_transaction_start(
      &ctx,
      fromhex(
          "7ba4b39209f1b9846b098fe43f74381e43cb2882ccde780f558a63355840aa87"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_multisig_signature(&ctx, NEM_NETWORK_MAINNET,
                                                      59414381, NULL, 6000000,
                                                      59500781, &other_trans));

  signature = fromhex(
      "e874ae9f069f0538008631d2df9f2e8a59944ff182e8672f743d2700fb99224aafb7a0ab"
      "09c4e9ea39ee7c8ca04a8a3d6103ae1122d87772e871761d4f00ca01");
  ck_assert_int_eq(ed25519_sign_open_keccak(ctx.buffer, ctx.offset,
                                            ctx.public_key, signature),
                   0);
}
END_TEST

START_TEST(test_nem_transaction_provision_namespace) {
  nem_transaction_ctx ctx;

  uint8_t buffer[1024], hash[SHA3_256_DIGEST_LENGTH];

  // http://bob.nem.ninja:8765/#/namespace/f7cab28da57204d01a907c697836577a4ae755e6c9bac60dcc318494a22debb3

  nem_transaction_start(
      &ctx,
      fromhex(
          "84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_provision_namespace(
      &ctx, NEM_NETWORK_TESTNET, 56999445, NULL, 20000000, 57003045, "gimre",
      NULL, "TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35", 5000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "f7cab28da57204d01a907c697836577a4ae755e6c9bac60dcc318494a22debb3"),
      sizeof(hash));

  // http://bob.nem.ninja:8765/#/namespace/7ddd5fe607e1bfb5606e0ac576024c318c8300d237273117d4db32a60c49524d

  nem_transaction_start(
      &ctx,
      fromhex(
          "244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_provision_namespace(
      &ctx, NEM_NETWORK_TESTNET, 21496797, NULL, 108000000, 21500397, "misc",
      "alice", "TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35", 5000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "7ddd5fe607e1bfb5606e0ac576024c318c8300d237273117d4db32a60c49524d"),
      sizeof(hash));

  // http://chain.nem.ninja/#/namespace/57071aad93ca125dc231dc02c07ad8610cd243d35068f9b36a7d231383907569

  nem_transaction_start(
      &ctx,
      fromhex(
          "9f3c14f304309c8b72b2821339c4428793b1518bea72d58dd01f19d523518614"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_provision_namespace(
      &ctx, NEM_NETWORK_MAINNET, 26699717, NULL, 108000000, 26703317, "sex",
      NULL, "NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA", 50000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "57071aad93ca125dc231dc02c07ad8610cd243d35068f9b36a7d231383907569"),
      sizeof(hash));
}
END_TEST

START_TEST(test_nem_transaction_mosaic_creation) {
  nem_transaction_ctx ctx;

  uint8_t buffer[1024], hash[SHA3_256_DIGEST_LENGTH];

  // http://bob.nem.ninja:8765/#/mosaic/68364353c29105e6d361ad1a42abbccbf419cfc7adb8b74c8f35d8f8bdaca3fa/0

  nem_transaction_start(
      &ctx,
      fromhex(
          "994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_creation(
      &ctx, NEM_NETWORK_TESTNET, 14070896, NULL, 108000000, 14074496,
      "gimre.games.pong", "paddles", "Paddles for the bong game.\n", 0, 10000,
      true, true, 0, 0, NULL, NULL, NULL,
      "TBMOSAICOD4F54EE5CDMR23CCBGOAM2XSJBR5OLC", 50000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "68364353c29105e6d361ad1a42abbccbf419cfc7adb8b74c8f35d8f8bdaca3fa"),
      sizeof(hash));

  // http://bob.nem.ninja:8765/#/mosaic/b2f4a98113ff1f3a8f1e9d7197aa982545297fe0aa3fa6094af8031569953a55/0

  nem_transaction_start(
      &ctx,
      fromhex(
          "244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_creation(
      &ctx, NEM_NETWORK_TESTNET, 21497248, NULL, 108000000, 21500848,
      "alice.misc", "bar", "Special offer: get one bar extra by bying one foo!",
      0, 1000, false, true, 1, 1, "TALICE2GMA34CXHD7XLJQ536NM5UNKQHTORNNT2J",
      "nem", "xem", "TBMOSAICOD4F54EE5CDMR23CCBGOAM2XSJBR5OLC", 50000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "b2f4a98113ff1f3a8f1e9d7197aa982545297fe0aa3fa6094af8031569953a55"),
      sizeof(hash));

  // http://chain.nem.ninja/#/mosaic/269c6fda657aba3053a0e5b138c075808cc20e244e1182d9b730798b60a1f77b/0

  nem_transaction_start(
      &ctx,
      fromhex(
          "58956ac77951622dc5f1c938affbf017c458e30e6b21ddb5783d38b302531f23"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_creation(
      &ctx, NEM_NETWORK_MAINNET, 26729938, NULL, 108000000, 26733538, "jabo38",
      "red_token",
      "This token is to celebrate the release of Namespaces and Mosaics on the "
      "NEM system. "
      "This token was the fist ever mosaic created other than nem.xem. "
      "There are only 10,000 Red Tokens that will ever be created. "
      "It has no levy and can be traded freely among third parties.",
      2, 10000, false, true, 0, 0, NULL, NULL, NULL,
      "NBMOSAICOD4F54EE5CDMR23CCBGOAM2XSIUX6TRS", 50000000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "269c6fda657aba3053a0e5b138c075808cc20e244e1182d9b730798b60a1f77b"),
      sizeof(hash));

  // http://chain.nem.ninja/#/mosaic/e8dc14821dbea4831d9051f86158ef348001447968fc22c01644fdaf2bda75c6/0

  nem_transaction_start(
      &ctx,
      fromhex(
          "a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_creation(
      &ctx, NEM_NETWORK_MAINNET, 69251020, NULL, 20000000, 69337420, "dim",
      "coin", "DIM COIN", 6, 9000000000, false, true, 2, 10,
      "NCGGLVO2G3CUACVI5GNX2KRBJSQCN4RDL2ZWJ4DP", "dim", "coin",
      "NBMOSAICOD4F54EE5CDMR23CCBGOAM2XSIUX6TRS", 500000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "e8dc14821dbea4831d9051f86158ef348001447968fc22c01644fdaf2bda75c6"),
      sizeof(hash));
}
END_TEST

START_TEST(test_nem_transaction_mosaic_supply_change) {
  nem_transaction_ctx ctx;

  uint8_t buffer[1024], hash[SHA3_256_DIGEST_LENGTH];

  // http://bigalice2.nem.ninja:7890/transaction/get?hash=33a50fdd4a54913643a580b2af08b9a5b51b7cee922bde380e84c573a7969c50

  nem_transaction_start(
      &ctx,
      fromhex(
          "994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_supply_change(
      &ctx, NEM_NETWORK_TESTNET, 14071648, NULL, 108000000, 14075248,
      "gimre.games.pong", "paddles", 1, 1234));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "33a50fdd4a54913643a580b2af08b9a5b51b7cee922bde380e84c573a7969c50"),
      sizeof(hash));

  // http://bigalice2.nem.ninja:7890/transaction/get?hash=1ce8e8894d077a66ff22294b000825d090a60742ec407efd80eb8b19657704f2

  nem_transaction_start(
      &ctx,
      fromhex(
          "84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_supply_change(
      &ctx, NEM_NETWORK_TESTNET, 14126909, NULL, 108000000, 14130509,
      "jabo38_ltd.fuzzy_kittens_cafe", "coupons", 2, 1));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "1ce8e8894d077a66ff22294b000825d090a60742ec407efd80eb8b19657704f2"),
      sizeof(hash));

  // http://bigalice3.nem.ninja:7890/transaction/get?hash=694e493e9576d2bcf60d85747e302ac2e1cc27783187947180d4275a713ff1ff

  nem_transaction_start(
      &ctx,
      fromhex(
          "b7ccc27b21ba6cf5c699a8dc86ba6ba98950442597ff9fa30e0abe0f5f4dd05d"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_supply_change(
      &ctx, NEM_NETWORK_MAINNET, 53377685, NULL, 20000000, 53464085, "abvapp",
      "abv", 1, 9000000));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "694e493e9576d2bcf60d85747e302ac2e1cc27783187947180d4275a713ff1ff"),
      sizeof(hash));

  // http://bigalice3.nem.ninja:7890/transaction/get?hash=09836334e123970e068d5b411e4d1df54a3ead10acf1ad5935a2cdd9f9680185

  nem_transaction_start(
      &ctx,
      fromhex(
          "75f001a8641e2ce5c4386883dda561399ed346177411b492a677b73899502f13"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_mosaic_supply_change(
      &ctx, NEM_NETWORK_MAINNET, 55176304, NULL, 20000000, 55262704, "sushi",
      "wasabi", 2, 20));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "09836334e123970e068d5b411e4d1df54a3ead10acf1ad5935a2cdd9f9680185"),
      sizeof(hash));
}
END_TEST

START_TEST(test_nem_transaction_aggregate_modification) {
  nem_transaction_ctx ctx;

  uint8_t buffer[1024], hash[SHA3_256_DIGEST_LENGTH];

  // http://bob.nem.ninja:8765/#/aggregate/6a55471b17159e5b6cd579c421e95a4e39d92e3f78b0a55ee337e785a601d3a2

  nem_transaction_start(
      &ctx,
      fromhex(
          "462ee976890916e54fa825d26bdd0235f5eb5b6a143c199ab0ae5ee9328e08ce"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_aggregate_modification(
      &ctx, NEM_NETWORK_TESTNET, 0, NULL, 22000000, 0, 2, false));

  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "c54d6e33ed1446eedd7f7a80a588dd01857f723687a09200c1917d5524752f8b")));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "6a55471b17159e5b6cd579c421e95a4e39d92e3f78b0a55ee337e785a601d3a2"),
      sizeof(hash));

  // http://bob.nem.ninja:8765/#/aggregate/1fbdae5ba753e68af270930413ae90f671eb8ab58988116684bac0abd5726584

  nem_transaction_start(
      &ctx,
      fromhex(
          "6bf7849c1eec6a2002995cc457dc00c4e29bad5c88de63f51e42dfdcd7b2131d"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_aggregate_modification(
      &ctx, NEM_NETWORK_TESTNET, 6542254, NULL, 40000000, 6545854, 4, true));

  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "5f53d076c8c3ec3110b98364bc423092c3ec2be2b1b3c40fd8ab68d54fa39295")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "9eb199c2b4d406f64cb7aa5b2b0815264b56ba8fe44d558a6cb423a31a33c4c2")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "94b2323dab23a3faba24fa6ddda0ece4fbb06acfedd74e76ad9fae38d006882b")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "d88c6ee2a2cd3929d0d76b6b14ecb549d21296ab196a2b3a4cb2536bcce32e87")));

  ck_assert(nem_transaction_write_minimum_cosignatories(&ctx, 2));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "1fbdae5ba753e68af270930413ae90f671eb8ab58988116684bac0abd5726584"),
      sizeof(hash));

  // http://chain.nem.ninja/#/aggregate/cc64ca69bfa95db2ff7ac1e21fe6d27ece189c603200ebc9778d8bb80ca25c3c

  nem_transaction_start(
      &ctx,
      fromhex(
          "f41b99320549741c5cce42d9e4bb836d98c50ed5415d0c3c2912d1bb50e6a0e5"),
      buffer, sizeof(buffer));

  ck_assert(nem_transaction_create_aggregate_modification(
      &ctx, NEM_NETWORK_MAINNET, 0, NULL, 40000000, 0, 5, false));

  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "1fbdbdde28daf828245e4533765726f0b7790e0b7146e2ce205df3e86366980b")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "f94e8702eb1943b23570b1b83be1b81536df35538978820e98bfce8f999e2d37")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "826cedee421ff66e708858c17815fcd831a4bb68e3d8956299334e9e24380ba8")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "719862cd7d0f4e875a6a0274c9a1738f38f40ad9944179006a54c34724c1274d")));
  ck_assert(nem_transaction_write_cosignatory_modification(
      &ctx, 1,
      fromhex(
          "43aa69177018fc3e2bdbeb259c81cddf24be50eef9c5386db51d82386c41475a")));

  keccak_256(ctx.buffer, ctx.offset, hash);
  ck_assert_mem_eq(
      hash,
      fromhex(
          "cc64ca69bfa95db2ff7ac1e21fe6d27ece189c603200ebc9778d8bb80ca25c3c"),
      sizeof(hash));
}
END_TEST

START_TEST(test_multibyte_address) {
  uint8_t priv_key[32];
  char wif[57];
  uint8_t pub_key[33];
  char address[40];
  uint8_t decode[24];
  int res;

  memcpy(
      priv_key,
      fromhex(
          "47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"),
      32);
  ecdsa_get_wif(priv_key, 0, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "13QtoXmbhELWcrwD9YA9KzvXy5rTaptiNuFR8L8ArpBNn4xmQj4N");
  ecdsa_get_wif(priv_key, 0x12, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif, "3hrF6SFnqzpzABB36uGDf8dJSuUCcMmoJrTmCWMshRkBr2Vx86qJ");
  ecdsa_get_wif(priv_key, 0x1234, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif,
                   "CtPTF9awbVbfDWGepGdVhB3nBhr4HktUGya8nf8dLxgC8tbqBreB9");
  ecdsa_get_wif(priv_key, 0x123456, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif,
                   "uTrDevVQt5QZgoL3iJ1cPWHaCz7ZMBncM7QXZfCegtxiMHqBvWoYJa");
  ecdsa_get_wif(priv_key, 0x12345678, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif,
                   "4zZWMzv1SVbs95pmLXWrXJVp9ntPEam1mfwb6CXBLn9MpWNxLg9huYgv");
  ecdsa_get_wif(priv_key, 0xffffffff, HASHER_SHA2D, wif, sizeof(wif));
  ck_assert_str_eq(wif,
                   "y9KVfV1RJXcTxpVjeuh6WYWh8tMwnAUeyUwDEiRviYdrJ61njTmnfUjE");

  memcpy(
      pub_key,
      fromhex(
          "0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71"),
      33);
  ecdsa_get_address(pub_key, 0, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8");
  ecdsa_get_address(pub_key, 0x12, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "8SCrMR2yYF7ciqoDbav7VLLTsVx5dTVPPq");
  ecdsa_get_address(pub_key, 0x1234, HASHER_SHA2_RIPEMD, HASHER_SHA2D, address,
                    sizeof(address));
  ck_assert_str_eq(address, "ZLH8q1UgMPg8o2s1MD55YVMpPV7vqms9kiV");
  ecdsa_get_address(pub_key, 0x123456, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                    address, sizeof(address));
  ck_assert_str_eq(address, "3ThqvsQVFnbiF66NwHtfe2j6AKn75DpLKpQSq");
  ecdsa_get_address(pub_key, 0x12345678, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                    address, sizeof(address));
  ck_assert_str_eq(address, "BrsGxAHga3VbopvSnb3gmLvMBhJNCGuDxBZL44");
  ecdsa_get_address(pub_key, 0xffffffff, HASHER_SHA2_RIPEMD, HASHER_SHA2D,
                    address, sizeof(address));
  ck_assert_str_eq(address, "3diW7paWGJyZRLGqMJZ55DMfPExob8QxQHkrfYT");

  res = ecdsa_address_decode("1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8", 0,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("0079fbfc3f34e7745860d76137da68f362380c606c"), 21);
  res = ecdsa_address_decode("8SCrMR2yYF7ciqoDbav7VLLTsVx5dTVPPq", 0x12,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("1279fbfc3f34e7745860d76137da68f362380c606c"), 21);
  res = ecdsa_address_decode("ZLH8q1UgMPg8o2s1MD55YVMpPV7vqms9kiV", 0x1234,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(decode,
                   fromhex("123479fbfc3f34e7745860d76137da68f362380c606c"), 21);
  res = ecdsa_address_decode("3ThqvsQVFnbiF66NwHtfe2j6AKn75DpLKpQSq", 0x123456,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      decode, fromhex("12345679fbfc3f34e7745860d76137da68f362380c606c"), 21);
  res = ecdsa_address_decode("BrsGxAHga3VbopvSnb3gmLvMBhJNCGuDxBZL44",
                             0x12345678, HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      decode, fromhex("1234567879fbfc3f34e7745860d76137da68f362380c606c"), 21);
  res = ecdsa_address_decode("3diW7paWGJyZRLGqMJZ55DMfPExob8QxQHkrfYT",
                             0xffffffff, HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 1);
  ck_assert_mem_eq(
      decode, fromhex("ffffffff79fbfc3f34e7745860d76137da68f362380c606c"), 21);

  // wrong length
  res = ecdsa_address_decode("BrsGxAHga3VbopvSnb3gmLvMBhJNCGuDxBZL44", 0x123456,
                             HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);

  // wrong address prefix
  res = ecdsa_address_decode("BrsGxAHga3VbopvSnb3gmLvMBhJNCGuDxBZL44",
                             0x22345678, HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);

  // wrong checksum
  res = ecdsa_address_decode("BrsGxAHga3VbopvSnb3gmLvMBhJNCGuDxBZL45",
                             0x12345678, HASHER_SHA2D, decode);
  ck_assert_int_eq(res, 0);
}
END_TEST

// https://tools.ietf.org/html/rfc6229#section-2
START_TEST(test_rc4_rfc6229) {
  static const size_t offsets[] = {
      0x0, 0xf0, 0x1f0, 0x2f0, 0x3f0, 0x5f0, 0x7f0, 0xbf0, 0xff0,
  };

  static const struct {
    char key[65];
    char vectors[sizeof(offsets) / sizeof(*offsets)][65];
  } tests[] = {
      {"0102030405",
       {
           "b2396305f03dc027ccc3524a0a1118a8"
           "6982944f18fc82d589c403a47a0d0919",
           "28cb1132c96ce286421dcaadb8b69eae"
           "1cfcf62b03eddb641d77dfcf7f8d8c93",
           "42b7d0cdd918a8a33dd51781c81f4041"
           "6459844432a7da923cfb3eb4980661f6",
           "ec10327bde2beefd18f9277680457e22"
           "eb62638d4f0ba1fe9fca20e05bf8ff2b",
           "45129048e6a0ed0b56b490338f078da5"
           "30abbcc7c20b01609f23ee2d5f6bb7df",
           "3294f744d8f9790507e70f62e5bbceea"
           "d8729db41882259bee4f825325f5a130",
           "1eb14a0c13b3bf47fa2a0ba93ad45b8b"
           "cc582f8ba9f265e2b1be9112e975d2d7",
           "f2e30f9bd102ecbf75aaade9bc35c43c"
           "ec0e11c479dc329dc8da7968fe965681",
           "068326a2118416d21f9d04b2cd1ca050"
           "ff25b58995996707e51fbdf08b34d875",
       }},
      {"01020304050607",
       {
           "293f02d47f37c9b633f2af5285feb46b"
           "e620f1390d19bd84e2e0fd752031afc1",
           "914f02531c9218810df60f67e338154c"
           "d0fdb583073ce85ab83917740ec011d5",
           "75f81411e871cffa70b90c74c592e454"
           "0bb87202938dad609e87a5a1b079e5e4",
           "c2911246b612e7e7b903dfeda1dad866"
           "32828f91502b6291368de8081de36fc2",
           "f3b9a7e3b297bf9ad804512f9063eff1"
           "8ecb67a9ba1f55a5a067e2b026a3676f",
           "d2aa902bd42d0d7cfd340cd45810529f"
           "78b272c96e42eab4c60bd914e39d06e3",
           "f4332fd31a079396ee3cee3f2a4ff049"
           "05459781d41fda7f30c1be7e1246c623",
           "adfd3868b8e51485d5e610017e3dd609"
           "ad26581c0c5be45f4cea01db2f3805d5",
           "f3172ceffc3b3d997c85ccd5af1a950c"
           "e74b0b9731227fd37c0ec08a47ddd8b8",
       }},
      {"0102030405060708",
       {
           "97ab8a1bf0afb96132f2f67258da15a8"
           "8263efdb45c4a18684ef87e6b19e5b09",
           "9636ebc9841926f4f7d1f362bddf6e18"
           "d0a990ff2c05fef5b90373c9ff4b870a",
           "73239f1db7f41d80b643c0c52518ec63"
           "163b319923a6bdb4527c626126703c0f",
           "49d6c8af0f97144a87df21d91472f966"
           "44173a103b6616c5d5ad1cee40c863d0",
           "273c9c4b27f322e4e716ef53a47de7a4"
           "c6d0e7b226259fa9023490b26167ad1d",
           "1fe8986713f07c3d9ae1c163ff8cf9d3"
           "8369e1a965610be887fbd0c79162aafb",
           "0a0127abb44484b9fbef5abcae1b579f"
           "c2cdadc6402e8ee866e1f37bdb47e42c",
           "26b51ea37df8e1d6f76fc3b66a7429b3"
           "bc7683205d4f443dc1f29dda3315c87b",
           "d5fa5a3469d29aaaf83d23589db8c85b"
           "3fb46e2c8f0f068edce8cdcd7dfc5862",
       }},
      {"0102030405060708090a",
       {
           "ede3b04643e586cc907dc21851709902"
           "03516ba78f413beb223aa5d4d2df6711",
           "3cfd6cb58ee0fdde640176ad0000044d"
           "48532b21fb6079c9114c0ffd9c04a1ad",
           "3e8cea98017109979084b1ef92f99d86"
           "e20fb49bdb337ee48b8d8dc0f4afeffe",
           "5c2521eacd7966f15e056544bea0d315"
           "e067a7031931a246a6c3875d2f678acb",
           "a64f70af88ae56b6f87581c0e23e6b08"
           "f449031de312814ec6f319291f4a0516",
           "bdae85924b3cb1d0a2e33a30c6d79599"
           "8a0feddbac865a09bcd127fb562ed60a",
           "b55a0a5b51a12a8be34899c3e047511a"
           "d9a09cea3ce75fe39698070317a71339",
           "552225ed1177f44584ac8cfa6c4eb5fc"
           "7e82cbabfc95381b080998442129c2f8",
           "1f135ed14ce60a91369d2322bef25e3c"
           "08b6be45124a43e2eb77953f84dc8553",
       }},
      {"0102030405060708090a0b0c0d0e0f10",
       {
           "9ac7cc9a609d1ef7b2932899cde41b97"
           "5248c4959014126a6e8a84f11d1a9e1c",
           "065902e4b620f6cc36c8589f66432f2b"
           "d39d566bc6bce3010768151549f3873f",
           "b6d1e6c4a5e4771cad79538df295fb11"
           "c68c1d5c559a974123df1dbc52a43b89",
           "c5ecf88de897fd57fed301701b82a259"
           "eccbe13de1fcc91c11a0b26c0bc8fa4d",
           "e7a72574f8782ae26aabcf9ebcd66065"
           "bdf0324e6083dcc6d3cedd3ca8c53c16",
           "b40110c4190b5622a96116b0017ed297"
           "ffa0b514647ec04f6306b892ae661181",
           "d03d1bc03cd33d70dff9fa5d71963ebd"
           "8a44126411eaa78bd51e8d87a8879bf5",
           "fabeb76028ade2d0e48722e46c4615a3"
           "c05d88abd50357f935a63c59ee537623",
           "ff38265c1642c1abe8d3c2fe5e572bf8"
           "a36a4c301ae8ac13610ccbc12256cacc",
       }},
      {"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20",
       {
           "eaa6bd25880bf93d3f5d1e4ca2611d91"
           "cfa45c9f7e714b54bdfa80027cb14380",
           "114ae344ded71b35f2e60febad727fd8"
           "02e1e7056b0f623900496422943e97b6",
           "91cb93c787964e10d9527d999c6f936b"
           "49b18b42f8e8367cbeb5ef104ba1c7cd",
           "87084b3ba700bade955610672745b374"
           "e7a7b9e9ec540d5ff43bdb12792d1b35",
           "c799b596738f6b018c76c74b1759bd90"
           "7fec5bfd9f9b89ce6548309092d7e958",
           "40f250b26d1f096a4afd4c340a588815"
           "3e34135c79db010200767651cf263073",
           "f656abccf88dd827027b2ce917d464ec"
           "18b62503bfbc077fbabb98f20d98ab34",
           "8aed95ee5b0dcbfbef4eb21d3a3f52f9"
           "625a1ab00ee39a5327346bddb01a9c18",
           "a13a7c79c7e119b5ab0296ab28c300b9"
           "f3e4c0a2e02d1d01f7f0a74618af2b48",
       }},
      {"833222772a",
       {
           "80ad97bdc973df8a2e879e92a497efda"
           "20f060c2f2e5126501d3d4fea10d5fc0",
           "faa148e99046181fec6b2085f3b20ed9"
           "f0daf5bab3d596839857846f73fbfe5a",
           "1c7e2fc4639232fe297584b296996bc8"
           "3db9b249406cc8edffac55ccd322ba12",
           "e4f9f7e0066154bbd125b745569bc897"
           "75d5ef262b44c41a9cf63ae14568e1b9",
           "6da453dbf81e82334a3d8866cb50a1e3"
           "7828d074119cab5c22b294d7a9bfa0bb",
           "adb89cea9a15fbe617295bd04b8ca05c"
           "6251d87fd4aaae9a7e4ad5c217d3f300",
           "e7119bd6dd9b22afe8f89585432881e2"
           "785b60fd7ec4e9fcb6545f350d660fab",
           "afecc037fdb7b0838eb3d70bcd268382"
           "dbc1a7b49d57358cc9fa6d61d73b7cf0",
           "6349d126a37afcba89794f9804914fdc"
           "bf42c3018c2f7c66bfde524975768115",
       }},
      {"1910833222772a",
       {
           "bc9222dbd3274d8fc66d14ccbda6690b"
           "7ae627410c9a2be693df5bb7485a63e3",
           "3f0931aa03defb300f060103826f2a64"
           "beaa9ec8d59bb68129f3027c96361181",
           "74e04db46d28648d7dee8a0064b06cfe"
           "9b5e81c62fe023c55be42f87bbf932b8",
           "ce178fc1826efecbc182f57999a46140"
           "8bdf55cd55061c06dba6be11de4a578a",
           "626f5f4dce652501f3087d39c92cc349"
           "42daac6a8f9ab9a7fd137c6037825682",
           "cc03fdb79192a207312f53f5d4dc33d9"
           "f70f14122a1c98a3155d28b8a0a8a41d",
           "2a3a307ab2708a9c00fe0b42f9c2d6a1"
           "862617627d2261eab0b1246597ca0ae9",
           "55f877ce4f2e1ddbbf8e13e2cde0fdc8"
           "1b1556cb935f173337705fbb5d501fc1",
           "ecd0e96602be7f8d5092816cccf2c2e9"
           "027881fab4993a1c262024a94fff3f61",
       }},
      {"641910833222772a",
       {
           "bbf609de9413172d07660cb680716926"
           "46101a6dab43115d6c522b4fe93604a9",
           "cbe1fff21c96f3eef61e8fe0542cbdf0"
           "347938bffa4009c512cfb4034b0dd1a7",
           "7867a786d00a7147904d76ddf1e520e3"
           "8d3e9e1caefcccb3fbf8d18f64120b32",
           "942337f8fd76f0fae8c52d7954810672"
           "b8548c10f51667f6e60e182fa19b30f7",
           "0211c7c6190c9efd1237c34c8f2e06c4"
           "bda64f65276d2aacb8f90212203a808e",
           "bd3820f732ffb53ec193e79d33e27c73"
           "d0168616861907d482e36cdac8cf5749",
           "97b0f0f224b2d2317114808fb03af7a0"
           "e59616e469787939a063ceea9af956d1",
           "c47e0dc1660919c11101208f9e69aa1f"
           "5ae4f12896b8379a2aad89b5b553d6b0",
           "6b6b098d0c293bc2993d80bf0518b6d9"
           "8170cc3ccd92a698621b939dd38fe7b9",
       }},
      {"8b37641910833222772a",
       {
           "ab65c26eddb287600db2fda10d1e605c"
           "bb759010c29658f2c72d93a2d16d2930",
           "b901e8036ed1c383cd3c4c4dd0a6ab05"
           "3d25ce4922924c55f064943353d78a6c",
           "12c1aa44bbf87e75e611f69b2c38f49b"
           "28f2b3434b65c09877470044c6ea170d",
           "bd9ef822de5288196134cf8af7839304"
           "67559c23f052158470a296f725735a32",
           "8bab26fbc2c12b0f13e2ab185eabf241"
           "31185a6d696f0cfa9b42808b38e132a2",
           "564d3dae183c5234c8af1e51061c44b5"
           "3c0778a7b5f72d3c23a3135c7d67b9f4",
           "f34369890fcf16fb517dcaae4463b2dd"
           "02f31c81e8200731b899b028e791bfa7",
           "72da646283228c14300853701795616f"
           "4e0a8c6f7934a788e2265e81d6d0c8f4",
           "438dd5eafea0111b6f36b4b938da2a68"
           "5f6bfc73815874d97100f086979357d8",
       }},
      {"ebb46227c6cc8b37641910833222772a",
       {
           "720c94b63edf44e131d950ca211a5a30"
           "c366fdeacf9ca80436be7c358424d20b",
           "b3394a40aabf75cba42282ef25a0059f"
           "4847d81da4942dbc249defc48c922b9f",
           "08128c469f275342adda202b2b58da95"
           "970dacef40ad98723bac5d6955b81761",
           "3cb89993b07b0ced93de13d2a11013ac"
           "ef2d676f1545c2c13dc680a02f4adbfe",
           "b60595514f24bc9fe522a6cad7393644"
           "b515a8c5011754f59003058bdb81514e",
           "3c70047e8cbc038e3b9820db601da495"
           "1175da6ee756de46a53e2b075660b770",
           "00a542bba02111cc2c65b38ebdba587e"
           "5865fdbb5b48064104e830b380f2aede",
           "34b21ad2ad44e999db2d7f0863f0d9b6"
           "84a9218fc36e8a5f2ccfbeae53a27d25",
           "a2221a11b833ccb498a59540f0545f4a"
           "5bbeb4787d59e5373fdbea6c6f75c29b",
       }},
      {"c109163908ebe51debb46227c6cc8b37641910833222772a",
       {
           "54b64e6b5a20b5e2ec84593dc7989da7"
           "c135eee237a85465ff97dc03924f45ce",
           "cfcc922fb4a14ab45d6175aabbf2d201"
           "837b87e2a446ad0ef798acd02b94124f",
           "17a6dbd664926a0636b3f4c37a4f4694"
           "4a5f9f26aeeed4d4a25f632d305233d9",
           "80a3d01ef00c8e9a4209c17f4eeb358c"
           "d15e7d5ffaaabc0207bf200a117793a2",
           "349682bf588eaa52d0aa1560346aeafa"
           "f5854cdb76c889e3ad63354e5f7275e3",
           "532c7ceccb39df3236318405a4b1279c"
           "baefe6d9ceb651842260e0d1e05e3b90",
           "e82d8c6db54e3c633f581c952ba04207"
           "4b16e50abd381bd70900a9cd9a62cb23",
           "3682ee33bd148bd9f58656cd8f30d9fb"
           "1e5a0b8475045d9b20b2628624edfd9e",
           "63edd684fb826282fe528f9c0e9237bc"
           "e4dd2e98d6960fae0b43545456743391",
       }},
      {"1ada31d5cf688221c109163908ebe51debb46227c6cc8b37641910833222772a",
       {
           "dd5bcb0018e922d494759d7c395d02d3"
           "c8446f8f77abf737685353eb89a1c9eb",
           "af3e30f9c095045938151575c3fb9098"
           "f8cb6274db99b80b1d2012a98ed48f0e",
           "25c3005a1cb85de076259839ab7198ab"
           "9dcbc183e8cb994b727b75be3180769c",
           "a1d3078dfa9169503ed9d4491dee4eb2"
           "8514a5495858096f596e4bcd66b10665",
           "5f40d59ec1b03b33738efa60b2255d31"
           "3477c7f764a41baceff90bf14f92b7cc",
           "ac4e95368d99b9eb78b8da8f81ffa795"
           "8c3c13f8c2388bb73f38576e65b7c446",
           "13c4b9c1dfb66579eddd8a280b9f7316"
           "ddd27820550126698efaadc64b64f66e",
           "f08f2e66d28ed143f3a237cf9de73559"
           "9ea36c525531b880ba124334f57b0b70",
           "d5a39e3dfcc50280bac4a6b5aa0dca7d"
           "370b1c1fe655916d97fd0d47ca1d72b8",
       }}};

  RC4_CTX ctx;
  uint8_t key[64];
  uint8_t buffer[0x1010];

  for (size_t i = 0; i < (sizeof(tests) / sizeof(*tests)); i++) {
    size_t length = strlen(tests[i].key) / 2;
    memcpy(key, fromhex(tests[i].key), length);
    memzero(buffer, sizeof(buffer));

    rc4_init(&ctx, key, length);
    rc4_encrypt(&ctx, buffer, sizeof(buffer));

    for (size_t j = 0; j < (sizeof(offsets) / sizeof(*offsets)); j++) {
      size_t size = strlen(tests[i].vectors[j]) / 2;
      ck_assert_mem_eq(&buffer[offsets[j]], fromhex(tests[i].vectors[j]), size);
    }
  }
}
END_TEST

static void test_compress_coord(const char *k_raw) {
  const ecdsa_curve *curve = &secp256k1;
  curve_point expected_coords;

  bignum256 k = {0};

  bn_read_be(fromhex(k_raw), &k);

  point_multiply(curve, &k, &curve->G, &expected_coords);

  uint8_t compress[33] = {0};
  compress_coords(&expected_coords, compress);

  bignum256 x = {0}, y = {0};
  bn_read_be(compress + 1, &x);
  uncompress_coords(curve, compress[0], &x, &y);

  ck_assert(bn_is_equal(&expected_coords.x, &x));
  ck_assert(bn_is_equal(&expected_coords.y, &y));
}

START_TEST(test_compress_coords) {
  static const char *k_raw[] = {
      "dc05960ac673fd59554c98655e26722d007bb7ada0c8ff00883fdee70783d0be",
      "41e41e0a218c980411108a0a58cf88f528c828b4d6f0d2c86234bc2504bdc3cd",
      "1d963ddcb79f6028a32cadd2421ff7fff969bff5774f73063dab41519b3da175",
      "2414141f96da0874dbc374b58861589935b7f940806ddf8d2e6b911f62e240f3",
      "01cc1fb182e29f60fe43e22d250de34f2d3f956bbef2aa9b182d09e5d9176873",
      "89b3d621d813682692fd61b2baea6b2ea696a44abc76925d29c4887fc4db9367",
      "20c80c633e05a3a7dfac05fa0e0a7c7a6b708b02323e687735cff81ea5944f59",
      "5a803c263aa93a4f74648066c03e63fb00641193bae93dfa254dabd634e8b49c",
      "05efbcc87007797dca68315b9271ac8fb75bddbece53f4dcbfb83fc21cb91fc0",
      "0bed78ef43474630bd646eef2d7ec19a1acb8e9eecf6a0a3ac7241ac40a7706f",
  };

  for (int i = 0; i < (int)(sizeof(k_raw) / sizeof(*k_raw)); i++)
    test_compress_coord(k_raw[i]);
}
END_TEST

// vectors generated using Schnorr::Sign function defined in
// https://github.com/Zilliqa/Zilliqa/blob/master/src/libCrypto/Schnorr.cpp#L88
START_TEST(test_schnorr_sign_verify) {
  static struct {
    const char *message;
    const char *priv_key;
    const char *k_hex;
    const char *s_hex;
    const char *r_hex;
  } test_cases[] = {
      {
          "123",
          "3382266517e2ebe6df51faf4bfe612236ad46fb8bd59ac982a223b045e080ac6",
          "669301F724C555D7BB1185C04909E9CACA3EC7A292B3A1C92DDCCD5A5A7DDDD3",
          "FFD72C290B98C93A4BCEDC0EDCDF040C35579BE962FE83E6821D4F3CB4B795D2",
          "74AAE9C3E069E2806E1B0D890970BE387AEBED8040F37991AACAD70B27895E39",
      },
      {
          "1234",
          "51a2758eed776c40b367364909c8a9c98cc969104f69ff316f7a287495c37c9b",
          "A0A1A9B3570AAE963535B8D4376C58A61646C18182C9FDDA5FB13703F88D4D1E",
          "99A0CB942C81571B77C682F79CD3CB663CE9E1C55BB425BA24B9F11A0DE84FE2",
          "C3C10363E38158BBA20556A36DE9358DFD81A31C180ABC9E7617C1CC1CAF03B3",
      },
      {
          "12345",
          "2685adffdbb4b2c515054cffc25cfcbfe2e462df65bbe82fb50f71e1e68dd285",
          "38DE7B3315F201433D271E91FBE62966576CA05CBFEC1770B77D7EC9D6A01D6D",
          "28982FA6C2B620CBC550F7EF9EAB605F409C584FBE5A765678877B79AB517086",
          "9A0788E5B0947DEDEDE386DF57A006CF3FE43919A74D9CA630F8A1A9D97B4650",
      },
      {
          "fun",
          "7457dc574d927e5dae84b05264a5b637b5a68e34a85b3965084ed6fed5b7f12d",
          "E005ABD242C7C602AB5EED080C5083C7C5F8DAEC6D046A54F384A8B8CDECF740",
          "51070ABCA039DAC294F6BA3BFC8C36CFC66020EDF66D1ACF1A9B545B0BF09F52",
          "330A924525EF722FA20E8E25CB6E8BD7DF4394886FA4414E4A0B6812AA25BBC0",
      },
      {
          "funny",
          "52c395a6d304de1a959e73e4604e32c5ad3f2bf01c8f730af426b38d7d5dd908",
          "0CF28B5C40A8830F3195BB99A9F0E2808F576105F41D16ABCF596AC5A8CFE88A",
          "3D60FB4664C994AD956378B9402BC68F7B4799D74F4783A6199C0D74865EA2B6",
          "5ED5EDEE0314DFFBEE39EE4E9C76DE8BC3EB8CB891AEC32B83957514284B205B",
      },
      {
          "What is great in man is that he is a bridge and not a goal",
          "52c395a6d304de1a959e73e4604e32c5ad3f2bf01c8f730af426b38d7d5dd908",
          "000000000000000000000000000000000000000000000000000000000000007B",
          "546F70AA1FEE3718C95508240CDC073B9FEFED05959C5319DD8E2BF07A1DD028",
          "B8667BE5E10B113608BFE5327C44E9F0462BE26F789177E10DCE53019AA33DAA",
      },
      {
          "123456789147258369qwertyuiopasdfghjklzxcvbnm,",
          "2685adffdbb4b2c515054cffc25cfcbfe2e462df65bbe82fb50f71e1e68dd285",
          "1D0CB70310C4D793A4561FE592B7C156771E3E26283B28AB588E968243B52DD0",
          "54D7A435E5E3F2811AA542F8895C20CCB760F2713DBDDB7291DAB6DA4E4F927E",
          "20A3BDABFFF2C1BF8E2AF709F6CDCAFE70DA9A1DBC22305B6332E36844092984",
      },
      {
          "11111111111111111111111111111111111111111111111111111111111111111"
          "11111111111111111111111111111111111111111111111111111111111111111"
          "111111111111111111",
          "3382266517e2ebe6df51faf4bfe612236ad46fb8bd59ac982a223b045e080ac6",
          "A669F372B3C2EEA351210082CAEC3B96767A7B222D19FF2EE3D814860F0D703A",
          "4890F9AC3A8D102EE3A2A473930C01CAD29DCE3860ACB7A5DADAEF16FE808991",
          "979F088E58F1814D5E462CB9F935D2924ABD8D32211D8F02DD7E0991726DF573",
      },
      {
          "qwertyuiop[]asdfghjkl;'zxcvbnm,./1234567890-=",
          "7457dc574d927e5dae84b05264a5b637b5a68e34a85b3965084ed6fed5b7f12d",
          "000000000000000000000000000000000000000000000000000000000000007C",
          "0AA595A649E517133D3448CA657424DD07BBED289030F0C0AA6738D26AB9A910",
          "83812632F1443A70B198D112D075D886BE7BBC6EC6275AE52661E52B7358BB8B",
      },
  };

  const ecdsa_curve *curve = &secp256k1;
  bignum256 k;
  uint8_t priv_key[32], buf_raw[32];
  schnorr_sign_pair result;
  for (size_t i = 0; i < sizeof(test_cases) / sizeof(*test_cases); i++) {
    memcpy(priv_key, fromhex(test_cases[i].priv_key), 32);
    memcpy(&buf_raw, fromhex(test_cases[i].k_hex), 32);
    bn_read_be(buf_raw, &k);
    schnorr_sign(curve, priv_key, &k, (const uint8_t *)test_cases[i].message,
                 strlen(test_cases[i].message), &result);

    schnorr_sign_pair expected;

    memcpy(&buf_raw, fromhex(test_cases[i].s_hex), 32);
    bn_read_be(buf_raw, &expected.s);
    memcpy(&buf_raw, fromhex(test_cases[i].r_hex), 32);
    bn_read_be(buf_raw, &expected.r);

    ck_assert_mem_eq(&expected.r, &result.r, 32);
    ck_assert_mem_eq(&expected.s, &result.s, 32);

    uint8_t pub_key[33];
    ecdsa_get_public_key33(curve, priv_key, pub_key);
    int res =
        schnorr_verify(curve, pub_key, (const uint8_t *)test_cases[i].message,
                       strlen(test_cases[i].message), &result);
    ck_assert_int_eq(res, 0);
  }
}
END_TEST

// vectors generated using Schnorr::Sign function defined in
// https://github.com/Zilliqa/Zilliqa/blob/master/src/libCrypto/Schnorr.cpp#L88
START_TEST(test_schnorr_fail_verify) {
  static struct {
    const char *message;
    const char *priv_key;
    const char *k_hex;
    const char *s_hex;
    const char *r_hex;
  } test_case = {
      "123",
      "3382266517e2ebe6df51faf4bfe612236ad46fb8bd59ac982a223b045e080ac6",
      "669301F724C555D7BB1185C04909E9CACA3EC7A292B3A1C92DDCCD5A5A7DDDD3",
      "FFD72C290B98C93A4BCEDC0EDCDF040C35579BE962FE83E6821D4F3CB4B795D2",
      "74AAE9C3E069E2806E1B0D890970BE387AEBED8040F37991AACAD70B27895E39",
  };

  const ecdsa_curve *curve = &secp256k1;
  bignum256 k;
  uint8_t priv_key[32], buf_raw[32];
  memcpy(priv_key, fromhex(test_case.priv_key), 32);
  memcpy(&buf_raw, fromhex(test_case.k_hex), 32);
  bn_read_be(buf_raw, &k);

  schnorr_sign_pair result;
  schnorr_sign(curve, priv_key, &k, (const uint8_t *)test_case.message,
               strlen(test_case.message), &result);
  uint8_t pub_key[33];
  ecdsa_get_public_key33(curve, priv_key, pub_key);

  // OK
  int res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                           strlen(test_case.message), &result);
  ck_assert_int_eq(res, 0);

  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message, 0,
                       &result);
  ck_assert_int_eq(res, 1);

  schnorr_sign_pair bad_result;

  bn_copy(&result.s, &bad_result.s);
  bn_zero(&bad_result.r);
  // r == 0
  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                       strlen(test_case.message), &bad_result);
  ck_assert_int_eq(res, 2);

  bn_copy(&result.r, &bad_result.r);
  bn_zero(&bad_result.s);
  // s == 0
  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                       strlen(test_case.message), &bad_result);
  ck_assert_int_eq(res, 3);

  bn_copy(&result.s, &bad_result.s);
  bn_copy(&curve->order, &bad_result.r);
  bn_addi(&bad_result.r, 1);
  // r == curve->order + 1
  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                       strlen(test_case.message), &bad_result);
  ck_assert_int_eq(res, 4);

  bn_copy(&result.r, &bad_result.r);
  bn_copy(&curve->order, &bad_result.s);
  bn_addi(&bad_result.s, 1);
  // s == curve->order + 1
  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                       strlen(test_case.message), &bad_result);
  ck_assert_int_eq(res, 5);

  bn_copy(&result.r, &bad_result.r);
  bn_copy(&result.s, &bad_result.s);
  // change message
  test_case.message = "12";
  res = schnorr_verify(curve, pub_key, (const uint8_t *)test_case.message,
                       strlen(test_case.message), &bad_result);
  ck_assert_int_eq(res, 10);
}
END_TEST

static int my_strncasecmp(const char *s1, const char *s2, size_t n) {
  size_t i = 0;
  while (i < n) {
    char c1 = s1[i];
    char c2 = s2[i];
    if (c1 >= 'A' && c1 <= 'Z') c1 = (c1 - 'A') + 'a';
    if (c2 >= 'A' && c2 <= 'Z') c2 = (c2 - 'A') + 'a';
    if (c1 < c2) return -1;
    if (c1 > c2) return 1;
    if (c1 == 0) return 0;
    ++i;
  }
  return 0;
}

#include "test_check_cashaddr.h"
#include "test_check_segwit.h"

#if USE_CARDANO
#include "test_check_cardano.h"
#endif

#if USE_MONERO
#include "test_check_monero.h"
#endif

// define test suite and cases
Suite *test_suite(void) {
  Suite *s = suite_create("trezor-crypto");
  TCase *tc;

  tc = tcase_create("bignum");
  tcase_add_test(tc, test_bignum_read_be);
  tcase_add_test(tc, test_bignum_write_be);
  tcase_add_test(tc, test_bignum_is_equal);
  tcase_add_test(tc, test_bignum_zero);
  tcase_add_test(tc, test_bignum_is_zero);
  tcase_add_test(tc, test_bignum_one);
  tcase_add_test(tc, test_bignum_read_le);
  tcase_add_test(tc, test_bignum_write_le);
  tcase_add_test(tc, test_bignum_read_uint32);
  tcase_add_test(tc, test_bignum_read_uint64);
  tcase_add_test(tc, test_bignum_write_uint32);
  tcase_add_test(tc, test_bignum_write_uint64);
  tcase_add_test(tc, test_bignum_copy);
  tcase_add_test(tc, test_bignum_is_even);
  tcase_add_test(tc, test_bignum_is_odd);
  tcase_add_test(tc, test_bignum_bitcount);
  tcase_add_test(tc, test_bignum_digitcount);
  tcase_add_test(tc, test_bignum_is_less);
  tcase_add_test(tc, test_bignum_format);
  tcase_add_test(tc, test_bignum_format_uint64);
  suite_add_tcase(s, tc);

  tc = tcase_create("base32");
  tcase_add_test(tc, test_base32_rfc4648);
  suite_add_tcase(s, tc);

  tc = tcase_create("base58");
  tcase_add_test(tc, test_base58);
  suite_add_tcase(s, tc);

#if USE_GRAPHENE
  tc = tcase_create("base58gph");
  tcase_add_test(tc, test_base58gph);
  suite_add_tcase(s, tc);
#endif

  tc = tcase_create("bignum_divmod");
  tcase_add_test(tc, test_bignum_divmod);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip32");
  tcase_add_test(tc, test_bip32_vector_1);
  tcase_add_test(tc, test_bip32_vector_2);
  tcase_add_test(tc, test_bip32_vector_3);
  tcase_add_test(tc, test_bip32_compare);
  tcase_add_test(tc, test_bip32_optimized);
  tcase_add_test(tc, test_bip32_cache_1);
  tcase_add_test(tc, test_bip32_cache_2);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip32-nist");
  tcase_add_test(tc, test_bip32_nist_seed);
  tcase_add_test(tc, test_bip32_nist_vector_1);
  tcase_add_test(tc, test_bip32_nist_vector_2);
  tcase_add_test(tc, test_bip32_nist_compare);
  tcase_add_test(tc, test_bip32_nist_repeat);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip32-ed25519");
  tcase_add_test(tc, test_bip32_ed25519_vector_1);
  tcase_add_test(tc, test_bip32_ed25519_vector_2);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip32-ecdh");
  tcase_add_test(tc, test_bip32_ecdh_nist256p1);
  tcase_add_test(tc, test_bip32_ecdh_curve25519);
  tcase_add_test(tc, test_bip32_ecdh_errors);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip32-decred");
  tcase_add_test(tc, test_bip32_decred_vector_1);
  tcase_add_test(tc, test_bip32_decred_vector_2);
  suite_add_tcase(s, tc);

  tc = tcase_create("ecdsa");
  tcase_add_test(tc, test_ecdsa_signature);
  suite_add_tcase(s, tc);

  tc = tcase_create("rfc6979");
  tcase_add_test(tc, test_rfc6979);
  suite_add_tcase(s, tc);

  tc = tcase_create("address");
  tcase_add_test(tc, test_address);
  suite_add_tcase(s, tc);

  tc = tcase_create("address_decode");
  tcase_add_test(tc, test_address_decode);
  suite_add_tcase(s, tc);

  tc = tcase_create("ethereum_address");
  tcase_add_test(tc, test_ethereum_address);
  suite_add_tcase(s, tc);

  tc = tcase_create("rsk_address");
  tcase_add_test(tc, test_rsk_address);
  suite_add_tcase(s, tc);

  tc = tcase_create("wif");
  tcase_add_test(tc, test_wif);
  suite_add_tcase(s, tc);

  tc = tcase_create("ecdsa_der");
  tcase_add_test(tc, test_ecdsa_der);
  suite_add_tcase(s, tc);

  tc = tcase_create("aes");
  tcase_add_test(tc, test_aes);
  suite_add_tcase(s, tc);

  tc = tcase_create("sha2");
  tcase_add_test(tc, test_sha1);
  tcase_add_test(tc, test_sha256);
  tcase_add_test(tc, test_sha512);
  suite_add_tcase(s, tc);

  tc = tcase_create("sha3");
  tcase_add_test(tc, test_sha3_256);
  tcase_add_test(tc, test_sha3_512);
  tcase_add_test(tc, test_keccak_256);
  suite_add_tcase(s, tc);

  tc = tcase_create("blake");
  tcase_add_test(tc, test_blake256);
  suite_add_tcase(s, tc);

  tc = tcase_create("blake2");
  tcase_add_test(tc, test_blake2b);
  tcase_add_test(tc, test_blake2s);
  suite_add_tcase(s, tc);

  tc = tcase_create("pbkdf2");
  tcase_add_test(tc, test_pbkdf2_hmac_sha256);
  tcase_add_test(tc, test_pbkdf2_hmac_sha512);
  suite_add_tcase(s, tc);

  tc = tcase_create("bip39");
  tcase_add_test(tc, test_mnemonic);
  tcase_add_test(tc, test_mnemonic_check);
  tcase_add_test(tc, test_mnemonic_to_entropy);
  suite_add_tcase(s, tc);

  tc = tcase_create("shamir");
  tcase_add_test(tc, test_shamir);
  suite_add_tcase(s, tc);

  tc = tcase_create("pubkey_validity");
  tcase_add_test(tc, test_pubkey_validity);
  suite_add_tcase(s, tc);

  tc = tcase_create("pubkey_uncompress");
  tcase_add_test(tc, test_pubkey_uncompress);
  suite_add_tcase(s, tc);

  tc = tcase_create("codepoints");
  tcase_add_test(tc, test_codepoints_secp256k1);
  tcase_add_test(tc, test_codepoints_nist256p1);
  suite_add_tcase(s, tc);

  tc = tcase_create("mult_border_cases");
  tcase_add_test(tc, test_mult_border_cases_secp256k1);
  tcase_add_test(tc, test_mult_border_cases_nist256p1);
  suite_add_tcase(s, tc);

  tc = tcase_create("scalar_mult");
  tcase_add_test(tc, test_scalar_mult_secp256k1);
  tcase_add_test(tc, test_scalar_mult_nist256p1);
  suite_add_tcase(s, tc);

  tc = tcase_create("point_mult");
  tcase_add_test(tc, test_point_mult_secp256k1);
  tcase_add_test(tc, test_point_mult_nist256p1);
  suite_add_tcase(s, tc);

  tc = tcase_create("scalar_point_mult");
  tcase_add_test(tc, test_scalar_point_mult_secp256k1);
  tcase_add_test(tc, test_scalar_point_mult_nist256p1);
  suite_add_tcase(s, tc);

  tc = tcase_create("ed25519");
  tcase_add_test(tc, test_ed25519);
  suite_add_tcase(s, tc);

  tc = tcase_create("ed25519_keccak");
  tcase_add_test(tc, test_ed25519_keccak);
  suite_add_tcase(s, tc);

  tc = tcase_create("ed25519_cosi");
  tcase_add_test(tc, test_ed25519_cosi);
  suite_add_tcase(s, tc);

  tc = tcase_create("ed25519_modm");
  tcase_add_test(tc, test_ed25519_modl_add);
  tcase_add_test(tc, test_ed25519_modl_neg);
  tcase_add_test(tc, test_ed25519_modl_sub);
  suite_add_tcase(s, tc);

#if USE_MONERO
  tc = tcase_create("ed25519_ge");
  tcase_add_test(tc, test_ge25519_double_scalarmult_vartime2);
  suite_add_tcase(s, tc);
#endif

  tc = tcase_create("script");
  tcase_add_test(tc, test_output_script);
  suite_add_tcase(s, tc);

  tc = tcase_create("ethereum_pubkeyhash");
  tcase_add_test(tc, test_ethereum_pubkeyhash);
  suite_add_tcase(s, tc);

  tc = tcase_create("nem_address");
  tcase_add_test(tc, test_nem_address);
  suite_add_tcase(s, tc);

  tc = tcase_create("nem_encryption");
  tcase_add_test(tc, test_nem_derive);
  tcase_add_test(tc, test_nem_cipher);
  suite_add_tcase(s, tc);

  tc = tcase_create("nem_transaction");
  tcase_add_test(tc, test_nem_transaction_transfer);
  tcase_add_test(tc, test_nem_transaction_multisig);
  tcase_add_test(tc, test_nem_transaction_provision_namespace);
  tcase_add_test(tc, test_nem_transaction_mosaic_creation);
  tcase_add_test(tc, test_nem_transaction_mosaic_supply_change);
  tcase_add_test(tc, test_nem_transaction_aggregate_modification);
  suite_add_tcase(s, tc);

  tc = tcase_create("multibyte_address");
  tcase_add_test(tc, test_multibyte_address);
  suite_add_tcase(s, tc);

  tc = tcase_create("rc4");
  tcase_add_test(tc, test_rc4_rfc6229);
  suite_add_tcase(s, tc);

  tc = tcase_create("segwit");
  tcase_add_test(tc, test_segwit);
  suite_add_tcase(s, tc);

  tc = tcase_create("cashaddr");
  tcase_add_test(tc, test_cashaddr);
  suite_add_tcase(s, tc);

  tc = tcase_create("compress_coords");
  tcase_add_test(tc, test_compress_coords);
  suite_add_tcase(s, tc);

  tc = tcase_create("schnorr");
  tcase_add_test(tc, test_schnorr_sign_verify);
  tcase_add_test(tc, test_schnorr_fail_verify);
  suite_add_tcase(s, tc);

#if USE_CARDANO
  tc = tcase_create("bip32-cardano");

  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_1);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_2);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_3);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_4);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_5);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_6);
  tcase_add_test(tc, test_bip32_cardano_hdnode_vector_7);

  tcase_add_test(tc, test_ed25519_cardano_sign_vectors);
  suite_add_tcase(s, tc);
#endif

#if USE_MONERO
  tc = tcase_create("xmr_base58");
  tcase_add_test(tc, test_xmr_base58);
  suite_add_tcase(s, tc);

  tc = tcase_create("xmr_crypto");
  tcase_add_test(tc, test_xmr_getset256_modm);
  tcase_add_test(tc, test_xmr_cmp256_modm);
  tcase_add_test(tc, test_xmr_copy_check_modm);
  tcase_add_test(tc, test_xmr_mulsub256_modm);
  tcase_add_test(tc, test_xmr_muladd256_modm);
  tcase_add_test(tc, test_xmr_curve25519_set);
  tcase_add_test(tc, test_xmr_curve25519_consts);
  tcase_add_test(tc, test_xmr_curve25519_tests);
  tcase_add_test(tc, test_xmr_curve25519_expand_reduce);
  tcase_add_test(tc, test_xmr_ge25519_base);
  tcase_add_test(tc, test_xmr_ge25519_check);
  tcase_add_test(tc, test_xmr_ge25519_scalarmult_base_wrapper);
  tcase_add_test(tc, test_xmr_ge25519_scalarmult);
  tcase_add_test(tc, test_xmr_ge25519_ops);
  suite_add_tcase(s, tc);

  tc = tcase_create("xmr_xmr");
  tcase_add_test(tc, test_xmr_check_point);
  tcase_add_test(tc, test_xmr_h);
  tcase_add_test(tc, test_xmr_fast_hash);
  tcase_add_test(tc, test_xmr_hasher);
  tcase_add_test(tc, test_xmr_hash_to_scalar);
  tcase_add_test(tc, test_xmr_hash_to_ec);
  tcase_add_test(tc, test_xmr_derivation_to_scalar);
  tcase_add_test(tc, test_xmr_generate_key_derivation);
  tcase_add_test(tc, test_xmr_derive_private_key);
  tcase_add_test(tc, test_xmr_derive_public_key);
  tcase_add_test(tc, test_xmr_add_keys2);
  tcase_add_test(tc, test_xmr_add_keys3);
  tcase_add_test(tc, test_xmr_get_subaddress_secret_key);
  tcase_add_test(tc, test_xmr_gen_c);
  tcase_add_test(tc, test_xmr_varint);
  tcase_add_test(tc, test_xmr_gen_range_sig);
  suite_add_tcase(s, tc);
#endif
  return s;
}

// run suite
int main(void) {
  int number_failed;
  Suite *s = test_suite();
  SRunner *sr = srunner_create(s);
  srunner_run_all(sr, CK_VERBOSE);
  number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);
  if (number_failed == 0) {
    printf("PASSED ALL TESTS\n");
  }
  return number_failed;
}