[
{
"path": ".gitignore",
"content": ".vscode\nbuild"
},
{
"path": ".mbedignore",
"content": "examples/*\ntests/*\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2019 Stepan Snigirev\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "# Micro-Bitcoin\n\nC++ Bitcoin library for 32-bit microcontrollers. The library supports [Arduino IDE](https://www.arduino.cc/), [ARM mbed](https://www.mbed.com/en/) and bare metal.
\nIt provides a collection of convenient classes for Bitcoin: private and public keys, HD wallets, generation of the recovery phrases, PSBT transaction formats, scripts — everything required for a hardware wallet or other bitcoin-powered device.\n\nThe library should work on any decent 32-bit microcontroller, like esp32, riscV, stm32 series and others. It *doesn't work* on 8-bit microcontrollers like a classic Arduino as these microcontrollers are not powerful enough to run complicated crypto algorithms.\n\nWe use elliptic curve implementation from [trezor-crypto](https://github.com/trezor/trezor-firmware/tree/master/crypto). API is inspired by [Jimmy Song's](https://github.com/jimmysong/) Porgramming Blockchain class and the [book](https://github.com/jimmysong/programmingbitcoin).\n\n## Documentation\n\nCheck out our [tutorial](https://micro-bitcoin.github.io/#/tutorial/README) where we write a minimal hardware wallet, or browse the [API docs](https://micro-bitcoin.github.io/#/api/README). We also have a collection of [recepies](https://micro-bitcoin.github.io/#/recepies/README) for some common use-cases.\n\nTelegram group: https://t.me/arduinoBitcoin\n\n## Alternative libraries\n\n[DIY Bitcoin Hardware website](https://diybitcoinhardware.com/) has a nice collection of bitcoin-related projects, resources and libraries for makers.\n\nA few bitcoin libraries:\n\n- [secp256k1](https://github.com/bitcoin-core/secp256k1) — elliptic curve library from Bitcoin Core and a [version](https://github.com/diybitcoinhardware/secp256k1-embedded) working with Arduino IDE & Mbed out of the box.\n- [libwally](https://github.com/ElementsProject/libwally-core/) - bitcoin library from Blockstream and a [version](https://github.com/diybitcoinhardware/libwally-embedded) working with Arduino IDE.\n- [f469-disco](https://github.com/diybitcoinhardware/f469-disco) - micropython bitcoin bundle for STM Discovery board and other platforms.\n\n## Installation\n\nThe library is [available](https://www.arduino.cc/reference/en/libraries/ubitcoin/) in the Arduino Library manager, or you can download and install it manually.\n\n[Download](https://github.com/micro-bitcoin/uBitcoin/archive/master.zip) the zip file from our [repository](https://github.com/micro-bitcoin/uBitcoin/) and select in Arduino IDE `Sketch` → `Include library` → `Add .ZIP library...`.\n\nOr clone it into your `Documents/Arduino/libraries` folder:\n\n```sh\ngit clone https://github.com/micro-bitcoin/uBitcoin.git\n```\n\nWhen installed you will also see a few examples in `File` → `Examples` → `Bitcoin` menu.\n\n## Basic usage example\n\nFirst, don't forget to include necessary headers:\n\n```cpp\n// we use these two in our sketch:\n#include \"Bitcoin.h\"\n#include \"PSBT.h\" // if using PSBT functionality\n// other headers of the library\n#include \"Conversion.h\" // to get access to functions like toHex() or fromBase64()\n#include \"Hash.h\" // if using hashes in your code\n```\n\nNow we can write a simple example that does the following:\n\n1. Creates a master private key from a recovery phrase and empty password\n2. Derives account and prints master public key for a watch-only wallet (`zpub` in this case)\n3. Derives and print first segwit address\n4. Parses, signs and prints signed PSBT transaction\n\n```cpp\n// derive master private key\nHDPrivateKey hd(\"add good charge eagle walk culture book inherit fan nature seek repair\", \"\");\n// derive native segwit account (bip-84) for tesnet\nHDPrivateKey account = hd.derive(\"m/84'/1'/0'/\");\n// print xpub: vpub5YkPqVJTA7gjK...AH2rXvcAe3p781G\nSerial.println(account.xpub());\n// or change the account type to UNKNOWN_TYPE to get tpub\nHDPublicKey xpub = account.xpub();\nxpub.type = UNKNOWN_TYPE;\n// this time prints tpubDCnYy4Ty...dL4fLKsBFjFQwz\nSerial.println(xpub);\n// set back correct type to get segwit addresses by default\nxpub.type = P2WPKH;\nSerial.println(hd.fingerprint());\n\n// print first address: tb1q6c8m3whsag5zadgl32nmhuf9q0qmtklws25n6g\nSerial.println(xpub.derive(\"m/0/0\").address());\n\nPSBT tx;\n// parse unsigned transaction\ntx.parseBase64(\"cHNidP8BAHECAAAAAUQS8FqBzYocPDpeQmXBRBH7NwZHVJF39dYJDCXxq\"\n\"zf6AAAAAAD+////AqCGAQAAAAAAFgAUuP0WcSBmiAZYi91nX90hg/cZJ1U8AgMAAAAAABYAF\"\n\"C1RhUR+m/nFyQkPSlP0xmZVxlOqAAAAAAABAR/gkwQAAAAAABYAFNYPuLrw6igutR+Kp7vxJ\"\n\"QPBtdvuIgYDzkBZaAkSIz0P0BexiPYfzInxu9mMeuaOQa1fGEUXcWIYoyAeuFQAAIABAACAA\"\n\"AAAgAAAAAAAAAAAAAAiAgMxjOiFQofq7l9q42nsLA3Ta4zKpEs5eCnAvMnQaVeqsBijIB64V\"\n\"AAAgAEAAIAAAACAAQAAAAAAAAAA\");\n// sign with the root key\ntx.sign(hd);\n// print signed transaction\nSerial.println(tx.toBase64());\n```\n\nReady for more? Check out the [tutorial](https://micro-bitcoin.github.io/#/tutorial/README) and start writing your very own hardware wallet!\n"
},
{
"path": "examples/cpp/Makefile",
"content": "TARGET ?= main\n\nifeq ($(OS),Windows_NT)\nEXT ?= .exe\nelse\nEXT ?= \nendif\n\nTARGET_EXEC ?= $(TARGET)$(EXT)\n\n# Paths\n# to make sure addprefix to LIB_DIR doesn't go out from build directory\nBUILD_DIR = build\nSRC_DIR = .\n# uBitcoin library\nLIB_DIR = ../../src\n\n# Tools\nifeq ($(OS),Windows_NT)\nTOOLCHAIN_PREFIX ?= x86_64-w64-mingw32-\nMKDIR_P = mkdir\nRM_R = rmdir /s /q\nelse\nTOOLCHAIN_PREFIX ?= \nMKDIR_P = mkdir -p\nRM_R = rm -r\nendif\n\n# compilers\nCC := $(TOOLCHAIN_PREFIX)gcc\nCXX := $(TOOLCHAIN_PREFIX)g++\n\n# main.cpp\nCXX_SOURCES = $(wildcard $(SRC_DIR)/*.cpp)\nC_SOURCES =\n\n# uBitcoin sources\nCXX_SOURCES += $(wildcard $(LIB_DIR)/*.cpp)\nC_SOURCES += $(wildcard $(LIB_DIR)/utility/trezor/*.c) \\\n\t\t\t$(wildcard $(LIB_DIR)/utility/*.c) \\\n\t\t\t$(wildcard $(LIB_DIR)/*.c)\n\n# include lib path, don't use mbed or arduino config (-DUSE_STDONLY), debug symbols, all warnings as errors\nFLAGS = -I$(LIB_DIR) -g -Wall -Werror -ldl\nCFLAGS = $(FLAGS)\nCPPFLAGS = $(FLAGS) -DUSE_STDONLY -DUBTC_EXAMPLE\n\nOBJS = $(patsubst $(SRC_DIR)/%, $(BUILD_DIR)/src/%.o, \\\n\t\t$(patsubst $(LIB_DIR)/%, $(BUILD_DIR)/lib/%.o, \\\n\t\t$(C_SOURCES) $(CXX_SOURCES)))\n\nvpath %.cpp $(SRC_DIR)\nvpath %.cpp $(LIB_DIR)\nvpath %.c $(LIB_DIR)\n\n.PHONY: clean all run\n\nall: $(BUILD_DIR)/$(TARGET_EXEC)\n\nrun: $(BUILD_DIR)/$(TARGET_EXEC)\n\t$(BUILD_DIR)/$(TARGET_EXEC)\n\n$(BUILD_DIR)/$(TARGET_EXEC): $(OBJS)\n\t$(CXX) $(OBJS) $(CPPFLAGS) -o $@\n\n# lib c sources\n$(BUILD_DIR)/lib/%.c.o: %.c\n\t$(MKDIR_P) $(dir $@)\n\t$(CC) -c $(CFLAGS) $< -o $@\n\n# lib cpp sources\n$(BUILD_DIR)/lib/%.cpp.o: %.cpp\n\t$(MKDIR_P) $(dir $@)\n\t$(CXX) -c $(CPPFLAGS) $< -o $@\n\n# cpp sources\n$(BUILD_DIR)/src/%.cpp.o: %.cpp\n\t$(MKDIR_P) $(dir $@)\n\t$(CXX) -c $(CPPFLAGS) $< -o $@\n\nclean:\n\t$(RM_R) $(BUILD_DIR)\n"
},
{
"path": "examples/cpp/README.md",
"content": "# C++ example\n\nrun with `make run`\n"
},
{
"path": "examples/cpp/main.cpp",
"content": "/*\n * A simple example showing how to work with uBitcoin in c++ on a PC\n */\n\n// only compile when UBTC_EXAMPLE flag is provided\n// to not clash with platformio's compile-everything approach\n#ifdef UBTC_EXAMPLE\n\n#include \n#include \"Bitcoin.h\"\n#include \"PSBT.h\"\n\n#include \n#include \n\n// You can define your random function to improve side-channel resistance\nextern \"C\" {\n\n // use system random function\n uint32_t random32(void){\n return (uint32_t)rand();\n }\n\n}\n\nusing namespace std;\n\nchar mnemonic[] = \"flight canvas heart purse potato mixed offer tooth maple blue kitten salute almost staff physical remain coral clump midnight rotate innocent shield inch ski\";\n\nint main() {\n // convert mnemonic to xprv\n cout << \"Your mnemonic: \" << endl << mnemonic << endl;\n HDPrivateKey hd(mnemonic, \"\");\n cout << \"Your xprv: \" << endl << string(hd) << endl;\n // derive account xpub\n char derivation[] = \"m/84h/1h/0h\";\n HDPublicKey xpub = hd.derive(derivation).xpub();\n // set network to regtest, otherwise default addresses will be for testnet\n xpub.network = &Regtest;\n cout << \"Account xpub at path \" << derivation << \":\" << endl;\n cout << string(xpub) << endl;\n // print first 5 receiving addresses\n HDPublicKey recv_xpub = xpub.child(0);\n for (uint32_t i = 0; i < 5; i++)\n {\n cout << \"Address #\" << i << \": \" << recv_xpub.child(i).address() << endl;\n }\n\n // signing PSBT transaction with 2 inputs\n PSBT psbt;\n psbt.parseBase64(string(\"cHNidP8BAJoCAAAAAqQW9JR6TFv46IXybtf9tKAy5WsYusr6O4rsfN8DIywEAQAAAAD9////9YKXV2aJad3wScN70cgZHMhQtwhTjw95loZfUB57+H4AAAAAAP3///8CwOHkAAAAAAAWABQzSSTq9G6AboazU3oS+BWVAw1zp21KTAAAAAAAFgAU2SSg4OQMonZrrLpdtTzcNes1MthDAQAAAAEAcQIAAAAB6GDWQUAnmq5s8Nm68qPp3fHnpARmx67Q5ZRHGj1rCjgBAAAAAP7///8CdIv2XwAAAAAWABRozVhYn14Pmv8XoAJePV7AQggf/4CWmAAAAAAAFgAUcOVKtnxrbE7ragGagzMqQ7kJsZkAAAAAAQEfgJaYAAAAAAAWABRw5Uq2fGtsTutqAZqDMypDuQmxmSIGA3s6OgE8GCKOcHDJe7XY0q/i/XSe6e933ErCDCCKR5WoGARkI4xUAACAAQAAgAAAAIAAAAAAAAAAAAABAHECAAAAAaH0XE8I0jQHvCDfdDTUbHrm9+oHbq1yt5ansxoaeeNjAQAAAAD+////AoCWmAAAAAAAFgAUQZD8n6hVi91tRSlWl4WkMwuBnoXsVTuMAAAAABYAFMbknFZNyqOzappeWfZi2+EP0asDAAAAAAEBH4CWmAAAAAAAFgAUQZD8n6hVi91tRSlWl4WkMwuBnoUiBgKNwymEX374HvJHU9FIT4YmCn8CuNteCOxtw7bJXGfscxgEZCOMVAAAgAEAAIAAAACAAAAAAAEAAAAAACICA9OwnpVPPgWAC/O7SuxHNPjX46Iz2Qv9dcI033AqEyv+GARkI4xUAACAAQAAgAAAAIABAAAAAAAAAAA=\"));\n // check parsing is ok\n if(!psbt){\n cout << \"Failed parsing transaction\" << endl;\n exit(EXIT_FAILURE);\n return EXIT_FAILURE;\n }\n cout << \"Transactions details:\" << endl;\n // going through all outputs\n cout << \"Outputs:\" << endl;\n for(unsigned int i = 0; i < psbt.tx.outputsNumber; i++){\n // print addresses\n cout << psbt.tx.txOuts[i].address(&Regtest);\n if(psbt.txOutsMeta[i].derivationsLen > 0){ // there is derivation path\n // considering only single key for simplicity\n PSBTDerivation der = psbt.txOutsMeta[i].derivations[0];\n HDPublicKey pub = hd.derive(der.derivation, der.derivationLen).xpub();\n pub.network = &Regtest;\n if(pub.address() == psbt.tx.txOuts[i].address(&Regtest)){\n cout << \" (change) \";\n }\n }\n cout << \" -> \" << psbt.tx.txOuts[i].btcAmount()*1e3 << \" mBTC\" << endl;\n }\n cout << \"Fee: \" << psbt.fee() << \" sat\" << endl;\n\n // sign using our key\n psbt.sign(hd);\n cout << \"Signed transaction:\" << endl << psbt.toBase64() << endl; // now you can combine and finalize PSBTs in Bitcoin Core\n\n return 0;\n}\n\n#endif // UBTC_EXAMPLE\n"
},
{
"path": "examples/ecdh/ecdh.ino",
"content": "/*\n * This example shows how to use ECDH algorithm\n * to get shared secret between two parties.\n * It is useful if you want to establish\n * secure communication with someone else.\n * You can use ECDH to create symmetric key\n * and then use AES in CBC mode to encrypt/decrypt data.\n */\n#include \n#include \n\nvoid setup(){\n Serial.begin(9600);\n while(!Serial){\n ; // wait for serial port to open\n }\n // generate random private keys and corresponding pubkeys\n byte secret1[32];\n byte secret2[32];\n for(int i=0; i // all single-line hashing algorithms\n#include // to print byte arrays in hex format\n\nvoid setup() {\n Serial.begin(9600);\n while(!Serial){\n ; // wait for serial port to open\n }\n String message = \"Hello world!\"; // message to hash\n byte hash[64] = { 0 }; // hash\n int hashLen = 0;\n\n // sha-256\n hashLen = sha256(message, hash);\n Serial.println(\"SHA-256: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: c0535e4be2b79ffd93291305436bf889314e4a3faec05ecffcbb7df31ad9e51a\");\n\n // you can also pass byte arrays to the hash function\n // and update piece by piece\n byte msg2[] = {1, 2, 3, 4, 5, 0xFA, 0xB0, 0x0B, 0x51};\n // hash in one line\n sha256(msg2, sizeof(msg2), hash);\n // you can also create a class instance and use .write method\n SHA256 h;\n h.begin();\n h.write(msg2, 5); // add first 5 bytes to hash\n h.write(msg2+5, 4); // add another 4 bytes\n h.end(hash); // result will be stored in the hash array\n\n // ripemd-160\n hashLen = rmd160(message, hash);\n Serial.println(\"RMD-160: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: 7f772647d88750add82d8e1a7a3e5c0902a346a3\");\n\n // hash160(msg) = rmd160(sha256(message))\n hashLen = hash160(message, hash);\n Serial.println(\"Hash160: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: 621281c15fb62d5c6013ea29007491e8b174e1b9\");\n\n // sha256(sha256(message))\n hashLen = doubleSha(message, hash);\n Serial.println(\"DoubleSha: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: 7982970534e089b839957b7e174725ce1878731ed6d700766e59cb16f1c25e27\");\n\n // sha512\n hashLen = sha512(message, hash);\n Serial.println(\"Sha512: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: f6cde2a0f819314cdde55fc227d8d7dae3d28cc556222a0a8ad66d91ccad4aad6094f517a2182360c9aacf6a3dc323162cb6fd8cdffedb0fe038f55e85ffb5b6\");\n\n // sha512-hmac\n // here we use more c-style approach\n char key[] = \"Bitcoin seed\";\n hashLen = sha512Hmac((byte*)key, strlen(key), (byte*)message.c_str(), message.length(), hash);\n Serial.println(\"Sha512-HMAC: \" + toHex(hash, hashLen));\n Serial.println(\"Should be: f7fc496a2c17bd09a6328124dc6edebed987e7e93903deee0633a756f1ee81da0753334f6cfe226b5c712d893a68c547d3a5497cd73e1d010670c1e0e9d93a8a\");\n}\n\nvoid loop() {\n\n}\n"
},
{
"path": "examples/mnemonic/mnemonic.ino",
"content": "/*\n * This example shows how to derive master private key from the recovery seed\n * Generate a random recovery seed i.e. on https://iancoleman.io/bip39/\n * and check the master private key, account private key, account public key\n * and first address.\n */\n#include \"Bitcoin.h\"\n\nvoid printHD(String mnemonic, String password = \"\"){\n\n HDPrivateKey hd(mnemonic, password);\n\n if(!hd){ // check if it is valid\n Serial.println(\"Invalid xpub\");\n return;\n }\n Serial.println(\"Mnemonic:\");\n Serial.println(mnemonic);\n Serial.print(\"Password: \\\"\");\n Serial.println(password+\"\\\"\");\n Serial.println(\"Root private key:\");\n Serial.println(hd);\n\n Serial.println(\"bip84 master private key:\");\n HDPrivateKey account = hd.derive(\"m/84'/0'/0'/\");\n Serial.println(account);\n \n Serial.println(\"bip84 master public key:\");\n Serial.println(account.xpub());\n \n Serial.println(\"first address:\");\n Serial.println(account.derive(\"m/0/0/\").address());\n \n Serial.println(\"\\n\");\n}\n\nvoid setup() {\n Serial.begin(115200);\n printHD(\"arch volcano urge cradle turn labor skin secret squeeze denial jacket vintage fix glad lemon\", \"my secret password\");\n\n // entropy bytes to mnemonic\n uint8_t arr[] = {'1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1'};\n String mn = mnemonicFromEntropy(arr, sizeof(arr));\n Serial.println(mn);\n uint8_t out[16];\n size_t len = mnemonicToEntropy(mn, out, sizeof(out));\n Serial.println(toHex(out, len));\n\n}\n\nvoid loop() {\n delay(100);\n}\n"
},
{
"path": "examples/multisig/multisig.ino",
"content": "/*\n * A simple example showing how to derive multisig addresses\n */\n\n#include \"Bitcoin.h\"\n\n// 2 of 3 multisig\n#define NUM_KEYS 3\n#define THRESHOLD 2\n\n// cosigners\nHDPublicKey xpubs[] = {\n // [73c5da0a/48h/1h/0h/2h] abandon * 11 + about\n HDPublicKey(\"Vpub5n95dMZrDHj6SeBgJ1oz4Fae2N2eJNuWK3VTKDb2dzGpMFLUHLmtyDfen7AaQxwQ5mZnMyXdVrkEaoMLVTH8FmVBRVWPGFYWhmtDUGehGmq\"),\n // [fb7c1f11/48h/1h/0h/2h] ability * 11 + acid\n HDPublicKey(\"Vpub5mpiGVPWYfDWqZAvCtJihfU559GdwhNC5gwCa9xjSBp4Bvr1DnqXYTtAogkjvWYN1LGTyKo5Yjhfz7mNAqVmw7KG66CM4mDd8vGH3zPQmBH\"),\n // [47fc1ba1/48h/1h/0h/2h] able * 11 + acid\n HDPublicKey(\"Vpub5nRyr5ptHEvisEDuWRMY3rgQ99B1CU21wfkuXEekTi8jCshCWseGqBWWZ8U3Wgv4jDj2fizxBNZmpFjo56Ffu49Efpu4vAj5XErHyBEQoN9\"),\n};\n\nvoid setup() {\n Serial.begin();\n\n // print first 5 addresses\n for(int idx = 0; idx < 5; idx++){\n // get derivation path\n String derivation = String(\"m/0/\")+String(idx);\n Serial.println(derivation);\n // generate individual public keys and put them into array\n PublicKey pubkeys[NUM_KEYS];\n for(int i=0; i 0){ // there is derivation path\n // considering only single key for simplicity\n PSBTDerivation der = psbt.txOutsMeta[i].derivations[0];\n HDPublicKey pub = hd.derive(der.derivation, der.derivationLen).xpub();\n if(pub.address() == psbt.tx.txOuts[i].address()){\n Serial.print(\" (change) \");\n }\n }\n Serial.print(\" -> \");\n Serial.print(psbt.tx.txOuts[i].btcAmount()*1e3);\n Serial.println(\" mBTC\");\n }\n Serial.print(\"Fee: \");\n Serial.print(float(psbt.fee())/100); // Arduino can't print 64-bit ints\n Serial.println(\" bits\");\n \n psbt.sign(hd);\n Serial.println(psbt.toBase64()); // now you can combine and finalize PSBTs in Bitcoin Core\n}\n\nvoid loop() {\n}\n"
},
{
"path": "examples/schnorr/schnorr.ino",
"content": "/*\n * A simple example showing how to work with uBitcoin in c++ on a PC\n */\n#include \"Bitcoin.h\"\n#include \"Hash.h\"\n\nchar mnemonic[] = \"flight canvas heart purse potato mixed offer tooth maple blue kitten salute almost staff physical remain coral clump midnight rotate innocent shield inch ski\";\n// convert mnemonic to xprv\nHDPrivateKey hd(mnemonic, \"\");\n\nvoid setup() {\n Serial.begin(115200);\n\n Serial.println(\"Your mnemonic: \");\n Serial.println(mnemonic);\n\n // derive private key you want to use for schnorr\n PrivateKey prv = hd.derive(\"m/86h/0h/0h/0/1\");\n // print corresponding public key - schnorr keys are x-only 32-byte keys\n PublicKey pub = prv.publicKey();\n Serial.print(\"Private key: \");\n Serial.println(prv);\n Serial.print(\"X-only public key: \");\n Serial.println(pub.x());\n // sign message\n uint8_t msg[32];\n sha256(\"hello world!\", msg);\n // sign using Schnorr algorithm\n SchnorrSignature sig = prv.schnorr_sign(msg);\n // Unlike ECDSA, Schnorr signature is always 64-bytes long\n Serial.println(\"Signature for message 'hello world!':\");\n Serial.println(sig);\n // verify signatures\n if(pub.schnorr_verify(sig, msg)){\n Serial.println(\"All good, signature is valid\");\n }else{\n Serial.println(\"Something is wrong! Signature is invalid.\");\n }\n}\n\nvoid loop() {\n}\n"
},
{
"path": "examples/tx/tx.ino",
"content": "#include \n#include \"Bitcoin.h\"\n\nvoid setup() {\n Serial.begin(9600);\n while(!Serial){\n ;\n }\n\n // Single private key for testnet\n PrivateKey privateKey(\"cQwxqQwCwGoirnTkVnNt4XqJuEv24HYBvVWCTLtL5g1kx9Q1AEhE\");\n Serial.println(privateKey.address());\n\n TxIn txIn(\"fbeae5f43d76fc3035cb4190baaf8cc123dd04f11c98c8f19a8b12cb4ce90db0\", 0);\n\n // addresses to send bitcoins\n char destination[] = \"n3DN9cswq5jnXXUmLP3bXtR89yfDNWrie9\";\n String change = privateKey.address();\n\n // amounts to send\n // unsigned long can store up to 4294967295 satoshi (42.9 BTC)\n // for larger amounts use uint64_t\n unsigned long availableAmount = 2000000; // 58 mBTC\n unsigned long fee = 1500;\n unsigned long sendAmount = 1000000; // 20 mBTC\n unsigned long changeAmount = availableAmount - sendAmount - fee;\n\n TxOut txOutDestination(sendAmount, destination);\n TxOut txOutChange(changeAmount, change.c_str());\n\n Serial.println(txOutDestination);\n\n // constructing actual transaction\n Tx tx;\n tx.addInput(txIn);\n tx.addOutput(txOutDestination);\n tx.addOutput(txOutChange);\n \n // Printing transaction information\n Serial.print(\"Tx length: \");\n Serial.println(tx.length());\n\n Serial.print(\"Version: \");\n Serial.println(tx.version);\n Serial.print(\"Inputs: \");\n Serial.println(tx.inputsNumber);\n for(int i=0; i< tx.inputsNumber; i++){\n TxIn txin = tx.txIns[i];\n Serial.print(\"\\tHash: \");\n Serial.println(toHex(txin.hash, 32));\n Serial.print(\"\\tOutput index: \");\n Serial.println(txin.outputIndex);\n Serial.print(\"\\tScript length: \");\n Serial.println(txin.scriptSig.length());\n Serial.print(\"\\tScript: \");\n Serial.println(txin.scriptSig);\n Serial.print(\"\\tSequence: \");\n Serial.println(txin.sequence);\n if(tx.isSegwit()){\n Serial.println(\"\\tSEGWIT!\");\n }\n }\n Serial.print(\"Outputs: \");\n Serial.println(tx.outputsNumber);\n\n for(int i=0; i< tx.outputsNumber; i++){\n Serial.print(tx.txOuts[i].address());\n Serial.print(\": \");\n Serial.print(((float)tx.txOuts[i].amount)/100000);\n Serial.println(\" mBTC\");\n }\n\n Serial.println(\"Unsigned transaction:\");\n Serial.println(tx);\n\n // signing transaction\n Serial.println(\"Signing transaction...\");\n Signature sig = tx.signInput(0, privateKey);\n Serial.println(sig);\n\n Serial.println(\"Signed transaction:\");\n Serial.println(tx);\n\n Serial.println(\"Transaction id:\");\n Serial.println(tx.txid());\n \n Serial.println(\"Done\");\n}\n\nvoid loop() {\n // put your main code here, to run repeatedly:\n delay(100);\n}\n"
},
{
"path": "examples/xpubs/xpubs.ino",
"content": "/*\n * This example shows how to derive bitcoin addresses from the master public key (bip32)\n * Enter account master public key to the serial console and get the addresses\n * Use this tool to check: https://iancoleman.io/bip39/\n */\n#include \"Bitcoin.h\"\n\nvoid printAddresses(String pub){\n\n HDPublicKey hd(pub);\n\n if(!hd){ // check if it is valid\n Serial.println(\"Invalid xpub\");\n return;\n }\n\n Serial.println(\"Master public key:\");\n Serial.println(hd);\n \n Serial.println(\"First 5 receiving addresses:\");\n for(int i=0; i<5; i++){\n String path = String(\"m/0/\")+i;\n Serial.print(\"Path:\");\n Serial.println(path);\n Serial.print(\"Address: \");\n Serial.println(hd.derive(path).address());\n // Serial.print(\"Legacy: \");\n // Serial.println(hd.derive(path).legacyAddress());\n // Serial.print(\"Nested segwit: \");\n // Serial.println(hd.derive(path).nestedSegwitAddress());\n // Serial.print(\"Native segwit: \");\n // Serial.println(hd.derive(path).segwitAddress());\n }\n \n Serial.println(\"\\n\");\n}\n\nvoid setup() {\n Serial.begin(115200);\n // bip 44\n printAddresses(\"xpub6BoiLSuHTDytgQejDauyXkBqQ4xTw2tSFKgkHfmZky7jDQQecUKwbFocxZXSJMCSp8gFNBbD9Squ3etZbJkE2qQqVBrypLjWJaWUNmHh3LT\");\n // bip 49\n printAddresses(\"ypub6XMsccDqTfZCUz5m4VjbRLebnjFTLDpeKTgRJuUtAxkpQicB7p4ZwHdmimRuMTcunPfdpzgpVt7DCDKRRffsgmWavWLXccumbyYazC3wh5N\");\n // bip 84\n printAddresses(\"zpub6rcGDMmj82CUJT1uV2mCcsN4EPTgBnJjciDWpYv12yCAPi9TEG5KLPF5iPtqzL6hNmaa5ZGfhJCHctoex7cGgqVxsyWcCDUNUDhjaYRQXzV\");\n Serial.println(\"Enter your master public key:\");\n}\n\nvoid loop() {\n if(Serial.available()){\n String pub = Serial.readStringUntil('\\n');\n Serial.println(pub);\n if(pub.length() > 0){\n printAddresses(pub);\n }\n }\n delay(100);\n}\n"
},
{
"path": "keywords.txt",
"content": "#######################################\n# Syntax Coloring Map\n#######################################\n\n#######################################\n# Hash.h Methods and Functions (KEYWORD2)\n#######################################\n\nrmd160\tKEYWORD2\nsha256\tKEYWORD2\nhash160\tKEYWORD2\ndoubleSha\tKEYWORD2\nsha512\tKEYWORD2\nsha512Hmac\tKEYWORD2\n\n#######################################\n# Datatypes and classes (KEYWORD1)\n#######################################\n\nBitcoin\tKEYWORD1\nHash\tKEYWORD1\nConversion\tKEYWORD1\nOpCodes\tKEYWORD1\n\nScalar\tKEYWORD1\nPoint\tKEYWORD1\nPrivateKey\tKEYWORD1\nPublicKey\tKEYWORD1\nHDPrivateKey\tKEYWORD1\nHDPublicKey\tKEYWORD1\nScript\tKEYWORD1\nSignature\tKEYWORD1\nSchnorrSignature\tKEYWORD1\nTx\tKEYWORD1\nTxIn\tKEYWORD1\nTxOut\tKEYWORD1\nElectrumTx\tKEYWORD1\nPSBT\tKEYWORD1\n\n#######################################\n# Methods and Functions (KEYWORD2)\n#######################################\n\nparse\tKEYWORD2\nparseHex\tKEYWORD2\nparseBase64\tKEYWORD2\ntoBase64\tKEYWORD2\nserialize\tKEYWORD2\nbin\tKEYWORD2\nder\tKEYWORD2\n\ntype\tKEYWORD2\nlength\tKEYWORD2\nscriptLength\tKEYWORD2\nserializeScript\tKEYWORD2\npush\tKEYWORD2\nscriptPubkey\tKEYWORD2\naddress\tKEYWORD2\n\npow\tKEYWORD2\nsign\tKEYWORD2\nschnorr_sign\tKEYWORD2\nverify\tKEYWORD2\nschnorr_verify\tKEYWORD2\nfromSeed\tKEYWORD2\nfromMnemonic\tKEYWORD2\nxpub\tKEYWORD2\nxprv\tKEYWORD2\nchild\tKEYWORD2\nhardenedChild\tKEYWORD2\nderive\tKEYWORD2\nlegacyAddress\tKEYWORD2\nsegwitAddress\tKEYWORD2\nnestedSegwitAddress\tKEYWORD2\nparse\tKEYWORD2\nfromWIF\tKEYWORD2\npublicKey\tKEYWORD2\nsec\tKEYWORD2\nfromHex\tKEYWORD2\ntoHex\tKEYWORD2\ntoString\tKEYWORD2\ngenerateMnemonic\tKEYWORD2\ncheckMnemonic\tKEYWORD2\n\nlittleEndianToInt\tKEYWORD2\nintToLittleEndian\tKEYWORD2\nbigEndianToInt\tKEYWORD2\nintToBigEndian\tKEYWORD2\n\nlenVarInt\tKEYWORD2\nreadVarInt\tKEYWORD2\nreadVarInt\tKEYWORD2\nwriteVarInt\tKEYWORD2\nwriteVarInt\tKEYWORD2\n\naddInput\tKEYWORD2\naddOutput\tKEYWORD2\nsignInput\tKEYWORD2\nsignSegwitInput\tKEYWORD2\nsigHash\tKEYWORD2\n\n######################################\n# Constants (LITERAL1)\n#######################################\n\nPRIME\tLITERAL1\n\nP2PKH\tLITERAL1\nP2SH\tLITERAL1\nP2WPKH\tLITERAL1\nP2WSH\tLITERAL1\nP2SH_P2WPKH\tLITERAL1\nP2SH_P2WSH\tLITERAL1\nSIGHASH_ALL\tLITERAL1\nSIGHASH_NONE\tLITERAL1\nSIGHASH_SINGLE\tLITERAL1\n\n######################################\n# Opcodes (LITERAL1)\n#######################################\n\nOP_0\tLITERAL1\nOP_PUSHDATA1\tLITERAL1\nOP_PUSHDATA2\tLITERAL1\nOP_PUSHDATA4\tLITERAL1\nOP_1NEGATE\tLITERAL1\nOP_RESERVED\tLITERAL1\nOP_1\tLITERAL1\nOP_2\tLITERAL1\nOP_3\tLITERAL1\nOP_4\tLITERAL1\nOP_5\tLITERAL1\nOP_6\tLITERAL1\nOP_7\tLITERAL1\nOP_8\tLITERAL1\nOP_9\tLITERAL1\nOP_10\tLITERAL1\nOP_11\tLITERAL1\nOP_12\tLITERAL1\nOP_13\tLITERAL1\nOP_14\tLITERAL1\nOP_15\tLITERAL1\nOP_16\tLITERAL1\nOP_NOP\tLITERAL1\nOP_VER\tLITERAL1\nOP_IF\tLITERAL1\nOP_NOTIF\tLITERAL1\nOP_VERIF\tLITERAL1\nOP_VERNOTIF\tLITERAL1\nOP_ELSE\tLITERAL1\nOP_ENDIF\tLITERAL1\nOP_VERIFY\tLITERAL1\nOP_RETURN\tLITERAL1\nOP_TOALTSTACK\tLITERAL1\nOP_FROMALTSTACK\tLITERAL1\nOP_2DROP\tLITERAL1\nOP_2DUP\tLITERAL1\nOP_3DUP\tLITERAL1\nOP_2OVER\tLITERAL1\nOP_2ROT\tLITERAL1\nOP_2SWAP\tLITERAL1\nOP_IFDUP\tLITERAL1\nOP_DEPTH\tLITERAL1\nOP_DROP\tLITERAL1\nOP_DUP\tLITERAL1\nOP_NIP\tLITERAL1\nOP_OVER\tLITERAL1\nOP_PICK\tLITERAL1\nOP_ROLL\tLITERAL1\nOP_ROT\tLITERAL1\nOP_SWAP\tLITERAL1\nOP_TUCK\tLITERAL1\nOP_CAT\tLITERAL1\nOP_SUBSTR\tLITERAL1\nOP_LEFT\tLITERAL1\nOP_RIGHT\tLITERAL1\nOP_SIZE\tLITERAL1\nOP_INVERT\tLITERAL1\nOP_AND\tLITERAL1\nOP_OR\tLITERAL1\nOP_XOR\tLITERAL1\nOP_EQUAL\tLITERAL1\nOP_EQUALVERIFY\tLITERAL1\nOP_RESERVED1\tLITERAL1\nOP_RESERVED2\tLITERAL1\nOP_1ADD\tLITERAL1\nOP_1SUB\tLITERAL1\nOP_2MUL\tLITERAL1\nOP_2DIV\tLITERAL1\nOP_NEGATE\tLITERAL1\nOP_ABS\tLITERAL1\nOP_NOT\tLITERAL1\nOP_0NOTEQUAL\tLITERAL1\nOP_ADD\tLITERAL1\nOP_SUB\tLITERAL1\nOP_MUL\tLITERAL1\nOP_DIV\tLITERAL1\nOP_MOD\tLITERAL1\nOP_LSHIFT\tLITERAL1\nOP_RSHIFT\tLITERAL1\nOP_BOOLAND\tLITERAL1\nOP_BOOLOR\tLITERAL1\nOP_NUMEQUAL\tLITERAL1\nOP_NUMEQUALVERIFY\tLITERAL1\nOP_NUMNOTEQUAL\tLITERAL1\nOP_LESSTHAN\tLITERAL1\nOP_GREATERTHAN\tLITERAL1\nOP_LESSTHANOREQUAL\tLITERAL1\nOP_GREATERTHANOREQUAL\tLITERAL1\nOP_MIN\tLITERAL1\nOP_MAX\tLITERAL1\nOP_WITHIN\tLITERAL1\nOP_RIPEMD160\tLITERAL1\nOP_SHA1\tLITERAL1\nOP_SHA256\tLITERAL1\nOP_HASH160\tLITERAL1\nOP_HASH256\tLITERAL1\nOP_CODESEPARATOR\tLITERAL1\nOP_CHECKSIG\tLITERAL1\nOP_CHECKSIGVERIFY\tLITERAL1\nOP_CHECKMULTISIG\tLITERAL1\nOP_CHECKMULTISIGVERIFY\tLITERAL1\nOP_NOP1\tLITERAL1\nOP_CHECKLOCKTIMEVERIFY\tLITERAL1\nOP_CHECKSEQUENCEVERIFY\tLITERAL1\nOP_NOP4\tLITERAL1\nOP_NOP5\tLITERAL1\nOP_NOP6\tLITERAL1\nOP_NOP7\tLITERAL1\nOP_NOP8\tLITERAL1\nOP_NOP9\tLITERAL1\nOP_NOP10\tLITERAL1\nOP_NULLDATA\tLITERAL1\nOP_PUBKEYHASH\tLITERAL1\nOP_PUBKEY\tLITERAL1\nOP_INVALIDOPCODE\tLITERAL1\n"
},
{
"path": "library.json",
"content": "{\n \"name\": \"uBitcoin\",\n \"version\": \"0.2.0\",\n \"description\": \"Brings Bitcoin to embedded devices. Write your own hardware wallet, vending machine or any other bitcoin-powered device. Supports public and private keys, HD wallets, transactions and scripts. Everything required to start working with Bitcoin on microcontrollers.\",\n \"keywords\": \"bitcoin, cryptography\",\n \"repository\":\n {\n \"type\": \"git\",\n \"url\": \"https://github.com/micro-bitcoin/uBitcoin.git\"\n },\n \"authors\":\n [\n {\n \"name\": \"Stepan Snigirev\",\n \"email\": \"snigirev.stepan@gmail.com\",\n \"url\": \"https://stepansnigirev.com\"\n }\n ],\n \"license\": \"MIT\",\n \"homepage\": \"https://micro-bitcoin.github.io\",\n \"dependencies\": {\n },\n \"frameworks\": \"*\",\n \"platforms\": \"*\"\n}\n"
},
{
"path": "library.properties",
"content": "name=uBitcoin\nversion=0.2.0\nauthor=Stepan Snigirev\nmaintainer=Stepan Snigirev \nsentence=Brings Bitcoin to embedded devices\nparagraph=Write your own hardware wallet, vending machine or any other bitcoin-powered device. Supports public and private keys, HD wallets, transactions and scripts. Everything required to start working with Bitcoin on microcontrollers.\ncategory=Data Processing\nurl=https://github.com/micro-bitcoin/uBitcoin\narchitectures=*\n"
},
{
"path": "src/BaseClasses.cpp",
"content": "#include \"uBitcoin_conf.h\"\n#include \"BaseClasses.h\"\n#include \n\n#if USE_STD_STRING\nusing std::string;\n#define String string\n#endif\n\nsize_t SerializeStream::serialize(const Streamable * s, size_t offset){\n return s->to_stream(this, offset);\n}\n\nsize_t ParseStream::parse(Streamable * s){\n return s->from_stream(this);\n}\n/************ Parse Byte Stream Class ************/\n\nParseByteStream::ParseByteStream(const uint8_t * arr, size_t length, encoding_format f){\n last = -1;\n format = f;\n cursor = 0;\n len = (arr == NULL) ? 0 : length;\n buf = arr;\n}\n// TODO: call prev constructor\nParseByteStream::ParseByteStream(const char * arr, encoding_format f){\n last = -1;\n format = f;\n cursor = 0;\n len = (arr == NULL) ? 0 : strlen(arr);\n buf = (const uint8_t *) arr;\n}\nParseByteStream::~ParseByteStream(){\n buf = NULL;\n}\nsize_t ParseByteStream::available(){\n if(format == HEX_ENCODING){\n return (len - cursor)/2;\n }else{\n return len-cursor;\n }\n};\nint ParseByteStream::read(){\n if(format == HEX_ENCODING){\n if(cursor < len-1){\n uint8_t c1 = hexToVal(buf[cursor]);\n uint8_t c2 = hexToVal(buf[cursor+1]);\n if(c1 < 0x10 && c2 < 0x10){\n cursor +=2;\n last = (c1<<4) + c2;\n return last;\n }\n }\n }else{\n if(cursor < len){\n uint8_t c = buf[cursor];\n cursor ++;\n last = c;\n return c;\n }\n }\n return -1;\n}\nint ParseByteStream::getLast(){\n return last;\n}\nsize_t ParseByteStream::read(uint8_t *arr, size_t length){\n size_t cc = 0;\n while(cc 0){\n if(format == HEX_ENCODING){\n buf[cursor] = ((b >> 4) & 0x0F) + '0';\n if(buf[cursor] > '9'){\n buf[cursor] += 'a'-'9'-1;\n }\n cursor++;\n buf[cursor] = (b & 0x0F) + '0';\n if(buf[cursor] > '9'){\n buf[cursor] += 'a'-'9'-1;\n }\n cursor++;\n }else{\n buf[cursor] = b;\n cursor++;\n }\n return 1;\n }\n return 0;\n};\nsize_t SerializeByteStream::write(const uint8_t *arr, size_t length){\n size_t l = 0;\n while(available()>0 && l < length){\n write(arr[l]);\n l++;\n }\n return l;\n};\n\n/************ Readable Class ************/\n\n#ifdef ARDUINO\nsize_t Readable::printTo(Print& p) const{\n size_t len = this->stringLength()+1;\n char * arr = (char *)calloc(len, sizeof(char));\n toString(arr, len);\n p.print(arr);\n free(arr);\n return len-1;\n}\n#endif\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString Readable::toString() const{\n size_t len = this->stringLength()+1;\n char * arr = (char *)calloc(len, sizeof(char));\n toString(arr, len);\n String s = arr;\n free(arr);\n return s;\n};\n#endif\n\n/************ Streamable Class ************/\n\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString Streamable::serialize(size_t offset, size_t len) const{\n if(len == 0){\n len = (length()-offset);\n }\n char * arr = (char *)calloc(2*len+1, sizeof(char));\n serialize(arr, 2*len, offset, HEX_ENCODING);\n String s = arr;\n free(arr);\n return s;\n};\n#endif\n\nsize_t Streamable::serialize(uint8_t * arr, size_t len, size_t offset, encoding_format format) const{\n SerializeByteStream s(arr, len, format);\n return to_stream(&s, offset);\n}\n\n"
},
{
"path": "src/BaseClasses.h",
"content": "#ifndef __BITCOIN_BASE_CLASSES_H__\n#define __BITCOIN_BASE_CLASSES_H__\n\n#include \"uBitcoin_conf.h\"\n#include \"Conversion.h\"\n\n#include \n#include \n\nenum encoding_format{\n RAW = 0,\n HEX_ENCODING = 16\n // TODO: would be nice to have base64 encoding here\n};\n\nenum parse_status{\n PARSING_DONE = 0,\n PARSING_INCOMPLETE = 1,\n PARSING_FAILED = 2\n};\n// error codes struct / class?\n\nclass Streamable;\n\nclass ParseStream{\npublic:\n virtual size_t available(){ return 0; };\n virtual int read(){ return -1; };\n virtual size_t read(uint8_t *arr, size_t length){ return 0; };\n virtual int getLast(){ return -1; };\n size_t parse(Streamable * s);\n};\n\n// TODO: skip leading non-hex if it's hex format\nclass ParseByteStream: public ParseStream{\nprivate:\n const uint8_t * buf;\n size_t cursor;\n size_t len;\n encoding_format format;\n int last;\npublic:\n ParseByteStream(const uint8_t * arr, size_t length, encoding_format f=RAW);\n ParseByteStream(const char * arr, encoding_format f=HEX_ENCODING);\n ~ParseByteStream();\n size_t available();\n int read();\n size_t read(uint8_t *arr, size_t length);\n virtual int getLast();\n};\n\nclass SerializeStream{\npublic:\n virtual size_t available(){ return 0; };\n virtual size_t write(uint8_t b){ return 0; };\n virtual size_t write(const uint8_t *arr, size_t len){ return 0; };\n size_t serialize(const Streamable * s, size_t offset);\n};\n\nclass SerializeByteStream: public SerializeStream{\nprivate:\n uint8_t * buf;\n size_t cursor;\n size_t len;\n encoding_format format;\npublic:\n SerializeByteStream(uint8_t * arr, size_t length, encoding_format f=RAW);\n explicit SerializeByteStream(char * arr, size_t length, encoding_format f=HEX_ENCODING);\n size_t available();\n size_t write(uint8_t b);\n size_t write(const uint8_t *arr, size_t length);\n};\n\n/** Abstract Readable class that can be encoded as a string and displayed to the user\n * Can be converted to and from a string (char *, Arduino String and std::string)\n * In Arduino it can be directly printed to the serial port, display or other Print device\n */\n#ifdef ARDUINO\nclass Readable: public Printable{\n#else\nclass Readable{\n#endif\nprivate:\nprotected:\n /* override these functions in your class */\n virtual size_t to_str(char * buf, size_t len) const = 0;\n virtual size_t from_str(const char * buf, size_t len) = 0;\npublic:\n /* override these function in your class */\n virtual size_t stringLength() const = 0;\n\n size_t toString(char * buf, size_t len) const{ return this->to_str(buf, len); };\n size_t fromString(const char * buf, size_t len){ return this->from_str(buf, len); };\n size_t fromString(const char * buf){ return this->from_str(buf, strlen(buf)); };\n#ifdef ARDUINO\n size_t printTo(Print& p) const;\n#endif\n#if USE_ARDUINO_STRING\n String toString() const;\n operator String(){ return this->toString(); };\n#endif\n#if USE_STD_STRING\n std::string toString() const;\n operator std::string(){ return this->toString(); };\n#endif\n};\n\n/** Abstract Streamable class that can be serialized to/from a sequence of bytes\n * and sent to Stream (File, Serial, Bluetooth) without allocating extra memory\n * Class can be parsed and serialized in raw and hex formats\n */\nclass Streamable: public Readable{\n friend class SerializeStream;\n friend class ParseStream;\nprivate:\nprotected:\n virtual size_t from_stream(ParseStream *s) = 0;\n virtual size_t to_stream(SerializeStream *s, size_t offset) const = 0;\n virtual size_t to_str(char * buf, size_t len) const{\n return serialize(buf, len);\n }\n virtual size_t from_str(const char * buf, size_t len){\n return parse(buf, len);\n }\n parse_status status;\n size_t bytes_parsed;\npublic:\n Streamable() { status = PARSING_DONE; bytes_parsed = 0; };\n virtual void reset(){ status = PARSING_DONE; bytes_parsed = 0; }; // used to reset parsing and mb object\n virtual size_t length() const = 0;\n virtual size_t stringLength() const{ return 2*length(); };\n /** \\brief Gets parsing status. \n * PARSING_DONE - everything is ok, \n * PARSING_INCOMPLETE - some data is still missing\n * PARSING_FAILED - something went wrong, the data is probably incorrect.\n */\n parse_status getStatus(){ return status; };\n /** \\brief Sets parsing status. Should be used with care. */\n void setStatus(parse_status s){ status = s; };\n size_t parse(const uint8_t * arr, size_t len, encoding_format format=RAW){\n ParseByteStream s(arr, len, format);\n return from_stream(&s);\n }\n#if USE_ARDUINO_STRING\n size_t parse(String arr, encoding_format format=HEX_ENCODING){\n return parse(arr.c_str(), strlen(arr.c_str()), format);\n }\n#endif\n#if USE_STD_STRING\n size_t parse(std::string arr, encoding_format format=HEX_ENCODING){\n return parse(arr.c_str(), strlen(arr.c_str()), format);\n }\n#endif\n#if !(USE_ARDUINO_STRING || USE_STD_STRING)\n size_t parse(const char * arr, encoding_format format=HEX_ENCODING){\n return parse(arr, strlen(arr), format);\n }\n#endif\n size_t serialize(uint8_t * arr, size_t len, size_t offset = 0, encoding_format format=RAW) const;\n size_t parse(const char * arr, size_t len, encoding_format format=HEX_ENCODING){\n return parse((const uint8_t *) arr, len, format);\n }\n size_t serialize(char * arr, size_t len, size_t offset = 0, encoding_format format=HEX_ENCODING) const{\n return serialize((uint8_t *)arr, len, offset, format);\n }\n#if USE_ARDUINO_STRING\n String serialize(size_t offset=0, size_t len=0) const;\n#endif\n#if USE_STD_STRING\n std::string serialize(size_t offset=0, size_t len=0) const;\n std::string serialize(int offset, int len) const{\n return serialize((size_t)offset, (size_t)len);\n };\n std::string serialize(size_t offset, int len) const{\n return serialize((size_t)offset, (size_t)len);\n };\n#endif\n};\n\n#endif // __BITCOIN_BASE_CLASSES_H__\n"
},
{
"path": "src/Bitcoin.cpp",
"content": "#include \"Bitcoin.h\"\n#include \"Hash.h\"\n#include \"Conversion.h\"\n\n#include \n#include \n#include \"utility/trezor/sha2.h\"\n#include \"utility/trezor/rfc6979.h\"\n#include \"utility/trezor/ecdsa.h\"\n#include \"utility/trezor/secp256k1.h\"\n#include \"utility/segwit_addr.h\"\n#include \"utility/trezor/bip39.h\"\n#include \"utility/trezor/memzero.h\"\n\n#if USE_STD_STRING\nusing std::string;\n#define String std::string\n#endif\n\n// error code when parsing fails\nint ubtc_errno = 0;\n\nconst char * generateMnemonic(uint8_t numWords){\n if(numWords<12 || numWords > 24 || numWords % 3 != 0){\n return NULL;\n }\n int strength = numWords*32/3;\n return mnemonic_generate(strength);\n}\nconst char * generateMnemonic(uint8_t numWords, const uint8_t * entropy_data, size_t dataLen){\n if(numWords<12 || numWords > 24 || numWords % 3 != 0){\n return NULL;\n }\n uint8_t hash[32];\n sha256(entropy_data, dataLen, hash);\n size_t len = numWords*4/3;\n return mnemonic_from_data(hash, len);\n}\n\nconst char * mnemonicFromEntropy(const uint8_t * entropy_data, size_t dataLen){\n return mnemonic_from_data(entropy_data, dataLen);\n}\nsize_t mnemonicToEntropy(const char * mnemonic, size_t mnemonicLen, uint8_t * output, size_t outputLen){\n int num_words = 1;\n for (size_t i = 0; i < strlen(mnemonic); i++){\n if(mnemonic[i] == ' '){\n num_words ++;\n }\n }\n size_t entropy_len = (num_words*4)/3;\n if(outputLen < entropy_len){\n return 0;\n }\n uint8_t res[33] = {0};\n int r = mnemonic_to_entropy(mnemonic, res);\n if(r == 0){\n return 0;\n }\n memcpy(output, res, entropy_len);\n return entropy_len;\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nsize_t mnemonicToEntropy(String mnemonic, uint8_t * output, size_t outputLen){\n return mnemonicToEntropy(mnemonic.c_str(), mnemonic.length(), output, outputLen);\n}\n#else\nsize_t mnemonicToEntropy(char * mnemonic, uint8_t * output, size_t outputLen){\n return mnemonicToEntropy(mnemonic, strlen(mnemonic), output, outputLen);\n}\n#endif\n\nconst char * generateMnemonic(const uint8_t * entropy_data, size_t dataLen){\n return generateMnemonic(24, entropy_data, dataLen);\n}\n#if !(USE_ARDUINO_STRING || USE_STD_STRING)\nconst char * generateMnemonic(uint8_t numWords, const char * entropy_string){\n return generateMnemonic(numWords, (uint8_t*)entropy_string, strlen(entropy_string));\n}\nconst char * generateMnemonic(const char * entropy_string){\n return generateMnemonic(24, entropy_string);\n}\nbool checkMnemonic(const char * mnemonic){\n return mnemonic_check(mnemonic);\n}\n#else\nconst char * generateMnemonic(uint8_t numWords, const String entropy_string){\n return generateMnemonic(numWords, (uint8_t*)entropy_string.c_str(), strlen(entropy_string.c_str()));\n}\nconst char * generateMnemonic(const String entropy_string){\n return generateMnemonic(24, entropy_string);\n}\nbool checkMnemonic(const String mnemonic){\n return mnemonic_check(mnemonic.c_str());\n}\n#endif\n\n// ---------------------------------------------------------------- Signature class\n\nSignature::Signature(){\n memzero(tot, 3); index = 0;\n memzero(r, 32);\n memzero(s, 32);\n}\nSignature::Signature(const uint8_t r_arr[32], const uint8_t s_arr[32]){\n memzero(tot, 3); index = 0;\n memcpy(r, r_arr, 32);\n memcpy(s, s_arr, 32);\n}\nSignature::Signature(const uint8_t * der){\n memzero(tot, 3); index = 0; memzero(r, 32); memzero(s, 32);\n fromDer(der, der[1]+2);\n}\nSignature::Signature(const uint8_t * der, size_t derLen){\n memzero(tot, 3); index = 0; memzero(r, 32); memzero(s, 32);\n fromDer(der, derLen);\n}\nSignature::Signature(const char * der){\n memzero(tot, 3); index = 0; memzero(r, 32); memzero(s, 32);\n ParseByteStream s(der);\n Signature::from_stream(&s);\n}\nsize_t Signature::from_stream(ParseStream *stream){\n // der encoding is probably the most uneffective way to encode signatures...\n // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]\n // * total-length: 1-byte length descriptor of everything that follows\n // * R-length: 1-byte length descriptor of the R value that follows.\n // * R: arbitrary-length big-endian encoded R value. It must use the shortest\n // possible encoding for a positive integers (which means no null bytes at\n // the start, except a single one when the next byte has its highest bit set).\n // * S-length: 1-byte length descriptor of the S value that follows.\n // * S: arbitrary-length big-endian encoded S value. The same rules apply.\n if(status == PARSING_FAILED){\n return 0;\n }\n if(status == PARSING_DONE){\n bytes_parsed = 0;\n memzero(tot, 3);\n memzero(r, 32);\n memzero(s, 32);\n }\n status = PARSING_INCOMPLETE;\n size_t bytes_read = 0;\n uint8_t c = 0;\n if(stream->available() && bytes_parsed+bytes_read < 1){\n c = stream->read();\n bytes_read++;\n if(c!=0x30){\n status = PARSING_FAILED;\n return bytes_read;\n }\n }\n if(stream->available() && bytes_parsed+bytes_read < 2){\n tot[0] = stream->read();\n bytes_read++;\n if(tot[0] > 70){ status = PARSING_FAILED; return bytes_read; }\n }\n // r\n if(stream->available() && bytes_parsed+bytes_read < 3){\n c = stream->read();\n bytes_read++;\n if(c != 0x02){ status = PARSING_FAILED; return bytes_read; }\n }\n if(stream->available() && bytes_parsed+bytes_read < 4){\n tot[1] = stream->read();\n bytes_read++;\n if(tot[1] > 33){ status = PARSING_FAILED; return bytes_read; }\n }\n if(stream->available() && tot[1]==33 && bytes_parsed+bytes_read < 5){\n c = stream->read();\n bytes_read++;\n if(c != 0){ status = PARSING_FAILED; return bytes_read; }\n }\n while(stream->available() && bytes_parsed+bytes_read < (size_t)4+tot[1]){\n r[bytes_parsed+bytes_read-4+32-tot[1]] = stream->read();\n bytes_read++;\n }\n if(rlen() != tot[1]){ status = PARSING_FAILED; return bytes_read; }\n // s\n if(stream->available() && bytes_parsed+bytes_read < (size_t)4+tot[1]+1){\n c = stream->read();\n bytes_read++;\n if(c != 0x02){ status = PARSING_FAILED; return bytes_read; }\n }\n if(stream->available() && bytes_parsed+bytes_read < (size_t)4+tot[1]+2){\n tot[2] = stream->read();\n bytes_read++;\n if(tot[2] > 33){ status = PARSING_FAILED; return bytes_read; }\n }\n if(stream->available() && tot[2]==33 && bytes_parsed+bytes_read < (size_t)4+tot[1]+3){\n c = stream->read();\n bytes_read++;\n if(c != 0){ status = PARSING_FAILED; return bytes_read; }\n }\n while(stream->available() && bytes_parsed+bytes_read < (size_t)4+tot[1]+2+tot[2]){\n s[bytes_parsed+bytes_read-4-tot[1]-2-tot[2]+32] = stream->read();\n bytes_read++;\n }\n if(slen() != tot[2]){ status = PARSING_FAILED; return bytes_read; }\n if(bytes_parsed+bytes_read == (size_t)4+tot[1]+2+tot[2]){\n status = PARSING_DONE;\n }\n bytes_parsed+=bytes_read;\n return bytes_read;\n}\n\nsize_t Signature::to_stream(SerializeStream *stream, size_t offset) const{\n uint8_t arr[72];\n der(arr, sizeof(arr));\n size_t l = Signature::length();\n size_t bytes_written = 0;\n while(stream->available() && offset+bytes_written < l){\n stream->write(arr[offset+bytes_written]);\n bytes_written++;\n }\n return bytes_written;\n}\n\nsize_t Signature::rlen() const{\n uint8_t len = 33;\n for(int i=0; i<32; i++){\n if(r[i] > 0){\n if(r[i] < 0x80){\n len --;\n }\n break;\n }else{\n len--;\n }\n }\n return len;\n}\nsize_t Signature::slen() const{\n uint8_t len = 33;\n for(int i=0; i<32; i++){\n if(s[i] > 0){\n if(s[i] < 0x80){\n len --;\n }\n break;\n }else{\n len--;\n }\n }\n return len;\n}\nsize_t Signature::length() const{\n return rlen()+slen()+6;\n}\n\nsize_t Signature::fromDer(const uint8_t * raw, size_t rawLen){\n ParseByteStream stream(raw, rawLen);\n return Signature::from_stream(&stream);\n}\nsize_t Signature::der(uint8_t * bytes, size_t len) const{\n memzero(bytes, len);\n uint8_t _rlen = rlen();\n uint8_t _slen = slen();\n bytes[0] = 0x30;\n bytes[1] = 4+_rlen+2+_slen-2;\n bytes[2] = 0x02;\n bytes[3] = _rlen;\n if(_rlen == 33){\n memcpy(bytes+5, r, 32);\n }else{\n memcpy(bytes+4, r+32-_rlen, _rlen);\n }\n\n bytes[4+_rlen] = 0x02;\n bytes[4+_rlen+1] = _slen;\n if(_slen == 33){\n memcpy(bytes+4+_rlen+3, s, 32);\n }else{\n memcpy(bytes+4+_rlen+2, s+32-_slen, _slen);\n }\n return 4+_rlen+2+_slen;\n}\nvoid Signature::bin(uint8_t * arr, size_t len) const{\n size_t l = len;\n if(l > 32){\n l = 32;\n }\n memcpy(arr, r, l);\n if(len > 32){\n l = len-32;\n if(l > 32){\n l = 32;\n }\n memcpy(arr+32, s, l);\n }\n if(len > 64){\n arr[64] = index;\n }\n}\nvoid Signature::fromBin(const uint8_t * arr, size_t len){\n size_t l = len;\n if(l > 32){\n l = 32;\n }\n memcpy(r, arr, l);\n if(len > 32){\n l = len-32;\n if(l > 32){\n l = 32;\n }\n memcpy(s, arr+32, l);\n }\n if(len > 64){\n index = arr[64];\n }\n}\n\n// ---------------------------------------------------------------- SchnorrSignature\n\nSchnorrSignature::SchnorrSignature(){\n memzero(r, 32);\n memzero(s, 32);\n}\nSchnorrSignature::SchnorrSignature(const uint8_t r_arr[32], const uint8_t s_arr[32]){\n memcpy(r, r_arr, 32);\n memcpy(s, s_arr, 32);\n}\nSchnorrSignature::SchnorrSignature(const uint8_t rs_arr[64]){\n memcpy(r, rs_arr, 32);\n memcpy(s, rs_arr+32, 32);\n}\nSchnorrSignature::SchnorrSignature(const char * rs){\n memzero(r, 32); memzero(s, 32);\n ParseByteStream s(rs);\n SchnorrSignature::from_stream(&s);\n}\nsize_t SchnorrSignature::from_stream(ParseStream *stream){\n if(status == PARSING_FAILED){\n return 0;\n }\n if(status == PARSING_DONE){\n bytes_parsed = 0;\n memzero(r, 32);\n memzero(s, 32);\n }\n status = PARSING_INCOMPLETE;\n size_t bytes_read = 0;\n while(stream->available() && bytes_parsed+bytes_read < 32){\n r[bytes_read+bytes_parsed] = stream->read();\n bytes_read++;\n }\n while(stream->available() && bytes_parsed+bytes_read < 64){\n s[bytes_read+bytes_parsed-32] = stream->read();\n bytes_read++;\n }\n if(bytes_parsed+bytes_read == 64){\n status = PARSING_DONE;\n }\n bytes_parsed+=bytes_read;\n return bytes_read;\n}\n\nsize_t SchnorrSignature::to_stream(SerializeStream *stream, size_t offset) const{\n uint8_t arr[64];\n memcpy(arr, r, 32);\n memcpy(arr+32, s, 32);\n size_t l = sizeof(arr);\n size_t bytes_written = 0;\n while(stream->available() && offset+bytes_written < l){\n stream->write(arr[offset+bytes_written]);\n bytes_written++;\n }\n return bytes_written;\n}\n\n// ---------------------------------------------------------------- PublicKey class\n\nint PublicKey::legacyAddress(char * address, size_t len, const Network * network) const{\n memzero(address, len);\n\n uint8_t buffer[20];\n uint8_t sec_arr[65] = { 0 };\n int l = sec(sec_arr, sizeof(sec_arr));\n hash160(sec_arr, l, buffer);\n\n uint8_t addr[21];\n addr[0] = network->p2pkh;\n memcpy(addr+1, buffer, 20);\n\n return toBase58Check(addr, 21, address, len);\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString PublicKey::legacyAddress(const Network * network) const{\n char addr[40] = { 0 };\n legacyAddress(addr, sizeof(addr), network);\n return String(addr);\n}\n#endif\nint PublicKey::segwitAddress(char address[], size_t len, const Network * network) const{\n memzero(address, len);\n if(len < 76){ // TODO: 76 is too much for native segwit\n return 0;\n }\n uint8_t hash[20];\n uint8_t sec_arr[65] = { 0 };\n int l = sec(sec_arr, sizeof(sec_arr));\n hash160(sec_arr, l, hash);\n segwit_addr_encode(address, network->bech32, 0, hash, 20);\n return 76;\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString PublicKey::segwitAddress(const Network * network) const{\n char addr[76] = { 0 };\n segwitAddress(addr, sizeof(addr), network);\n return String(addr);\n}\n#endif\nint PublicKey::nestedSegwitAddress(char address[], size_t len, const Network * network) const{\n memzero(address, len);\n uint8_t script[22] = { 0 };\n // script[0] = 0x00; // no need to set - already zero\n script[1] = 0x14;\n uint8_t sec_arr[65] = { 0 };\n int l = sec(sec_arr, sizeof(sec_arr));\n hash160(sec_arr, l, script+2);\n\n uint8_t addr[21];\n addr[0] = network->p2sh;\n hash160(script, 22, addr+1);\n\n return toBase58Check(addr, 21, address, len);\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString PublicKey::nestedSegwitAddress(const Network * network) const{\n char addr[40] = { 0 };\n nestedSegwitAddress(addr, sizeof(addr), network);\n return String(addr);\n}\n#endif\nScript PublicKey::script(ScriptType type) const{\n return Script(*this, type);\n}\nbool PublicKey::verify(const Signature sig, const uint8_t hash[32]) const{\n uint8_t signature[64] = {0};\n sig.bin(signature, 64);\n uint8_t pub[65];\n serialize(pub, 65);\n return (ecdsa_verify_digest(&secp256k1, pub, signature, hash)==0);\n}\nbool PublicKey::schnorr_verify(const SchnorrSignature sig, const uint8_t hash[32]) const{\n PublicKey pub = *this;\n if(!pub.isEven()){\n pub = -pub;\n }\n uint8_t rs[64];\n sig.serialize(rs, sizeof(rs));\n PublicKey R;\n R.from_x(rs, 32);\n // calculate hash using tagged hash with \"BIP0340/challenge\" prefix\n uint8_t e[32];\n uint8_t tmp[32];\n TaggedHash tch(\"BIP0340/challenge\");\n // write R\n tch.write(rs, 32);\n // write xonly pubkey\n pub.x(tmp, sizeof(tmp));\n tch.write(tmp, sizeof(tmp));\n // write message\n tch.write(hash, 32);\n tch.end(e);\n PrivateKey challenge(e);\n PublicKey S = challenge*pub + R;\n S.x(tmp, sizeof(tmp));\n PrivateKey s(rs+32);\n s.publicKey().x(e, 32);\n return memcmp(tmp, e, 32) == 0;\n};\n\n// ---------------------------------------------------------------- PrivateKey class\n\nsize_t PrivateKey::from_stream(ParseStream *s){\n if(status == PARSING_FAILED){\n return 0;\n }\n if(status == PARSING_DONE){\n bytes_parsed = 0;\n }\n status = PARSING_INCOMPLETE;\n size_t bytes_read = 0;\n while(s->available() > 0 && bytes_parsed+bytes_read < 32){\n num[bytes_parsed+bytes_read] = s->read();\n bytes_read++;\n }\n if(bytes_parsed+bytes_read == 32){\n status = PARSING_DONE;\n uint8_t zero[32] = { 0 };\n if(memcmp(num, zero, 32)==0){ // should we add something else here?\n status = PARSING_FAILED;\n }\n bignum256 n;\n bn_read_be(num, &n);\n bn_mod(&n, &secp256k1.order);\n bn_write_be(&n, num);\n pubKey = *this * GeneratorPoint;\n }\n bytes_parsed += bytes_read;\n return bytes_read;\n}\nPrivateKey::PrivateKey(void){\n reset();\n memzero(num, 32); // empty key\n network = &DEFAULT_NETWORK;\n}\nPrivateKey::PrivateKey(const uint8_t * secret_arr, bool use_compressed, const Network * net){\n reset();\n memcpy(num, secret_arr, 32);\n network = net;\n pubKey = *this * GeneratorPoint;\n pubKey.compressed = use_compressed;\n}\nPrivateKey::PrivateKey(const ECScalar other){\n reset();\n other.getSecret(num);\n pubKey = *this * GeneratorPoint;\n pubKey.compressed = true;\n network = &DEFAULT_NETWORK;\n}\n/*PrivateKey &PrivateKey::operator=(const PrivateKey &other){\n if (this == &other){ return *this; } // self-assignment\n reset();\n other.getSecret(num);\n network = other.network;\n pubKey = *this * GeneratorPoint;\n pubKey.compressed = other.pubKey.compressed;\n return *this;\n};*/\nPrivateKey::~PrivateKey(void) {\n reset();\n // erase secret key from memory\n memzero(num, 32);\n}\nint PrivateKey::wif(char * wifArr, size_t wifSize) const{\n memzero(wifArr, wifSize);\n\n uint8_t wifHex[34] = { 0 }; // prefix + 32 bytes secret (+ compressed )\n size_t len = 33;\n wifHex[0] = network->wif;\n memcpy(wifHex+1, num, 32);\n if(pubKey.compressed){\n wifHex[33] = 0x01;\n len++;\n }\n size_t l = toBase58Check(wifHex, len, wifArr, wifSize);\n\n memzero(wifHex, sizeof(wifHex)); // secret should not stay in RAM\n return l;\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString PrivateKey::wif() const{\n char wifString[53] = { 0 };\n wif(wifString, sizeof(wifString));\n return String(wifString);\n}\n#endif\nint PrivateKey::fromWIF(const char * wifArr, size_t wifSize){\n uint8_t arr[40] = { 0 };\n size_t l = fromBase58Check(wifArr, wifSize, arr, sizeof(arr));\n if( (l < 33) || (l > 34) ){\n memzero(num, 32);\n return 0;\n }\n bool compressed;\n network = &DEFAULT_NETWORK;\n bool found = false;\n for(int i=0; iwif){\n network = networks[i];\n found = true;\n break;\n }\n }\n if(!found){\n return 0;\n }\n\n if(l == 34){\n compressed = (arr[33] > 0);\n }\n if(l == 33){\n compressed = false;\n }\n memcpy(num, arr+1, 32);\n memzero(arr, 40); // clear memory\n\n pubKey = *this * GeneratorPoint;\n pubKey.compressed = compressed;\n return 1;\n}\nint PrivateKey::fromWIF(const char * wifArr){\n return fromWIF(wifArr, strlen(wifArr));\n}\n\nPublicKey PrivateKey::publicKey() const{\n return pubKey;\n}\n\nint PrivateKey::address(char * address, size_t len) const{\n return pubKey.address(address, len, network);\n}\nint PrivateKey::legacyAddress(char * address, size_t len) const{\n return pubKey.legacyAddress(address, len, network);\n}\nint PrivateKey::segwitAddress(char * address, size_t len) const{\n return pubKey.segwitAddress(address, len, network);\n}\nint PrivateKey::nestedSegwitAddress(char * address, size_t len) const{\n return pubKey.nestedSegwitAddress(address, len, network);\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nString PrivateKey::address() const{\n return pubKey.address(network);\n}\nString PrivateKey::legacyAddress() const{\n return pubKey.legacyAddress(network);\n}\nString PrivateKey::segwitAddress() const{\n return pubKey.segwitAddress(network);\n}\nString PrivateKey::nestedSegwitAddress() const{\n return pubKey.nestedSegwitAddress(network);\n}\n#endif\n\nint PrivateKey::ecdh(const PublicKey pub, uint8_t shared_secret[32], bool use_hash){\n // calculate pk * pub, serialize as uncompressed point and hash \n ECPoint mult = *this * pub;\n mult.compressed = false;\n uint8_t sec[65];\n mult.sec(sec, sizeof(sec));\n if(use_hash){\n sha256(sec+1, 64, shared_secret);\n }else{\n // just copy x\n memcpy(shared_secret, sec+1, 32);\n }\n return 1;\n}\n\nstatic int is_canonical(uint8_t by, uint8_t sig[64]){\n return 1;\n}\n\nSignature PrivateKey::sign(const uint8_t hash[32]) const{\n uint8_t signature[65] = {0};\n uint8_t i = 0;\n ecdsa_sign_digest(&secp256k1, num, hash, signature, &i, &is_canonical);\n Signature sig(signature, signature+32);\n sig.index = i;\n return sig;\n}\n\nSchnorrSignature PrivateKey::schnorr_sign(const uint8_t hash[32]) const{\n PrivateKey prv = *this;\n PublicKey pub = prv.publicKey();\n // check if pubkey is even, if not - negate\n if(!pub.isEven()){\n prv = -prv;\n pub = -pub;\n }\n uint8_t r[32];\n uint8_t s[32];\n uint8_t tmp[32];\n // generate k using tagged hash with \"BIP0340/nonce\" prefix\n uint8_t nonce[32];\n TaggedHash tnonce(\"BIP0340/nonce\");\n prv.getSecret(tmp);\n tnonce.write(tmp, sizeof(tmp));\n pub.x(tmp, sizeof(tmp));\n tnonce.write(tmp, sizeof(tmp));\n tnonce.write(hash, 32);\n tnonce.end(nonce);\n PrivateKey k(nonce);\n PublicKey R = k.publicKey();\n // flip k if r is not even\n if(!R.isEven()){\n k = -k;\n R = -R;\n }\n\n // calculate hash using tagged hash with \"BIP0340/challenge\" prefix\n uint8_t e[32];\n TaggedHash tch(\"BIP0340/challenge\");\n R.x(r, sizeof(r));\n tch.write(r, sizeof(r));\n pub.x(tmp, sizeof(tmp));\n tch.write(tmp, sizeof(tmp));\n tch.write(hash, 32);\n tch.end(e);\n PrivateKey challenge(e);\n // calculate s\n PrivateKey S = k + challenge*prv;\n S.getSecret(s);\n\n SchnorrSignature sig(r, s);\n return sig;\n}\n#if USE_ARDUINO_STRING || USE_STD_STRING\nPrivateKey::PrivateKey(const String wifString){\n fromWIF(wifString.c_str());\n}\n#else\nPrivateKey::PrivateKey(const char * wifArr){\n fromWIF(wifArr);\n}\n#endif\n"
},
{
"path": "src/Bitcoin.h",
"content": "/** @file Bitcoin.h\n */\n\n#ifndef __BITCOIN_H__\n#define __BITCOIN_H__\n\n#include \"uBitcoin_conf.h\"\n#include \"BaseClasses.h\"\n#include \"BitcoinCurve.h\"\n#include \"Conversion.h\"\n#include \"Networks.h\"\n#include \"utility/trezor/rand.h\"\n#include \n#include \n\n/* TODO:\n - autodetect mnemonic w/o passwd or xprv\n - HD.derive()\n - accept strings instead of char arrays for txout (address) and other things\n - fail if script or witness is too large\n - fix is_canonical function\n - refactor fromWIF to return bytes read\n - fix all warnings\n - psbt\n - docs\n - publish on arduino libs and mbed\n - operators +, += in script - concatenation\n - signature & everything from char array might be not a bright idea\n - tests (egde cases!)\n - sidechannel for pubkey calculation - use rng\n */\n\nextern int ubtc_errno;\n\n// number of rounds for mnemonic to seed conversion\n#define PBKDF2_ROUNDS 2048\n#define HARDENED_INDEX 0x80000000\n\n/** \\brief Common script types */\nenum ScriptType{\n UNKNOWN_TYPE,\n /** \\brief a script directly in ScriptPubkey and not one of below */\n DIRECT_SCRIPT,\n /** \\brief default script for signing */\n P2PKH,\n P2SH,\n P2WPKH,\n P2WSH,\n P2SH_P2WPKH,\n P2SH_P2WSH,\n MULTISIG\n};\n\n/** \\brief SigHash types */\nenum SigHashType{\n SIGHASH_ALL = 1,\n SIGHASH_NONE = 2,\n SIGHASH_SINGLE = 3\n};\n\n/* forward declarations */\nclass Signature;\nclass SchnorrSignature;\nclass PublicKey;\nclass PrivateKey;\nclass HDPublicKey;\nclass HDPrivateKey;\nclass Script;\nclass TxIn;\n\nconst char * generateMnemonic(uint8_t numWords);\nconst char * generateMnemonic(uint8_t numWords, const uint8_t * entropy_data, size_t dataLen);\nconst char * generateMnemonic(const uint8_t * entropy_data, size_t dataLen);\n#if USE_ARDUINO_STRING\nconst char * generateMnemonic(uint8_t numWords, const String entropy_string);\nconst char * generateMnemonic(const String entropy_string);\nbool checkMnemonic(const String mnemonic);\n#elif USE_STD_STRING\nconst char * generateMnemonic(uint8_t numWords, const std::string entropy_string);\nconst char * generateMnemonic(const std::string entropy_string);\nbool checkMnemonic(const std::string mnemonic);\n#else\nconst char * generateMnemonic(uint8_t numWords, const char * entropy_string);\nconst char * generateMnemonic(const char * entropy_string);\nbool checkMnemonic(const char * mnemonic);\n#endif\n\nconst char * mnemonicFromEntropy(const uint8_t * entropy_data, size_t dataLen);\nsize_t mnemonicToEntropy(const char * mnemonic, size_t mnemonic_len, uint8_t * output, size_t outputLen);\n#if USE_ARDUINO_STRING\nsize_t mnemonicToEntropy(String mnemonic, uint8_t * output, size_t outputLen);\n#elif USE_STD_STRING\nsize_t mnemonicToEntropy(std::string mnemonic, uint8_t * output, size_t outputLen);\n#else\nsize_t mnemonicToEntropy(char * mnemonic, uint8_t * output, size_t outputLen);\n#endif\n\n/**\n * PublicKey class.\n *\n * Derived from ECPoint class, therefore you can add or substract them, multiply by ECScalar or PrivateKey.\n *\n * `compressed` flag determines what public key sec format to use by default:\n * - `compressed = false` will use 65-byte representation (`04`)\n * - `compressed = true` will use 33-byte representation (`03` if y is odd, `02` if y is even)\n */\nclass PublicKey : public ECPoint{\npublic:\n PublicKey(){ reset(); };\n PublicKey(const uint8_t pubkeyArr[64], bool use_compressed){ reset(); memcpy(point, pubkeyArr, 64); compressed=use_compressed; };\n PublicKey(const uint8_t * secArr){ reset(); parse(secArr, 33 + ((uint8_t)(secArr[0]==0x04))*32); };\n explicit PublicKey(const char * secHex){ reset(); from_str(secHex, strlen(secHex)); };\n PublicKey(const ECPoint p){ reset(); memcpy(point, p.point, 64); compressed=p.compressed; };\n /**\n * \\brief Fills `addr` with legacy Pay-To-Pubkey-Hash address (P2PKH, `1...` for mainnet)\n */\n int legacyAddress(char * addr, size_t len, const Network * network = &DEFAULT_NETWORK) const;\n /**\n * \\brief Fills `addr` with native segwit address (P2WPKH, `bc1...` for mainnet)\n */\n int segwitAddress(char * addr, size_t len, const Network * network = &DEFAULT_NETWORK) const;\n /**\n * \\brief Fills `addr` with nested segwit address (P2SH-P2WPKH, `3...` for mainnet)\n */\n int nestedSegwitAddress(char * addr, size_t len, const Network * network = &DEFAULT_NETWORK) const;\n /**\n * \\brief Alias for `legacyAddress`\n */\n int address(char * address, size_t len, const Network * network = &DEFAULT_NETWORK) const{ return legacyAddress(address, len, network); };\n#if USE_ARDUINO_STRING\n String legacyAddress(const Network * network = &DEFAULT_NETWORK) const;\n String segwitAddress(const Network * network = &DEFAULT_NETWORK) const;\n String nestedSegwitAddress(const Network * network = &DEFAULT_NETWORK) const;\n String address(const Network * network = &DEFAULT_NETWORK) const{ return legacyAddress(network); };\n#endif\n#if USE_STD_STRING\n std::string legacyAddress(const Network * network = &DEFAULT_NETWORK) const;\n std::string segwitAddress(const Network * network = &DEFAULT_NETWORK) const;\n std::string nestedSegwitAddress(const Network * network = &DEFAULT_NETWORK) const;\n std::string address(const Network * network = &DEFAULT_NETWORK) const{ return legacyAddress(network); };\n#endif\n /**\n * \\brief verifies the ECDSA signature of the hash of the message\n */\n bool verify(const Signature sig, const uint8_t hash[32]) const;\n /**\n * \\brief verifies the Schnorr signature of the hash of the message\n */\n bool schnorr_verify(const SchnorrSignature sig, const uint8_t hash[32]) const;\n /**\n * \\brief Returns a Script with the type: `P2PKH`, `P2WPKH` or `P2SH_P2WPKH`\n */\n Script script(ScriptType type = P2PKH) const;\n};\n\n/**\n * PrivateKey class.\n * Corresponding public key (point on curve) will be calculated in the constructor.\n * as point calculation is pretty slow, class initialization can take some time.\n */\nclass PrivateKey : public ECScalar{\nprotected:\n /** \\brief corresponding point on curve ( secret * G ) */\n PublicKey pubKey;\n virtual size_t to_str(char * buf, size_t len) const{ return wif( buf, len); };\n virtual size_t from_str(const char * buf, size_t len){ return fromWIF(buf, len); };\n virtual size_t from_stream(ParseStream *s);\npublic:\n PrivateKey();\n PrivateKey(const uint8_t secret_arr[32], bool use_compressed = true, const Network * net = &DEFAULT_NETWORK);\n PrivateKey(const ECScalar sc);\n#if USE_ARDUINO_STRING\n PrivateKey(const String wifString);\n#elif USE_STD_STRING\n PrivateKey(const std::string wifString);\n#else\n PrivateKey(const char * wifArr);\n#endif\n ~PrivateKey();\n /** \\brief Length of the key in WIF format (52). In reality not always 52... */\n virtual size_t stringLength() const{ return 52; };\n virtual size_t length() const{ return 32; };\n void setSecret(const uint8_t secret_arr[32]){ memcpy(num, secret_arr, 32); pubKey = *this * GeneratorPoint; };\n\n /** \\brief Pointer to the network to use. Mainnet or Testnet */\n const Network * network;\n\n /** \\brief Writes the private key in Wallet Import Format */\n int wif(char * wifArr, size_t len) const;\n#if USE_ARDUINO_STRING\n String wif() const;\n#endif\n#if USE_STD_STRING\n std::string wif() const;\n#endif\n /** \\brief Loads the private key from a string in Wallet Import Format */\n int fromWIF(const char * wifArr, size_t wifSize);\n int fromWIF(const char * wifArr);\n /** \\brief Returns the corresponding PublicKey = secret * GeneratorPoint */\n PublicKey publicKey() const;\n /** \\brief Signs the hash and returns the Signature */\n Signature sign(const uint8_t hash[32]) const; // pass 32-byte hash of the message here\n /** \\brief Signs the hash using Schnorr algorithm and returns the SchnorrSignature */\n SchnorrSignature schnorr_sign(const uint8_t hash[32]) const;\n\n /** \\brief Alias for .publicKey().address(network) */\n int address(char * address, size_t len) const;\n /** \\brief Alias for .publicKey().legacyAddress(network) */\n int legacyAddress(char * address, size_t len) const;\n /** \\brief Alias for .publicKey().segwitAddress(network) */\n int segwitAddress(char * address, size_t len) const;\n /** \\brief Alias for .publicKey().nestedSegwitAddress(network) */\n int nestedSegwitAddress(char * address, size_t len) const;\n#if USE_ARDUINO_STRING\n String address() const;\n String legacyAddress() const;\n String segwitAddress() const;\n String nestedSegwitAddress() const;\n#endif\n#if USE_STD_STRING\n std::string address() const;\n std::string legacyAddress() const;\n std::string segwitAddress() const;\n std::string nestedSegwitAddress() const;\n#endif\n// PrivateKey &operator=(const PrivateKey &other); // assignment\n /** \\brief Performs ECDH key agreement using public key of another party.\n * 32-byte shared secret will be written to `shared_secret` array.\n * Optional parameter hash (true by default) defines if you want sha256() or just .\n * Having hash=true is recommended unless you have a very good reason not to use it.\n */\n int ecdh(const PublicKey pub, uint8_t shared_secret[32], bool hash=true);\n};\n\n/**\n * \\brief HD Private Key class. Derived from PrivateKey class.\n * Works according to [bip32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki),\n * [bip39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) and \n * [slip32](https://github.com/satoshilabs/slips/blob/master/slip-0032.md).\n * You can generate the key from mnemonic or seed, derive children and hardened children.\n * xprv and xpub methods return strings according to slip32, xprv/xpub for bip44, yprv/ypub for bip49 and zprv/zpub for bip84\n */\nclass HDPrivateKey : public PrivateKey{\nprotected:\n void init();\n size_t to_bytes(uint8_t * arr, size_t len) const;\n virtual size_t to_str(char * buf, size_t len) const{ return xprv( buf, len); };\n virtual size_t from_str(const char * buf, size_t len);\n virtual size_t from_stream(ParseStream *s);\n virtual size_t to_stream(SerializeStream *s, size_t offset = 0) const;\n uint8_t prefix[4]; // used for parsing only\npublic:\n HDPrivateKey();\n HDPrivateKey(const uint8_t secret[32], const uint8_t chain_code[32],\n uint8_t key_depth = 0,\n const uint8_t parent_fingerprint_arr[4] = NULL,\n uint32_t childnumber = 0,\n const Network * network = &DEFAULT_NETWORK,\n ScriptType key_type = UNKNOWN_TYPE);\n HDPrivateKey(const char xprvArr[]);\n HDPrivateKey(const char * mnemonic, size_t mnemonicSize, const char * password, size_t passwordSize, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n#if USE_STD_STRING\n HDPrivateKey(std::string mnemonic, std::string password, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n#endif\n#if USE_ARDUINO_STRING\n HDPrivateKey(String mnemonic, String password, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n#endif\n/* HDPrivateKey(const HDPrivateKey &other):HDPrivateKey( // copy\n other.num, other.chainCode, other.depth,\n other.parentFingerprint, other.childNumber, other.network, other.type){};\n*/\n ~HDPrivateKey();\n virtual size_t length() const{ return 78; };\n /** \\brief Length of the key in base58 encoding (111). */\n virtual size_t stringLength() const{ return 111; };\n\n uint8_t chainCode[32];\n uint8_t depth;\n uint8_t parentFingerprint[4];\n uint32_t childNumber;\n ScriptType type;\n\n int fromSeed(const uint8_t * seed, size_t seedSize, const Network * network = &DEFAULT_NETWORK);\n // int fromSeed(const uint8_t seed[64], const Network * network = &DEFAULT_NETWORK);\n int fromMnemonic(const char * mnemonic, size_t mnemonicSize, const char * password, size_t passwordSize, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n int fromMnemonic(const char * mnemonic, const char * password, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL){\n return fromMnemonic(mnemonic, strlen(mnemonic), password, strlen(password), network, progress_callback);\n }\n#if USE_STD_STRING\n int fromMnemonic(std::string mnemonic, std::string password, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n#endif\n#if USE_ARDUINO_STRING\n int fromMnemonic(String mnemonic, String password, const Network * network = &DEFAULT_NETWORK, void (*progress_callback)(float) = NULL);\n#endif\n int xprv(char * arr, size_t len) const;\n int xpub(char * arr, size_t len) const;\n HDPublicKey xpub() const;\n int address(char * arr, size_t len) const;\n#if USE_ARDUINO_STRING\n String xprv() const;\n String address() const;\n#endif\n#if USE_STD_STRING\n std::string xprv() const;\n std::string address() const;\n#endif\n\n /** \\brief populates array with the fingerprint of the key */\n void fingerprint(uint8_t arr[4]) const;\n#if USE_STD_STRING\n std::string fingerprint() const;\n#endif\n#if USE_ARDUINO_STRING\n String fingerprint() const;\n#endif\n\n HDPrivateKey child(uint32_t index, bool hardened = false) const;\n HDPrivateKey hardenedChild(uint32_t index) const;\n /** \\brief derives a child according to derivation path. Use 0x80000000 + index for hardened index. */\n HDPrivateKey derive(uint32_t * index, size_t len) const;\n /** \\brief derives a child according to derivation path. For example \"m/84h/1h/0h/1/23/\" for the 23rd change address for testnet with P2WPKH type (bip84). */\n HDPrivateKey derive(const char * path) const;\n#if USE_ARDUINO_STRING\n HDPrivateKey derive(String path) const{ return derive(path.c_str()); };\n#endif\n // just to make sure it is compressed\n PublicKey publicKey() const{ PublicKey p = pubKey; p.compressed = true; return p; };\n// HDPrivateKey &operator=(const HDPrivateKey &other); // assignment\n};\n\n/**\n * \\brief HD Public Key class. Derived from PublicKey class.\n * Works according to [bip32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki),\n * [bip39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) and \n * [slip32](https://github.com/satoshilabs/slips/blob/master/slip-0032.md).\n * You can derive children\n * xpub method return strings according to slip32, xpub for bip44, ypub for bip49 and zpub for bip84\n */\nclass HDPublicKey : public PublicKey{\n size_t to_bytes(uint8_t * arr, size_t len) const;\n virtual size_t to_str(char * buf, size_t len) const{ return xpub( buf, len); };\n virtual size_t from_str(const char * buf, size_t len);\n virtual size_t from_stream(ParseStream *s);\n virtual size_t to_stream(SerializeStream *s, size_t offset = 0) const;\n uint8_t prefix[4]; // used for parsing only\npublic:\n HDPublicKey();\n HDPublicKey(const uint8_t point[64], const uint8_t chain_code[32],\n uint8_t key_depth = 0,\n const uint8_t parent_fingerprint_arr[4] = NULL,\n uint32_t childnumber = 0,\n const Network * net = &DEFAULT_NETWORK,\n ScriptType key_type = UNKNOWN_TYPE);\n HDPublicKey(const char * xpubArr);\n/* HDPublicKey(const HDPublicKey &other):HDPublicKey( // copy\n other.point, other.chainCode, other.depth,\n other.parentFingerprint, other.childNumber, other.network, other.type){};\n*/\n#if USE_ARDUINO_STRING\n HDPublicKey(String pub){ reset(); from_str(pub.c_str(), pub.length()); };\n#endif\n ~HDPublicKey();\n /** \\brief Length of the key (78). */\n virtual size_t length() const{ return 78; };\n /** \\brief Length of the key in base58 encoding (111). */\n virtual size_t stringLength() const{ return 111; };\n\n uint8_t chainCode[32];\n uint8_t depth;\n uint8_t parentFingerprint[4];\n uint32_t childNumber;\n ScriptType type;\n const Network * network;\n\n int xpub(char * arr, size_t len) const;\n int address(char * arr, size_t len) const;\n#if USE_ARDUINO_STRING\n String xpub() const;\n String address() const;\n#endif\n#if USE_STD_STRING\n std::string xpub() const;\n std::string address() const;\n#endif\n\n /** \\brief populates array with the fingerprint of the key */\n void fingerprint(uint8_t arr[4]) const;\n#if USE_STD_STRING\n std::string fingerprint() const;\n#endif\n#if USE_ARDUINO_STRING\n String fingerprint() const;\n#endif\n\n /** \\brief derive a child. \n * You can derive only normal children (not hardened) from the public key. \n */\n HDPublicKey child(uint32_t index) const;\n /** \\brief derives a child according to derivation path. */\n HDPublicKey derive(uint32_t * index, size_t len) const;\n /** \\brief derives a child according to derivation path. For example \"m/1/23/\" for the 23rd change address. */\n HDPublicKey derive(const char * path) const;\n#if USE_ARDUINO_STRING\n HDPublicKey derive(String path) const{ return derive(path.c_str()); };\n#endif\n// HDPublicKey &operator=(const HDPublicKey &other); // assignment\n};\n\n/**\n * \\brief Signature class.\n * Reference: https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki\n */\nclass Signature : public Streamable{\nprotected:\n uint8_t r[32];\n uint8_t s[32];\n virtual size_t from_stream(ParseStream *s);\n virtual size_t to_stream(SerializeStream *s, size_t offset = 0) const;\n size_t rlen() const;\n size_t slen() const;\n uint8_t tot[3]; // temporary thingy for parsing\npublic:\n Signature();\n Signature(const uint8_t r_arr[32], const uint8_t s_arr[32]);\n Signature(const uint8_t * der, size_t derLen);\n Signature(const uint8_t * der);\n explicit Signature(const char * der);\n virtual size_t length() const;\n\n uint8_t index; // used to derive pubkey from signature\n\n /** \\brief encodes signature in der format and writes it to array */\n size_t der(uint8_t * arr, size_t len) const;\n /** \\brief parses signature in der format */\n size_t fromDer(const uint8_t * arr, size_t len);\n /** \\brief populates array with */\n void bin(uint8_t * arr, size_t len) const;\n /** \\brief parses array as */\n void fromBin(const uint8_t * arr, size_t len);\n\n bool isValid() const{ uint8_t arr[32] = { 0 }; return !((memcmp(r, arr, 32) == 0) && (memcmp(s, arr, 32)==0)); };\n explicit operator bool() const{ return isValid(); };\n\n bool operator==(const Signature& other) const{ return (memcmp(r, other.r, 32) == 0) && (memcmp(s, other.s, 32) == 0); };\n bool operator!=(const Signature& other) const{ return !operator==(other); };\n};\n\n/**\n * \\brief SchnorrSignature class.\n * Reference: https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n */\nclass SchnorrSignature : public Streamable{\nprotected:\n uint8_t r[32];\n uint8_t s[32];\n virtual size_t from_stream(ParseStream *s);\n virtual size_t to_stream(SerializeStream *s, size_t offset = 0) const;\npublic:\n SchnorrSignature();\n SchnorrSignature(const uint8_t r_arr[32], const uint8_t s_arr[32]);\n SchnorrSignature(const uint8_t rs_arr[64]);\n explicit SchnorrSignature(const char * rs);\n virtual size_t length() const{ return 64; };\n\n bool isValid() const{ uint8_t arr[32] = { 0 }; return !((memcmp(r, arr, 32) == 0) && (memcmp(s, arr, 32)==0)); };\n explicit operator bool() const{ return isValid(); };\n\n bool operator==(const SchnorrSignature& other) const{ return (memcmp(r, other.r, 32) == 0) && (memcmp(s, other.s, 32) == 0); };\n bool operator!=(const SchnorrSignature& other) const{ return !operator==(other); };\n};\n\n/**\n * \\brief Script class. Parsing requires the length of the script in the beginning.\n */\nclass Script : public Streamable{\nprotected:\n virtual size_t from_stream(ParseStream *s);\n virtual size_t to_stream(SerializeStream *s, size_t offset = 0) const;\n uint8_t lenLen; // for parsing only, length of the varint\n void fromAddress(const char * address);\n void init();\npublic:\n uint8_t * scriptArray;\n size_t scriptLen;\n void clear();\n Script();\n Script(const uint8_t * buffer, size_t len);\n /** \\brief creates a script from address */\n Script(const char * address){ init(); fromAddress(address); };\n#if USE_ARDUINO_STRING\n /** \\brief creates a script from address */\n Script(const String address){ init(); fromAddress(address.c_str()); };\n#endif\n#if USE_STD_STRING\n /** \\brief creates a script from address */\n Script(const std::string address){ init(); fromAddress(address.c_str()); };\n#endif\n /** \\brief creates one of standart scripts (P2PKH, P2WPKH) */\n Script(const PublicKey pubkey, ScriptType type = P2PKH);\n /** \\brief creates one of standart scripts (P2SH, P2WSH) */\n Script(const Script &other, ScriptType type);\n Script(const Script &other); // copy\n ~Script(){ if(scriptArray){ free(scriptArray); } };\n\n /** \\brief tries to determine the script type */\n ScriptType type() const;\n /** \\brief returns address corresponding to the script */\n size_t address(char * buffer, size_t len, const Network * network = &DEFAULT_NETWORK) const;\n#if USE_ARDUINO_STRING\n String address(const Network * network = &DEFAULT_NETWORK) const;\n#endif\n#if USE_STD_STRING\n std::string address(const Network * network = &DEFAULT_NETWORK) const;\n#endif\n\n /** \\brief length of the script with varint */\n virtual size_t length() const; \n /** \\brief pushes a single byte (op_code) to the end */\n size_t push(uint8_t code);\n /** \\brief pushes bytes from data object to the end */\n size_t push(const uint8_t * data, size_t len);\n /** \\brief adds to the script */\n size_t push(const PublicKey pubkey);\n /** \\brief adds to the script */\n size_t push(const Signature sig, SigHashType sigType = SIGHASH_ALL);\n /** \\brief adds