nel-neo-thinsdk
Version:
1,203 lines • 264 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var Neo;
(function (Neo) {
var UintVariable = (function () {
function UintVariable(bits) {
if (typeof bits === "number") {
if (bits <= 0 || bits % 32 != 0)
throw new RangeError();
this._bits = new Uint32Array(bits / 32);
}
else if (bits instanceof Uint8Array) {
if (bits.length == 0 || bits.length % 4 != 0)
throw new RangeError();
if (bits.byteOffset % 4 == 0) {
this._bits = new Uint32Array(bits.buffer, bits.byteOffset, bits.length / 4);
}
else {
var bits_new = new Uint8Array(bits);
this._bits = new Uint32Array(bits_new.buffer);
}
}
else if (bits instanceof Uint32Array) {
this._bits = bits;
}
else if (bits instanceof Array) {
if (bits.length == 0)
throw new RangeError();
this._bits = new Uint32Array(bits);
}
}
Object.defineProperty(UintVariable.prototype, "bits", {
get: function () {
return this._bits;
},
enumerable: true,
configurable: true
});
UintVariable.prototype.compareTo = function (other) {
var max = Math.max(this._bits.length, other._bits.length);
for (var i = max - 1; i >= 0; i--)
if ((this._bits[i] || 0) > (other._bits[i] || 0))
return 1;
else if ((this._bits[i] || 0) < (other._bits[i] || 0))
return -1;
return 0;
};
UintVariable.prototype.equals = function (other) {
var max = Math.max(this._bits.length, other._bits.length);
for (var i = 0; i < max; i++)
if ((this._bits[i] || 0) != (other._bits[i] || 0))
return false;
return true;
};
UintVariable.prototype.toString = function () {
var s = "";
for (var i = this._bits.length * 32 - 4; i >= 0; i -= 4)
s += ((this._bits[i >>> 5] >>> (i % 32)) & 0xf).toString(16);
return s;
};
return UintVariable;
}());
Neo.UintVariable = UintVariable;
})(Neo || (Neo = {}));
var Neo;
(function (Neo) {
var _max, _min;
var Uint64 = (function (_super) {
__extends(Uint64, _super);
function Uint64(low, high) {
if (low === void 0) { low = 0; }
if (high === void 0) { high = 0; }
return _super.call(this, [low, high]) || this;
}
Object.defineProperty(Uint64, "MaxValue", {
get: function () { return _max || (_max = new Uint64(0xffffffff, 0xffffffff)); },
enumerable: true,
configurable: true
});
Object.defineProperty(Uint64, "MinValue", {
get: function () { return _min || (_min = new Uint64()); },
enumerable: true,
configurable: true
});
Object.defineProperty(Uint64, "Zero", {
get: function () { return Uint64.MinValue; },
enumerable: true,
configurable: true
});
Uint64.prototype.add = function (other) {
var low = this._bits[0] + other._bits[0];
var high = this._bits[1] + other._bits[1] + (low > 0xffffffff ? 1 : 0);
return new Uint64(low, high);
};
Uint64.prototype.and = function (other) {
if (typeof other === "number") {
return this.and(new Uint64(other));
}
else {
var bits = new Uint32Array(this._bits.length);
for (var i = 0; i < bits.length; i++)
bits[i] = this._bits[i] & other._bits[i];
return new Uint64(bits[0], bits[1]);
}
};
Uint64.prototype.leftShift = function (shift) {
if (shift == 0)
return this;
var shift_units = shift >>> 5;
shift = shift & 0x1f;
var bits = new Uint32Array(this._bits.length);
for (var i = shift_units; i < bits.length; i++)
if (shift == 0)
bits[i] = this._bits[i - shift_units];
else
bits[i] = this._bits[i - shift_units] << shift | this._bits[i - shift_units - 1] >>> (32 - shift);
return new Uint64(bits[0], bits[1]);
};
Uint64.prototype.not = function () {
var bits = new Uint32Array(this._bits.length);
for (var i = 0; i < bits.length; i++)
bits[i] = ~this._bits[i];
return new Uint64(bits[0], bits[1]);
};
Uint64.prototype.or = function (other) {
if (typeof other === "number") {
return this.or(new Uint64(other));
}
else {
var bits = new Uint32Array(this._bits.length);
for (var i = 0; i < bits.length; i++)
bits[i] = this._bits[i] | other._bits[i];
return new Uint64(bits[0], bits[1]);
}
};
Uint64.parse = function (str) {
var bi = Neo.BigInteger.parse(str);
if (bi.bitLength() > 64)
throw new RangeError();
var array = new Uint32Array(bi.toUint8Array(true, 8).buffer);
return new Uint64(array[0], array[1]);
};
Uint64.prototype.rightShift = function (shift) {
if (shift == 0)
return this;
var shift_units = shift >>> 5;
shift = shift & 0x1f;
var bits = new Uint32Array(this._bits.length);
for (var i = 0; i < bits.length - shift_units; i++)
if (shift == 0)
bits[i] = this._bits[i + shift_units];
else
bits[i] = this._bits[i + shift_units] >>> shift | this._bits[i + shift_units + 1] << (32 - shift);
return new Uint64(bits[0], bits[1]);
};
Uint64.prototype.subtract = function (other) {
var low = this._bits[0] - other._bits[0];
var high = this._bits[1] - other._bits[1] - (this._bits[0] < other._bits[0] ? 1 : 0);
return new Uint64(low, high);
};
Uint64.prototype.toInt32 = function () {
return this._bits[0] | 0;
};
Uint64.prototype.toNumber = function () {
return this._bits[0] + this._bits[1] * Math.pow(2, 32);
};
Uint64.prototype.toString = function () {
return (new Neo.BigInteger(this._bits.buffer)).toString();
};
Uint64.prototype.toUint32 = function () {
return this._bits[0];
};
Uint64.prototype.xor = function (other) {
if (typeof other === "number") {
return this.xor(new Uint64(other));
}
else {
var bits = new Uint32Array(this._bits.length);
for (var i = 0; i < bits.length; i++)
bits[i] = this._bits[i] ^ other._bits[i];
return new Uint64(bits[0], bits[1]);
}
};
return Uint64;
}(Neo.UintVariable));
Neo.Uint64 = Uint64;
})(Neo || (Neo = {}));
var Neo;
(function (Neo) {
var DB = 26;
var DM = (1 << DB) - 1;
var DV = DM + 1;
var _minusone, _one, _zero;
var BigInteger = (function () {
function BigInteger(value) {
this._sign = 0;
this._bits = new Array();
if (typeof value === "number") {
if (!isFinite(value) || isNaN(value))
throw new RangeError();
var parts = BigInteger.getDoubleParts(value);
if (parts.man.equals(Neo.Uint64.Zero) || parts.exp <= -64)
return;
if (parts.exp <= 0) {
this.fromUint64(parts.man.rightShift(-parts.exp), parts.sign);
}
else if (parts.exp <= 11) {
this.fromUint64(parts.man.leftShift(parts.exp), parts.sign);
}
else {
parts.man = parts.man.leftShift(11);
parts.exp -= 11;
var units = Math.ceil((parts.exp + 64) / DB);
var cu = Math.ceil(parts.exp / DB);
var cbit = cu * DB - parts.exp;
for (var i = cu; i < units; i++)
this._bits[i] = parts.man.rightShift(cbit + (i - cu) * DB).toUint32() & DM;
if (cbit > 0)
this._bits[cu - 1] = (parts.man.toUint32() << (DB - cbit)) & DM;
this._sign = parts.sign;
this.clamp();
}
}
else if (typeof value === "string") {
this.fromString(value);
}
else if (value instanceof Uint8Array) {
this.fromUint8Array(value);
}
else if (value instanceof ArrayBuffer) {
this.fromUint8Array(new Uint8Array(value));
}
}
Object.defineProperty(BigInteger, "MinusOne", {
get: function () { return _minusone || (_minusone = new BigInteger(-1)); },
enumerable: true,
configurable: true
});
Object.defineProperty(BigInteger, "One", {
get: function () { return _one || (_one = new BigInteger(1)); },
enumerable: true,
configurable: true
});
Object.defineProperty(BigInteger, "Zero", {
get: function () { return _zero || (_zero = new BigInteger(0)); },
enumerable: true,
configurable: true
});
BigInteger.add = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_x._sign == 0)
return bi_y;
if (bi_y._sign == 0)
return bi_x;
if ((bi_x._sign > 0) != (bi_y._sign > 0))
return BigInteger.subtract(bi_x, bi_y.negate());
var bits_r = new Array();
BigInteger.addTo(bi_x._bits, bi_y._bits, bits_r);
return BigInteger.create(bi_x._sign, bits_r);
};
BigInteger.prototype.add = function (other) {
return BigInteger.add(this, other);
};
BigInteger.addTo = function (x, y, r) {
if (x.length < y.length) {
var t = x;
x = y;
y = t;
}
var c = 0, i = 0;
while (i < y.length) {
c += x[i] + y[i];
r[i++] = c & DM;
c >>>= DB;
}
while (i < x.length) {
c += x[i];
r[i++] = c & DM;
c >>>= DB;
}
if (c > 0)
r[i] = c;
};
BigInteger.prototype.bitLength = function () {
var l = this._bits.length;
if (l == 0)
return 0;
return --l * DB + BigInteger.bitLengthInternal(this._bits[l]);
};
BigInteger.bitLengthInternal = function (w) {
return (w < 1 << 15 ? (w < 1 << 7
? (w < 1 << 3 ? (w < 1 << 1
? (w < 1 << 0 ? (w < 0 ? 32 : 0) : 1)
: (w < 1 << 2 ? 2 : 3)) : (w < 1 << 5
? (w < 1 << 4 ? 4 : 5)
: (w < 1 << 6 ? 6 : 7)))
: (w < 1 << 11
? (w < 1 << 9 ? (w < 1 << 8 ? 8 : 9) : (w < 1 << 10 ? 10 : 11))
: (w < 1 << 13 ? (w < 1 << 12 ? 12 : 13) : (w < 1 << 14 ? 14 : 15)))) : (w < 1 << 23 ? (w < 1 << 19
? (w < 1 << 17 ? (w < 1 << 16 ? 16 : 17) : (w < 1 << 18 ? 18 : 19))
: (w < 1 << 21 ? (w < 1 << 20 ? 20 : 21) : (w < 1 << 22 ? 22 : 23))) : (w < 1 << 27
? (w < 1 << 25 ? (w < 1 << 24 ? 24 : 25) : (w < 1 << 26 ? 26 : 27))
: (w < 1 << 29 ? (w < 1 << 28 ? 28 : 29) : (w < 1 << 30 ? 30 : 31)))));
};
BigInteger.prototype.clamp = function () {
var l = this._bits.length;
while (l > 0 && (this._bits[--l] | 0) == 0)
this._bits.pop();
while (l > 0)
this._bits[--l] |= 0;
if (this._bits.length == 0)
this._sign = 0;
};
BigInteger.compare = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_x._sign >= 0 && bi_y._sign < 0)
return +1;
if (bi_x._sign < 0 && bi_y._sign >= 0)
return -1;
var c = BigInteger.compareAbs(bi_x, bi_y);
return bi_x._sign < 0 ? -c : c;
};
BigInteger.compareAbs = function (x, y) {
if (x._bits.length > y._bits.length)
return +1;
if (x._bits.length < y._bits.length)
return -1;
for (var i = x._bits.length - 1; i >= 0; i--)
if (x._bits[i] > y._bits[i])
return +1;
else if (x._bits[i] < y._bits[i])
return -1;
return 0;
};
BigInteger.prototype.compareTo = function (other) {
return BigInteger.compare(this, other);
};
BigInteger.create = function (sign, bits, clamp) {
if (clamp === void 0) { clamp = false; }
var bi = Object.create(BigInteger.prototype);
bi._sign = sign;
bi._bits = bits;
if (clamp)
bi.clamp();
return bi;
};
BigInteger.divide = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
return BigInteger.divRem(bi_x, bi_y).result;
};
BigInteger.prototype.divide = function (other) {
return BigInteger.divide(this, other);
};
BigInteger.divRem = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_y._sign == 0)
throw new RangeError();
if (bi_x._sign == 0)
return { result: BigInteger.Zero, remainder: BigInteger.Zero };
if (bi_y._sign == 1 && bi_y._bits == null)
return { result: bi_x, remainder: BigInteger.Zero };
if (bi_y._sign == -1 && bi_y._bits == null)
return { result: bi_x.negate(), remainder: BigInteger.Zero };
var sign_result = (bi_x._sign > 0) == (bi_y._sign > 0) ? +1 : -1;
var c = BigInteger.compareAbs(bi_x, bi_y);
if (c == 0)
return { result: sign_result > 0 ? BigInteger.One : BigInteger.MinusOne, remainder: BigInteger.Zero };
if (c < 0)
return { result: BigInteger.Zero, remainder: bi_x };
var bits_result = new Array();
var bits_rem = new Array();
Array.copy(bi_x._bits, 0, bits_rem, 0, bi_x._bits.length);
var df = bi_y._bits[bi_y._bits.length - 1];
for (var i = bi_x._bits.length - 1; i >= bi_y._bits.length - 1; i--) {
var offset = i - bi_y._bits.length + 1;
var d = bits_rem[i] + (bits_rem[i + 1] || 0) * DV;
var max = Math.floor(d / df);
if (max > DM)
max = DM;
var min = 0;
while (min != max) {
var bits_sub_1 = new Array(offset + bi_y._bits.length);
for (var i_1 = 0; i_1 < offset; i_1++)
bits_sub_1[i_1] = 0;
bits_result[offset] = Math.ceil((min + max) / 2);
BigInteger.multiplyTo(bi_y._bits, [bits_result[offset]], bits_sub_1, offset);
if (BigInteger.subtractTo(bits_rem, bits_sub_1))
max = bits_result[offset] - 1;
else
min = bits_result[offset];
}
var bits_sub = new Array(offset + bi_y._bits.length);
for (var i_2 = 0; i_2 < offset; i_2++)
bits_sub[i_2] = 0;
bits_result[offset] = min;
BigInteger.multiplyTo(bi_y._bits, [bits_result[offset]], bits_sub, offset);
BigInteger.subtractTo(bits_rem, bits_sub, bits_rem);
}
return { result: BigInteger.create(sign_result, bits_result, true), remainder: BigInteger.create(bi_x._sign, bits_rem, true) };
};
BigInteger.equals = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_x._sign != bi_y._sign)
return false;
if (bi_x._bits.length != bi_y._bits.length)
return false;
for (var i = 0; i < bi_x._bits.length; i++)
if (bi_x._bits[i] != bi_y._bits[i])
return false;
return true;
};
BigInteger.prototype.equals = function (other) {
return BigInteger.equals(this, other);
};
BigInteger.fromString = function (str, radix) {
if (radix === void 0) { radix = 10; }
var bi = Object.create(BigInteger.prototype);
bi.fromString(str, radix);
return bi;
};
BigInteger.prototype.fromString = function (str, radix) {
if (radix === void 0) { radix = 10; }
if (radix < 2 || radix > 36)
throw new RangeError();
if (str.length == 0) {
this._sign == 0;
this._bits = [];
return;
}
var bits_radix = [radix];
var bits_a = [0];
var first = str.charCodeAt(0);
var withsign = first == 0x2b || first == 0x2d;
this._sign = first == 0x2d ? -1 : +1;
this._bits = [];
for (var i = withsign ? 1 : 0; i < str.length; i++) {
bits_a[0] = str.charCodeAt(i);
if (bits_a[0] >= 0x30 && bits_a[0] <= 0x39)
bits_a[0] -= 0x30;
else if (bits_a[0] >= 0x41 && bits_a[0] <= 0x5a)
bits_a[0] -= 0x37;
else if (bits_a[0] >= 0x61 && bits_a[0] <= 0x7a)
bits_a[0] -= 0x57;
else
throw new RangeError();
var bits_temp = new Array();
BigInteger.multiplyTo(this._bits, bits_radix, bits_temp);
BigInteger.addTo(bits_temp, bits_a, this._bits);
}
this.clamp();
};
BigInteger.fromUint8Array = function (arr, sign, littleEndian) {
if (sign === void 0) { sign = 1; }
if (littleEndian === void 0) { littleEndian = true; }
var bi = Object.create(BigInteger.prototype);
bi.fromUint8Array(arr, sign, littleEndian);
return bi;
};
BigInteger.fromUint8ArrayAutoSign = function (arr, littleEndian) {
if (littleEndian === void 0) { littleEndian = true; }
var spos = littleEndian ? arr.length - 1 : 0;
var btsign = arr[spos];
var care = (btsign & 128);
if (care > 0) {
var array = new Uint8Array(arr.length);
for (var i = 0; i < arr.length; i++) {
array[i] = ~arr[i];
}
var n = BigInteger.fromUint8Array(array, 1, littleEndian);
n = n.add(1);
n["_sign"] = -1;
return n;
}
return BigInteger.fromUint8Array(arr, 1, littleEndian);
};
BigInteger.prototype.fromUint8Array = function (arr, sign, littleEndian) {
if (sign === void 0) { sign = 1; }
if (littleEndian === void 0) { littleEndian = true; }
if (!littleEndian) {
var arr_new = new Uint8Array(arr.length);
for (var i = 0; i < arr.length; i++)
arr_new[arr.length - 1 - i] = arr[i];
arr = arr_new;
}
var actual_length = BigInteger.getActualLength(arr);
var bits = actual_length * 8;
var units = Math.ceil(bits / DB);
this._bits = [];
for (var i = 0; i < units; i++) {
var cb = i * DB;
var cu = Math.floor(cb / 8);
cb %= 8;
this._bits[i] = ((arr[cu] | arr[cu + 1] << 8 | arr[cu + 2] << 16 | arr[cu + 3] << 24) >>> cb) & DM;
}
this._sign = sign < 0 ? -1 : +1;
this.clamp();
};
BigInteger.prototype.fromUint64 = function (i, sign) {
while (i.bits[0] != 0 || i.bits[1] != 0) {
this._bits.push(i.toUint32() & DM);
i = i.rightShift(DB);
}
this._sign = sign;
this.clamp();
};
BigInteger.getActualLength = function (arr) {
var actual_length = arr.length;
for (var i = arr.length - 1; i >= 0; i--)
if (arr[i] != 0) {
actual_length = i + 1;
break;
}
return actual_length;
};
BigInteger.getDoubleParts = function (dbl) {
var uu = new Uint32Array(2);
new Float64Array(uu.buffer)[0] = dbl;
var result = {
sign: 1 - ((uu[1] >>> 30) & 2),
man: new Neo.Uint64(uu[0], uu[1] & 0x000FFFFF),
exp: (uu[1] >>> 20) & 0x7FF,
fFinite: true
};
if (result.exp == 0) {
if (!result.man.equals(Neo.Uint64.Zero))
result.exp = -1074;
}
else if (result.exp == 0x7FF) {
result.fFinite = false;
}
else {
result.man = result.man.or(new Neo.Uint64(0, 0x00100000));
result.exp -= 1075;
}
return result;
};
BigInteger.prototype.getLowestSetBit = function () {
if (this._sign == 0)
return -1;
var w = 0;
while (this._bits[w] == 0)
w++;
for (var x = 0; x < DB; x++)
if ((this._bits[w] & 1 << x) > 0)
return x + w * DB;
};
BigInteger.prototype.isEven = function () {
if (this._sign == 0)
return true;
return (this._bits[0] & 1) == 0;
};
BigInteger.prototype.isZero = function () {
return this._sign == 0;
};
BigInteger.prototype.leftShift = function (shift) {
if (shift == 0)
return this;
var shift_units = Math.floor(shift / DB);
shift %= DB;
var bits_new = new Array(this._bits.length + shift_units);
if (shift == 0) {
for (var i = 0; i < this._bits.length; i++)
bits_new[i + shift_units] = this._bits[i];
}
else {
for (var i = shift_units; i < bits_new.length; i++)
bits_new[i] = (this._bits[i - shift_units] << shift | this._bits[i - shift_units - 1] >>> (DB - shift)) & DM;
bits_new[bits_new.length] = this._bits[this._bits.length - 1] >>> (DB - shift) & DM;
}
return BigInteger.create(this._sign, bits_new, true);
};
BigInteger.mod = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
var bi_new = BigInteger.divRem(bi_x, bi_y).remainder;
if (bi_new._sign < 0)
bi_new = BigInteger.add(bi_new, bi_y);
return bi_new;
};
BigInteger.prototype.mod = function (other) {
return BigInteger.mod(this, other);
};
BigInteger.modInverse = function (value, modulus) {
var a = typeof value === "number" ? new BigInteger(value) : value;
var n = typeof modulus === "number" ? new BigInteger(modulus) : modulus;
var i = n, v = BigInteger.Zero, d = BigInteger.One;
while (a._sign > 0) {
var t = BigInteger.divRem(i, a);
var x = d;
i = a;
a = t.remainder;
d = v.subtract(t.result.multiply(x));
v = x;
}
return BigInteger.mod(v, n);
};
BigInteger.prototype.modInverse = function (modulus) {
return BigInteger.modInverse(this, modulus);
};
BigInteger.modPow = function (value, exponent, modulus) {
var bi_v = typeof value === "number" ? new BigInteger(value) : value;
var bi_e = typeof exponent === "number" ? new BigInteger(exponent) : exponent;
var bi_m = typeof modulus === "number" ? new BigInteger(modulus) : modulus;
if (bi_e._sign < 0 || bi_m._sign == 0)
throw new RangeError();
if (Math.abs(bi_m._sign) == 1 && bi_m._bits == null)
return BigInteger.Zero;
var h = bi_e.bitLength();
var bi_new = BigInteger.One;
for (var i = 0; i < h; i++) {
if (i > 0)
bi_v = BigInteger.multiply(bi_v, bi_v);
bi_v = bi_v.remainder(bi_m);
if (bi_e.testBit(i))
bi_new = BigInteger.multiply(bi_v, bi_new).remainder(bi_m);
}
if (bi_new._sign < 0)
bi_new = BigInteger.add(bi_new, bi_m);
return bi_new;
};
BigInteger.prototype.modPow = function (exponent, modulus) {
return BigInteger.modPow(this, exponent, modulus);
};
BigInteger.multiply = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_x._sign == 0)
return bi_x;
if (bi_y._sign == 0)
return bi_y;
if (bi_x._sign == 1 && bi_x._bits == null)
return bi_y;
if (bi_x._sign == -1 && bi_x._bits == null)
return bi_y.negate();
if (bi_y._sign == 1 && bi_y._bits == null)
return bi_x;
if (bi_y._sign == -1 && bi_y._bits == null)
return bi_x.negate();
var bits_r = new Array();
BigInteger.multiplyTo(bi_x._bits, bi_y._bits, bits_r);
return BigInteger.create((bi_x._sign > 0) == (bi_y._sign > 0) ? +1 : -1, bits_r);
};
BigInteger.prototype.multiply = function (other) {
return BigInteger.multiply(this, other);
};
BigInteger.multiplyTo = function (x, y, r, offset) {
if (offset === void 0) { offset = 0; }
if (x.length > y.length) {
var t = x;
x = y;
y = t;
}
for (var i = x.length + y.length - 2; i >= 0; i--)
r[i + offset] = 0;
for (var i = 0; i < x.length; i++) {
if (x[i] == 0)
continue;
for (var j = 0; j < y.length; j++) {
var c = x[i] * y[j];
if (c == 0)
continue;
var k = i + j;
do {
c += r[k + offset] || 0;
r[k + offset] = c & DM;
c = Math.floor(c / DV);
k++;
} while (c > 0);
}
}
};
BigInteger.prototype.negate = function () {
return BigInteger.create(-this._sign, this._bits);
};
BigInteger.parse = function (str) {
return BigInteger.fromString(str);
};
BigInteger.pow = function (value, exponent) {
var bi_v = typeof value === "number" ? new BigInteger(value) : value;
if (exponent < 0 || exponent > 0x7fffffff)
throw new RangeError();
if (exponent == 0)
return BigInteger.One;
if (exponent == 1)
return bi_v;
if (bi_v._sign == 0)
return bi_v;
if (bi_v._bits.length == 1) {
if (bi_v._bits[0] == 1)
return bi_v;
if (bi_v._bits[0] == -1)
return (exponent & 1) != 0 ? bi_v : BigInteger.One;
}
var h = BigInteger.bitLengthInternal(exponent);
var bi_new = BigInteger.One;
for (var i = 0; i < h; i++) {
var e = 1 << i;
if (e > 1)
bi_v = BigInteger.multiply(bi_v, bi_v);
if ((exponent & e) != 0)
bi_new = BigInteger.multiply(bi_v, bi_new);
}
return bi_new;
};
BigInteger.prototype.pow = function (exponent) {
return BigInteger.pow(this, exponent);
};
BigInteger.random = function (bitLength, rng) {
if (bitLength == 0)
return BigInteger.Zero;
var bytes = new Uint8Array(Math.ceil(bitLength / 8));
{
for (var i = 0; i < bytes.length; i++)
bytes[i] = Math.random() * 256;
}
bytes[bytes.length - 1] &= 0xff >>> (8 - bitLength % 8);
return new BigInteger(bytes);
};
BigInteger.remainder = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
return BigInteger.divRem(bi_x, bi_y).remainder;
};
BigInteger.prototype.remainder = function (other) {
return BigInteger.remainder(this, other);
};
BigInteger.prototype.rightShift = function (shift) {
if (shift == 0)
return this;
var shift_units = Math.floor(shift / DB);
shift %= DB;
if (this._bits.length <= shift_units)
return BigInteger.Zero;
var bits_new = new Array(this._bits.length - shift_units);
if (shift == 0) {
for (var i = 0; i < bits_new.length; i++)
bits_new[i] = this._bits[i + shift_units];
}
else {
for (var i = 0; i < bits_new.length; i++)
bits_new[i] = (this._bits[i + shift_units] >>> shift | this._bits[i + shift_units + 1] << (DB - shift)) & DM;
}
return BigInteger.create(this._sign, bits_new, true);
};
BigInteger.prototype.sign = function () {
return this._sign;
};
BigInteger.subtract = function (x, y) {
var bi_x = typeof x === "number" ? new BigInteger(x) : x;
var bi_y = typeof y === "number" ? new BigInteger(y) : y;
if (bi_x._sign == 0)
return bi_y.negate();
if (bi_y._sign == 0)
return bi_x;
if ((bi_x._sign > 0) != (bi_y._sign > 0))
return BigInteger.add(bi_x, bi_y.negate());
var c = BigInteger.compareAbs(bi_x, bi_y);
if (c == 0)
return BigInteger.Zero;
if (c < 0)
return BigInteger.subtract(bi_y, bi_x).negate();
var bits_r = new Array();
BigInteger.subtractTo(bi_x._bits, bi_y._bits, bits_r);
return BigInteger.create(bi_x._sign, bits_r, true);
};
BigInteger.prototype.subtract = function (other) {
return BigInteger.subtract(this, other);
};
BigInteger.subtractTo = function (x, y, r) {
if (r == null)
r = [];
var l = Math.min(x.length, y.length);
var c = 0, i = 0;
while (i < l) {
c += x[i] - y[i];
r[i++] = c & DM;
c >>= DB;
}
if (x.length < y.length)
while (i < y.length) {
c -= y[i];
r[i++] = c & DM;
c >>= DB;
}
else
while (i < x.length) {
c += x[i];
r[i++] = c & DM;
c >>= DB;
}
return c < 0;
};
BigInteger.prototype.testBit = function (n) {
var units = Math.floor(n / DB);
if (this._bits.length <= units)
return false;
return (this._bits[units] & (1 << (n %= DB))) != 0;
};
BigInteger.prototype.toInt32 = function () {
if (this._sign == 0)
return 0;
if (this._bits.length == 1)
return this._bits[0] * this._sign;
return ((this._bits[0] | this._bits[1] * DV) & 0x7fffffff) * this._sign;
};
BigInteger.prototype.toString = function (radix) {
if (radix === void 0) { radix = 10; }
if (this._sign == 0)
return "0";
if (radix < 2 || radix > 36)
throw new RangeError();
var s = "";
for (var bi = this; bi._sign != 0;) {
var r = BigInteger.divRem(bi, radix);
var rem = Math.abs(r.remainder.toInt32());
if (rem < 10)
rem += 0x30;
else
rem += 0x57;
s = String.fromCharCode(rem) + s;
bi = r.result;
}
if (this._sign < 0)
s = "-" + s;
return s;
};
BigInteger.prototype.toUint8Array = function (littleEndian, length) {
if (littleEndian === void 0) { littleEndian = true; }
if (this._sign == 0)
return new Uint8Array(length || 1);
var cb = Math.ceil((this._bits.length * DB + 1) / 8);
var array = new Uint8Array(length || cb);
for (var i = 0; i < array.length; i++) {
var offset = littleEndian ? i : array.length - 1 - i;
var cbits = i * 8;
var cu = Math.floor(cbits / DB);
cbits %= DB;
if (DB - cbits < 8)
array[offset] = (this._bits[cu] >>> cbits | this._bits[cu + 1] << (DB - cbits)) & 0xff;
else
array[offset] = this._bits[cu] >>> cbits & 0xff;
}
length = length || BigInteger.getActualLength(array);
if (length < array.length)
array = array.subarray(0, length);
return array;
};
BigInteger.prototype.toUint8ArrayWithSign = function (littleEndian, length) {
if (littleEndian === void 0) { littleEndian = true; }
if (this._sign == 0)
return new Uint8Array(length || 1);
if (this._sign > 0) {
var cb = Math.ceil((this._bits.length * DB + 1) / 8);
var array_1 = new Uint8Array(length || cb);
for (var i_3 = 0; i_3 < array_1.length; i_3++) {
var offset = littleEndian ? i_3 : array_1.length - 1 - i_3;
var cbits = i_3 * 8;
var cu = Math.floor(cbits / DB);
if (cu <= this._bits.length) {
cbits %= DB;
if (DB - cbits < 8)
array_1[offset] = (this._bits[cu] >>> cbits | this._bits[cu + 1] << (DB - cbits)) & 0xff;
else
array_1[offset] = this._bits[cu] >>> cbits & 0xff;
}
else {
array_1[offset] = 0;
}
}
length = length || BigInteger.getActualLength(array_1);
if (length < array_1.length)
array_1 = array_1.subarray(0, length);
if ((array_1[array_1.length - 1] & 0x80) > 0) {
var newarr = new Uint8Array(array_1.length + 1);
for (var i = 0; i < array_1.length; i++) {
newarr[i] = array_1[i];
}
newarr[array_1.length] = 0;
array_1 = newarr;
}
return array_1;
}
else {
var n = this.add(1);
if (n.sign() < 0)
n["_sign"] = 1;
var array = n.toUint8Array();
var needaddsign = (array[array.length - 1] & 0x80) > 0;
var newarr = new Uint8Array(needaddsign ? array.length + 1 : array.length);
for (var i = 0; i < array.length; i++) {
newarr[i] = ~array[i];
}
if (needaddsign) {
newarr[i] = 0xff;
}
array = newarr;
return array;
}
};
return BigInteger;
}());
Neo.BigInteger = BigInteger;
})(Neo || (Neo = {}));
var Neo;
(function (Neo) {
var D = 100000000;
var _max, _minus, _min, _one, _satoshi;
var Fixed8 = (function () {
function Fixed8(data) {
this.data = data;
if (data.bits[1] >= 0x80000000 && (data.bits[0] != 0xffffffff || data.bits[1] != 0xffffffff))
throw new RangeError();
}
Object.defineProperty(Fixed8, "MaxValue", {
get: function () { return _max || (_max = new Fixed8(new Neo.Uint64(0xffffffff, 0x7fffffff))); },
enumerable: true,
configurable: true
});
Object.defineProperty(Fixed8, "MinusOne", {
get: function () { return _minus || (_minus = new Fixed8(new Neo.Uint64(0xffffffff, 0xffffffff))); },
enumerable: true,
configurable: true
});
Object.defineProperty(Fixed8, "MinValue", {
get: function () { return _min || (_min = new Fixed8(Neo.Uint64.MinValue)); },
enumerable: true,
configurable: true
});
Object.defineProperty(Fixed8, "One", {
get: function () { return _one || (_one = Fixed8.fromNumber(1)); },
enumerable: true,
configurable: true
});
Object.defineProperty(Fixed8, "Satoshi", {
get: function () { return _satoshi || (_satoshi = new Fixed8(new Neo.Uint64(1))); },
enumerable: true,
configurable: true
});
Object.defineProperty(Fixed8, "Zero", {
get: function () { return Fixed8.MinValue; },
enumerable: true,
configurable: true
});
Fixed8.prototype.add = function (other) {
var result = this.data.add(other.data);
if (result.compareTo(this.data) < 0)
throw new Error();
return new Fixed8(result);
};
Fixed8.prototype.compareTo = function (other) {
return this.data.compareTo(other.data);
};
Fixed8.prototype.equals = function (other) {
return this.data.equals(other.data);
};
Fixed8.fromNumber = function (value) {
if (value < 0)
throw new RangeError();
value *= D;
if (value >= 0x8000000000000000)
throw new RangeError();
var array = new Uint32Array((new Neo.BigInteger(value)).toUint8Array(true, 8).buffer);
return new Fixed8(new Neo.Uint64(array[0], array[1]));
};
Fixed8.prototype.getData = function () {
return this.data;
};
Fixed8.max = function (first) {
var others = [];
for (var _i = 1; _i < arguments.length; _i++) {
others[_i - 1] = arguments[_i];
}
for (var i = 0; i < others.length; i++)
if (first.compareTo(others[i]) < 0)
first = others[i];
return first;
};
Fixed8.min = function (first) {
var others = [];
for (var _i = 1; _i < arguments.length; _i++) {
others[_i - 1] = arguments[_i];
}
for (var i = 0; i < others.length; i++)
if (first.compareTo(others[i]) > 0)
first = others[i];
return first;
};
Fixed8.parse = function (str) {
var dot = str.indexOf('.');
var digits = dot >= 0 ? str.length - dot - 1 : 0;
str = str.replace('.', '');
if (digits > 8)
str = str.substr(0, str.length - digits + 8);
else if (digits < 8)
for (var i = digits; i < 8; i++)
str += '0';
return new Fixed8(Neo.Uint64.parse(str));
};
Fixed8.prototype.subtract = function (other) {
if (this.data.compareTo(other.data) < 0)
throw new Error();
return new Fixed8(this.data.subtract(other.data));
};
Fixed8.prototype.toString = function () {
var str = this.data.toString();
while (str.length <= 8)
str = '0' + str;
str = str.substr(0, str.length - 8) + '.' + str.substr(str.length - 8);
var e = 0;
for (var i = str.length - 1; i >= 0; i--)
if (str[i] == '0')
e++;
else
break;
str = str.substr(0, str.length - e);
if (str[str.length - 1] == '.')
str = str.substr(0, str.length - 1);
return str;
};
Fixed8.prototype.deserialize = function (reader) {
this.data = reader.readUint64();
};
Fixed8.prototype.serialize = function (writer) {
writer.writeUint64(this.getData());
};
return Fixed8;
}());
Neo.Fixed8 = Fixed8;
})(Neo || (Neo = {}));
Array.copy = function (src, srcOffset, dst, dstOffset, count) {
for (var i = 0; i < count; i++)
dst[i + dstOffset] = src[i + srcOffset];
};
Array.fromArray = function (arr) {
var array = new Array(arr.length);
for (var i = 0; i < array.length; i++)
array[i] = arr[i];
return array;
};
Uint8Array.fromArrayBuffer = function (buffer) {
if (buffer instanceof Uint8Array)
return buffer;
else if (buffer instanceof ArrayBuffer)
return new Uint8Array(buffer);
else {
var view = buffer;
return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
}
};
String.prototype.hexToBytes = function () {
if ((this.length & 1) != 0)
throw new RangeError();
var str = this;
if (this.length >= 2 && this[0] == '0' && this[1] == 'x')
str = this.substr(2);
var bytes = new Uint8Array(str.length / 2);
for (var i = 0; i < bytes.length; i++) {
bytes[i] = parseInt(str.substr(i * 2, 2), 16);
}
return bytes;
};
ArrayBuffer.prototype.slice = ArrayBuffer.prototype.slice || function (begin, end) {
if (end === void 0) { end = this.byteLength; }
if (begin < 0)
begin += this.byteLength;
if (begin < 0)
begin = 0;
if (end < 0)
end += this.byteLength;
if (end > this.byteLength)
end = this.byteLength;
var length = end - begin;
if (length < 0)
length = 0;
var src = new Uint8Array(this);
var dst = new Uint8Array(length);
for (var i = 0; i < length; i++)
dst[i] = src[i + begin];
return dst.buffer;
};
Uint8Array.prototype.toHexString = function () {
var s = "";
for (var i = 0; i < this.length; i++) {
s += (this[i] >>> 4).toString(16);
s += (this[i] & 0xf).toString(16);
}
return s;
};
Uint8Array.prototype.clone = function () {
var u8 = new Uint8Array(this.length);
for (var i = 0; i < this.length; i++)
u8[i] = this[i];
return u8;
};
Uint8Array.prototype.concat = function (data) {
var newarr = new Uint8Array(this.length + data.length);
for (var i = 0; i < this.length; i++) {
newarr[i] = this[i];
}
for (var i = 0; i < data.length; i++) {
newarr[this.length + i] = data[i];
}
return newarr;
};
void function () {
function fillArray(value, start, end) {
if (start === void 0) { start = 0; }
if (end === void 0) { end = this.length; }
if (start < 0)
start += this.length;
if (start < 0)
start = 0;
if (start >= this.length)
return this;
if (end < 0)
end += this.length;
if (end < 0)
return this;
if (end > this.length)
end = this.length;
for (var i = start; i < end; i++)
this[i] = value;
return this;
}
Array.prototype.fill = Array.prototype.fill || fillArray;
Int8Array.prototype.fill = Int8Array.prototype.fill || fillArray;
Int16Array.prototype.fill = Int16Array.prototype.fill || fillArray;
Int32Array.prototype.fill = Int32Array.prototype.fill || fillArray;
Uint8Array.prototype.fill = Uint8Array.prototype.fill || fillArray;
Uint16Array.prototype.fill = Uint16Array.prototype.fill || fillArray;
Uint32Array.prototype.fill = Uint32Array.prototype.fill || fillArray;
}();
var NeoMap = (function () {
function NeoMap() {
this._map = new Object();
this._size = 0;
}
Object.defineProperty(NeoMap.prototype, "size", {
get: function () { return this._size; },
enumerable: true,
configurable: true
});
NeoMap.prototype.clear = function () {
for (var key in this._map)
delete this._map[key];
this._size = 0;
};
NeoMap.prototype.delete = function (key) {
if (!this._map.hasOwnProperty(key))
return false;
this._size--;
return delete this._map[key];
};
NeoMap.prototype.forEach = function (callback) {
for (var key in this._map)
callback(this._map[key], key, this);
};
NeoMap.prototype.get = function (key) {
return this._map[key];
};
NeoMap.prototype.has = function (key) {
return this._map.hasOwnProperty(key);
};
NeoMap.prototype.set = function (key, value) {
if (!this._map.hasOwnProperty(key))
this._size++;
this._map[key] = value;
};
return NeoMap;
}());
var PromiseState;
(function (PromiseState) {
PromiseState[PromiseState["pending"] = 0] = "pending";
PromiseState[PromiseState["fulfilled"] = 1] = "fulfilled";
PromiseState[PromiseState["rejected"] = 2] = "rejected";
})(PromiseState || (PromiseState = {}));
var NeoPromise = (function () {
function NeoPromise(executor) {
this._state = PromiseState.pending;
this._callback_attached = false;
if (executor != null)
executor(this.resolve.bind(this), this.reject.bind(this));
}
NeoPromise.all = function (iterable) {
return new NeoPromise(function (resolve, reject) {
if (iterable.length == 0) {
resolve([]);
return;
}
var