@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.3

package/dependencies/src/xxhashjs-0.2.2/lib/xxhash64.js

@@ -0,0 +1,444 @@
+/**
+xxHash64 implementation in pure Javascript
+
+Copyright (C) 2016, Pierre Curto
+MIT license
+*/
+var UINT64 = require('../../cuint-0.2.2/index').UINT64
+
+/*
+ * Constants
+ */
+var PRIME64_1 = UINT64( '11400714785074694791' )
+var PRIME64_2 = UINT64( '14029467366897019727' )
+var PRIME64_3 = UINT64(  '1609587929392839161' )
+var PRIME64_4 = UINT64(  '9650029242287828579' )
+var PRIME64_5 = UINT64(  '2870177450012600261' )
+
+/**
+* Convert string to proper UTF-8 array
+* @param str Input string
+* @returns {Uint8Array} UTF8 array is returned as uint8 array
+*/
+function toUTF8Array (str) {
+	var utf8 = []
+	for (var i=0, n=str.length; i < n; i++) {
+		var charcode = str.charCodeAt(i)
+		if (charcode < 0x80) utf8.push(charcode)
+		else if (charcode < 0x800) {
+			utf8.push(0xc0 | (charcode >> 6),
+			0x80 | (charcode & 0x3f))
+		}
+		else if (charcode < 0xd800 || charcode >= 0xe000) {
+			utf8.push(0xe0 | (charcode >> 12),
+			0x80 | ((charcode>>6) & 0x3f),
+			0x80 | (charcode & 0x3f))
+		}
+		// surrogate pair
+		else {
+			i++;
+			// UTF-16 encodes 0x10000-0x10FFFF by
+			// subtracting 0x10000 and splitting the
+			// 20 bits of 0x0-0xFFFFF into two halves
+			charcode = 0x10000 + (((charcode & 0x3ff)<<10)
+			| (str.charCodeAt(i) & 0x3ff))
+			utf8.push(0xf0 | (charcode >>18),
+			0x80 | ((charcode>>12) & 0x3f),
+			0x80 | ((charcode>>6) & 0x3f),
+			0x80 | (charcode & 0x3f))
+		}
+	}
+
+	return new Uint8Array(utf8)
+}
+
+/**
+ * XXH64 object used as a constructor or a function
+ * @constructor
+ * or
+ * @param {Object|String} input data
+ * @param {Number|UINT64} seed
+ * @return ThisExpression
+ * or
+ * @return {UINT64} xxHash
+ */
+function XXH64 () {
+	if (arguments.length == 2)
+		return new XXH64( arguments[1] ).update( arguments[0] ).digest()
+
+	if (!(this instanceof XXH64))
+		return new XXH64( arguments[0] )
+
+	init.call(this, arguments[0])
+}
+
+/**
+ * Initialize the XXH64 instance with the given seed
+ * @method init
+ * @param {Number|Object} seed as a number or an unsigned 32 bits integer
+ * @return ThisExpression
+ */
+ function init (seed) {
+	this.seed = seed instanceof UINT64 ? seed.clone() : UINT64(seed)
+	this.v1 = this.seed.clone().add(PRIME64_1).add(PRIME64_2)
+	this.v2 = this.seed.clone().add(PRIME64_2)
+	this.v3 = this.seed.clone()
+	this.v4 = this.seed.clone().subtract(PRIME64_1)
+	this.total_len = 0
+	this.memsize = 0
+	this.memory = null
+
+	return this
+}
+XXH64.prototype.init = init
+
+/**
+ * Add data to be computed for the XXH64 hash
+ * @method update
+ * @param {String|Buffer|ArrayBuffer} input as a string or nodejs Buffer or ArrayBuffer
+ * @return ThisExpression
+ */
+XXH64.prototype.update = function (input) {
+	var isString = typeof input == 'string'
+	var isArrayBuffer
+
+	// Convert all strings to utf-8 first (issue #5)
+	if (isString) {
+		input = toUTF8Array(input)
+		isString = false
+		isArrayBuffer = true
+	}
+
+	if (typeof ArrayBuffer !== "undefined" && input instanceof ArrayBuffer)
+	{
+		isArrayBuffer = true
+		input = new Uint8Array(input);
+	}
+
+	var p = 0
+	var len = input.length
+	var bEnd = p + len
+
+	if (len == 0) return this
+
+	this.total_len += len
+
+	if (this.memsize == 0)
+	{
+		if (isString) {
+			this.memory = ''
+		} else if (isArrayBuffer) {
+			this.memory = new Uint8Array(32)
+		} else {
+			this.memory = new Buffer(32)
+		}
+	}
+
+	if (this.memsize + len < 32)   // fill in tmp buffer
+	{
+		// XXH64_memcpy(this.memory + this.memsize, input, len)
+		if (isString) {
+			this.memory += input
+		} else if (isArrayBuffer) {
+			this.memory.set( input.subarray(0, len), this.memsize )
+		} else {
+			input.copy( this.memory, this.memsize, 0, len )
+		}
+
+		this.memsize += len
+		return this
+	}
+
+	if (this.memsize > 0)   // some data left from previous update
+	{
+		// XXH64_memcpy(this.memory + this.memsize, input, 16-this.memsize);
+		if (isString) {
+			this.memory += input.slice(0, 32 - this.memsize)
+		} else if (isArrayBuffer) {
+			this.memory.set( input.subarray(0, 32 - this.memsize), this.memsize )
+		} else {
+			input.copy( this.memory, this.memsize, 0, 32 - this.memsize )
+		}
+
+		var p64 = 0
+		if (isString) {
+			var other
+			other = UINT64(
+					(this.memory.charCodeAt(p64+1) << 8) | this.memory.charCodeAt(p64)
+				,	(this.memory.charCodeAt(p64+3) << 8) | this.memory.charCodeAt(p64+2)
+				,	(this.memory.charCodeAt(p64+5) << 8) | this.memory.charCodeAt(p64+4)
+				,	(this.memory.charCodeAt(p64+7) << 8) | this.memory.charCodeAt(p64+6)
+				)
+			this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory.charCodeAt(p64+1) << 8) | this.memory.charCodeAt(p64)
+				,	(this.memory.charCodeAt(p64+3) << 8) | this.memory.charCodeAt(p64+2)
+				,	(this.memory.charCodeAt(p64+5) << 8) | this.memory.charCodeAt(p64+4)
+				,	(this.memory.charCodeAt(p64+7) << 8) | this.memory.charCodeAt(p64+6)
+				)
+			this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory.charCodeAt(p64+1) << 8) | this.memory.charCodeAt(p64)
+				,	(this.memory.charCodeAt(p64+3) << 8) | this.memory.charCodeAt(p64+2)
+				,	(this.memory.charCodeAt(p64+5) << 8) | this.memory.charCodeAt(p64+4)
+				,	(this.memory.charCodeAt(p64+7) << 8) | this.memory.charCodeAt(p64+6)
+				)
+			this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory.charCodeAt(p64+1) << 8) | this.memory.charCodeAt(p64)
+				,	(this.memory.charCodeAt(p64+3) << 8) | this.memory.charCodeAt(p64+2)
+				,	(this.memory.charCodeAt(p64+5) << 8) | this.memory.charCodeAt(p64+4)
+				,	(this.memory.charCodeAt(p64+7) << 8) | this.memory.charCodeAt(p64+6)
+				)
+			this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+		} else {
+			var other
+			other = UINT64(
+					(this.memory[p64+1] << 8) | this.memory[p64]
+				,	(this.memory[p64+3] << 8) | this.memory[p64+2]
+				,	(this.memory[p64+5] << 8) | this.memory[p64+4]
+				,	(this.memory[p64+7] << 8) | this.memory[p64+6]
+				)
+			this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory[p64+1] << 8) | this.memory[p64]
+				,	(this.memory[p64+3] << 8) | this.memory[p64+2]
+				,	(this.memory[p64+5] << 8) | this.memory[p64+4]
+				,	(this.memory[p64+7] << 8) | this.memory[p64+6]
+				)
+			this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory[p64+1] << 8) | this.memory[p64]
+				,	(this.memory[p64+3] << 8) | this.memory[p64+2]
+				,	(this.memory[p64+5] << 8) | this.memory[p64+4]
+				,	(this.memory[p64+7] << 8) | this.memory[p64+6]
+				)
+			this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			p64 += 8
+			other = UINT64(
+					(this.memory[p64+1] << 8) | this.memory[p64]
+				,	(this.memory[p64+3] << 8) | this.memory[p64+2]
+				,	(this.memory[p64+5] << 8) | this.memory[p64+4]
+				,	(this.memory[p64+7] << 8) | this.memory[p64+6]
+				)
+			this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+		}
+
+		p += 32 - this.memsize
+		this.memsize = 0
+		if (isString) this.memory = ''
+	}
+
+	if (p <= bEnd - 32)
+	{
+		var limit = bEnd - 32
+
+		do
+		{
+			if (isString) {
+				var other
+				other = UINT64(
+						(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+					,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+					,	(input.charCodeAt(p+5) << 8) | input.charCodeAt(p+4)
+					,	(input.charCodeAt(p+7) << 8) | input.charCodeAt(p+6)
+					)
+				this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+					,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+					,	(input.charCodeAt(p+5) << 8) | input.charCodeAt(p+4)
+					,	(input.charCodeAt(p+7) << 8) | input.charCodeAt(p+6)
+					)
+				this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+					,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+					,	(input.charCodeAt(p+5) << 8) | input.charCodeAt(p+4)
+					,	(input.charCodeAt(p+7) << 8) | input.charCodeAt(p+6)
+					)
+				this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+					,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+					,	(input.charCodeAt(p+5) << 8) | input.charCodeAt(p+4)
+					,	(input.charCodeAt(p+7) << 8) | input.charCodeAt(p+6)
+					)
+				this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			} else {
+				var other
+				other = UINT64(
+						(input[p+1] << 8) | input[p]
+					,	(input[p+3] << 8) | input[p+2]
+					,	(input[p+5] << 8) | input[p+4]
+					,	(input[p+7] << 8) | input[p+6]
+					)
+				this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input[p+1] << 8) | input[p]
+					,	(input[p+3] << 8) | input[p+2]
+					,	(input[p+5] << 8) | input[p+4]
+					,	(input[p+7] << 8) | input[p+6]
+					)
+				this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input[p+1] << 8) | input[p]
+					,	(input[p+3] << 8) | input[p+2]
+					,	(input[p+5] << 8) | input[p+4]
+					,	(input[p+7] << 8) | input[p+6]
+					)
+				this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+				p += 8
+				other = UINT64(
+						(input[p+1] << 8) | input[p]
+					,	(input[p+3] << 8) | input[p+2]
+					,	(input[p+5] << 8) | input[p+4]
+					,	(input[p+7] << 8) | input[p+6]
+					)
+				this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
+			}
+			p += 8
+		} while (p <= limit)
+	}
+
+	if (p < bEnd)
+	{
+		// XXH64_memcpy(this.memory, p, bEnd-p);
+		if (isString) {
+			this.memory += input.slice(p)
+		} else if (isArrayBuffer) {
+			this.memory.set( input.subarray(p, bEnd), this.memsize )
+		} else {
+			input.copy( this.memory, this.memsize, p, bEnd )
+		}
+
+		this.memsize = bEnd - p
+	}
+
+	return this
+}
+
+/**
+ * Finalize the XXH64 computation. The XXH64 instance is ready for reuse for the given seed
+ * @method digest
+ * @return {UINT64} xxHash
+ */
+XXH64.prototype.digest = function () {
+	var input = this.memory
+	var isString = typeof input == 'string'
+	var p = 0
+	var bEnd = this.memsize
+	var h64, h
+	var u = new UINT64
+
+	if (this.total_len >= 32)
+	{
+		h64 = this.v1.clone().rotl(1)
+		h64.add( this.v2.clone().rotl(7) )
+		h64.add( this.v3.clone().rotl(12) )
+		h64.add( this.v4.clone().rotl(18) )
+
+		h64.xor( this.v1.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
+		h64.multiply(PRIME64_1).add(PRIME64_4)
+
+		h64.xor( this.v2.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
+		h64.multiply(PRIME64_1).add(PRIME64_4)
+
+		h64.xor( this.v3.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
+		h64.multiply(PRIME64_1).add(PRIME64_4)
+
+		h64.xor( this.v4.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
+		h64.multiply(PRIME64_1).add(PRIME64_4)
+	}
+	else
+	{
+		h64  = this.seed.clone().add( PRIME64_5 )
+	}
+
+	h64.add( u.fromNumber(this.total_len) )
+
+	while (p <= bEnd - 8)
+	{
+		if (isString) {
+			u.fromBits(
+				(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+			,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+			,	(input.charCodeAt(p+5) << 8) | input.charCodeAt(p+4)
+			,	(input.charCodeAt(p+7) << 8) | input.charCodeAt(p+6)
+			)
+		} else {
+			u.fromBits(
+				(input[p+1] << 8) | input[p]
+			,	(input[p+3] << 8) | input[p+2]
+			,	(input[p+5] << 8) | input[p+4]
+			,	(input[p+7] << 8) | input[p+6]
+			)
+		}
+		u.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1)
+		h64
+			.xor(u)
+			.rotl(27)
+			.multiply( PRIME64_1 )
+			.add( PRIME64_4 )
+		p += 8
+	}
+
+	if (p + 4 <= bEnd) {
+		if (isString) {
+			u.fromBits(
+				(input.charCodeAt(p+1) << 8) | input.charCodeAt(p)
+			,	(input.charCodeAt(p+3) << 8) | input.charCodeAt(p+2)
+			,	0
+			,	0
+			)
+		} else {
+			u.fromBits(
+				(input[p+1] << 8) | input[p]
+			,	(input[p+3] << 8) | input[p+2]
+			,	0
+			,	0
+			)
+		}
+		h64
+			.xor( u.multiply(PRIME64_1) )
+			.rotl(23)
+			.multiply( PRIME64_2 )
+			.add( PRIME64_3 )
+		p += 4
+	}
+
+	while (p < bEnd)
+	{
+		u.fromBits( isString ? input.charCodeAt(p++) : input[p++], 0, 0, 0 )
+		h64
+			.xor( u.multiply(PRIME64_5) )
+			.rotl(11)
+			.multiply(PRIME64_1)
+	}
+
+	h = h64.clone().shiftRight(33)
+	h64.xor(h).multiply(PRIME64_2)
+
+	h = h64.clone().shiftRight(29)
+	h64.xor(h).multiply(PRIME64_3)
+
+	h = h64.clone().shiftRight(32)
+	h64.xor(h)
+
+	// Reset the state
+	this.init( this.seed )
+
+	return h64
+}
+
+module.exports = XXH64

package/errors/coinlib-error.d.ts

@@ -0,0 +1,30 @@
+export declare enum Domain {
+    SERIALIZER = "SERIALIZER",
+    SUBPROTOCOLS = "SUBPROTOCOLS",
+    WALLET = "WALLET",
+    BITCOIN = "BITCOIN",
+    ETHEREUM = "ETHEREUM",
+    ERC20 = "ERC20",
+    COSMOS = "COSMOS",
+    SUBSTRATE = "SUBSTRATE",
+    AETERNITY = "AETERNITY",
+    GROESTLCOIN = "GROESTLCOIN",
+    TEZOS = "TEZOS",
+    TEZOSFA = "TEZOSFA",
+    UTILS = "UTILS",
+    ACTIONS = "ACTIONS",
+    ICP = "ICP"
+}
+export declare class CoinlibError extends Error {
+    domain: Domain;
+    code: string;
+    description?: string | undefined;
+    constructor(domain: Domain, code: string, description?: string | undefined);
+}
+export declare class CoinlibAssertionError extends Error {
+    domain: Domain;
+    code: string;
+    expected: string;
+    actual: any;
+    constructor(domain: Domain, code: string, expected: string, actual: any);
+}

package/errors/coinlib-error.js

@@ -0,0 +1,62 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinlibAssertionError = exports.CoinlibError = exports.Domain = void 0;
+var Domain;
+(function (Domain) {
+    Domain["SERIALIZER"] = "SERIALIZER";
+    Domain["SUBPROTOCOLS"] = "SUBPROTOCOLS";
+    Domain["WALLET"] = "WALLET";
+    Domain["BITCOIN"] = "BITCOIN";
+    Domain["ETHEREUM"] = "ETHEREUM";
+    Domain["ERC20"] = "ERC20";
+    Domain["COSMOS"] = "COSMOS";
+    Domain["SUBSTRATE"] = "SUBSTRATE";
+    Domain["AETERNITY"] = "AETERNITY";
+    Domain["GROESTLCOIN"] = "GROESTLCOIN";
+    Domain["TEZOS"] = "TEZOS";
+    Domain["TEZOSFA"] = "TEZOSFA";
+    Domain["UTILS"] = "UTILS";
+    Domain["ACTIONS"] = "ACTIONS";
+    Domain["ICP"] = "ICP";
+})(Domain = exports.Domain || (exports.Domain = {}));
+var CoinlibError = /** @class */ (function (_super) {
+    __extends(CoinlibError, _super);
+    function CoinlibError(domain, code, description) {
+        var _this = _super.call(this, description ? "".concat(domain, "(").concat(code, "): ").concat(description) : "".concat(domain, "(").concat(code, ")")) || this;
+        _this.domain = domain;
+        _this.code = code;
+        _this.description = description;
+        return _this;
+    }
+    return CoinlibError;
+}(Error));
+exports.CoinlibError = CoinlibError;
+var CoinlibAssertionError = /** @class */ (function (_super) {
+    __extends(CoinlibAssertionError, _super);
+    function CoinlibAssertionError(domain, code, expected, actual) {
+        var _this = _super.call(this, "".concat(domain, "(").concat(code, "): expected ").concat(expected, " but got ").concat(actual, ".")) || this;
+        _this.domain = domain;
+        _this.code = code;
+        _this.expected = expected;
+        _this.actual = actual;
+        return _this;
+    }
+    return CoinlibAssertionError;
+}(Error));
+exports.CoinlibAssertionError = CoinlibAssertionError;
+//# sourceMappingURL=coinlib-error.js.map

package/errors/coinlib-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coinlib-error.js","sourceRoot":"","sources":["../../src/errors/coinlib-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,IAAY,MAgBX;AAhBD,WAAY,MAAM;IAChB,mCAAyB,CAAA;IACzB,uCAA6B,CAAA;IAC7B,2BAAiB,CAAA;IACjB,6BAAmB,CAAA;IACnB,+BAAqB,CAAA;IACrB,yBAAe,CAAA;IACf,2BAAiB,CAAA;IACjB,iCAAuB,CAAA;IACvB,iCAAuB,CAAA;IACvB,qCAA2B,CAAA;IAC3B,yBAAe,CAAA;IACf,6BAAmB,CAAA;IACnB,yBAAe,CAAA;IACf,6BAAmB,CAAA;IACnB,qBAAW,CAAA;AACb,CAAC,EAhBW,MAAM,GAAN,cAAM,KAAN,cAAM,QAgBjB;AAED;IAAkC,gCAAK;IACrC,sBAAmB,MAAc,EAAS,IAAY,EAAS,WAAoB;QAAnF,YACE,kBAAM,WAAW,CAAC,CAAC,CAAC,UAAG,MAAM,cAAI,IAAI,gBAAM,WAAW,CAAE,CAAC,CAAC,CAAC,UAAG,MAAM,cAAI,IAAI,MAAG,CAAC,SACjF;QAFkB,YAAM,GAAN,MAAM,CAAQ;QAAS,UAAI,GAAJ,IAAI,CAAQ;QAAS,iBAAW,GAAX,WAAW,CAAS;;IAEnF,CAAC;IACH,mBAAC;AAAD,CAAC,AAJD,CAAkC,KAAK,GAItC;AAJY,oCAAY;AAMzB;IAA2C,yCAAK;IAC9C,+BAAmB,MAAc,EAAS,IAAY,EAAS,QAAgB,EAAS,MAAM;QAA9F,YACE,kBAAM,UAAG,MAAM,cAAI,IAAI,yBAAe,QAAQ,sBAAY,MAAM,MAAG,CAAC,SACrE;QAFkB,YAAM,GAAN,MAAM,CAAQ;QAAS,UAAI,GAAJ,IAAI,CAAQ;QAAS,cAAQ,GAAR,QAAQ,CAAQ;QAAS,YAAM,GAAN,MAAM,CAAA;;IAE9F,CAAC;IACH,4BAAC;AAAD,CAAC,AAJD,CAA2C,KAAK,GAI/C;AAJY,sDAAqB"}

package/errors/index.d.ts

@@ -0,0 +1,156 @@
+import { AxiosError } from '../dependencies/src/axios-0.19.0';
+import { CoinlibError, Domain } from './coinlib-error';
+export declare enum SerializerErrorType {
+    SERIALIZER_VERSION_MISMATCH = "SERIALIZER_VERSION_MISMATCH",
+    PROTOCOL_NOT_SUPPORTED = "PROTOCOL_NOT_SUPPORTED",
+    PROTOCOL_VERSION_MISMATCH = "PROTOCOL_VERSION_MISMATCH",
+    TYPE_NOT_SUPPORTED = "TYPE_NOT_SUPPORTED",
+    INVALID_SCHEMA = "INVALID_SCHEMA",
+    INVALID_SCHEMA_TYPE = "INVALID_SCHEMA_TYPE",
+    INVALID_PAYLOAD = "INVALID_PAYLOAD",
+    INVALID_HEX_STRING = "INVALID_HEX_STRING",
+    INVALID_STRING = "INVALID_STRING",
+    SCHEMA_ALREADY_EXISTS = "SCHEMA_ALREADY_EXISTS",
+    SCHEMA_DOES_NOT_EXISTS = "SCHEMA_DOES_NOT_EXISTS",
+    UNEXPECTED_PAYLOAD = "UNEXPECTED_PAYLOAD",
+    PAYLOAD_TYPE_UNKNOWN = "PAYLOAD_TYPE_UNKNOWN",
+    PAYLOAD_TYPE_MISMATCH = "PAYLOAD_TYPE_MISMATCH",
+    PAYLOAD_TYPE_NOT_SUPPORTED = "PAYLOAD_TYPE_NOT_SUPPORTED",
+    PROPERTY_IS_EMPTY = "PROPERTY_IS_EMPTY",
+    PROPERTY_INVALID = "PROPERTY_INVALID"
+}
+export declare enum ProtocolErrorType {
+    NETWORK = "NETWORK",
+    CONDITION_VIOLATION = "CONDITION_VIOLATION",
+    UNSUPPORTED = "UNSUPPORTED",
+    NOT_FOUND = "NOT_FOUND",
+    BALANCE = "BALANCE",
+    PROPERTY_UNDEFINED = "PROPERTY_UNDEFINED",
+    OPERATION_FAILED = "OPERATION_FAILED",
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
+    INVALID_VALUE = "INVALID_VALUE",
+    TRANSACTION_FAILED = "TRANSACTION_FAILED"
+}
+/**
+ * Gets thrown if an error occurs when making a network request
+ * Partial<AxiosError> is either an AxiosError or an AxiosResponse,
+ * as we sometimes want to throw an Error even though we get a 200 response
+ * from the API (as in case of internal operation errors for Tezos).
+ */
+export declare class NetworkError extends CoinlibError {
+    data: string;
+    status: number | undefined;
+    url: string | undefined;
+    method: string | undefined;
+    requestBody?: unknown;
+    constructor(domain: Domain, error: Partial<AxiosError>, description?: string);
+}
+/**
+ * Gets thrown if a value ist expected to fulfill a certain condition such as having a certain length, but the condition is not satisfied
+ */
+export declare class ConditionViolationError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if a variable assumes a value for which an operation is not supported
+ */
+export declare class UnsupportedError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if a variable is unexpectedly undefined
+ */
+export declare class NotFoundError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if an account has an insufficient balance to perform a certain kind of operation
+ */
+export declare class BalanceError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+export declare class TransactionError extends CoinlibError {
+    data?: unknown;
+    constructor(domain: Domain, description?: string, data?: unknown);
+}
+/**
+ * Gets thrown if an accessed object property is undefined
+ */
+export declare class PropertyUndefinedError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if an internal method fails
+ */
+export declare class OperationFailedError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if a method is executed which is not implemented
+ */
+export declare class NotImplementedError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+/**
+ * Gets thrown if a variable has a value which cannot be handled
+ */
+export declare class InvalidValueError extends CoinlibError {
+    constructor(domain: Domain, description?: string);
+}
+export declare class SerializerError extends CoinlibError {
+    constructor(code: string, description?: string);
+}
+/**
+ * Gets thrown if the serializer version does not match
+ */
+export declare class SerializerVersionMismatch extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the serializer cannot handle the specified coin/protocol
+ */
+export declare class ProtocolNotSupported extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the serializer CAN handle the specified coin/protocol, but not in this version
+ */
+export declare class ProtocolVersionMismatch extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the specified Type is not supported
+ */
+export declare class TypeNotSupported extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the schema in the serializer is invalid
+ */
+export declare class InvalidSchema extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the 2 types provided are not compatible
+ */
+export declare class InvalidSchemaType extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the payload that is being decoded does not match the schema
+ */
+export declare class InvalidPayloadError extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the string is not a valid hex string
+ */
+export declare class InvalidHexString extends SerializerError {
+    constructor(description?: string);
+}
+/**
+ * Gets thrown if the string starts with "0x". This causes problems with RLP
+ */
+export declare class InvalidString extends SerializerError {
+    constructor(description?: string);
+}