eosjs
Version:
Talk to eos API
1,276 lines • 64.8 kB
JavaScript
"use strict";
/**
* @module Serialize
*/
// copyright defined in eosjs/LICENSE.txt
/* eslint-disable max-classes-per-file */
/* eslint-disable jsdoc/check-indentation */
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.serializeQuery = exports.deserializeAnyArray = exports.serializeAnyArray = exports.deserializeAnyObject = exports.serializeAnyObject = exports.deserializeAnyvarShort = exports.deserializeAnyvar = exports.serializeAnyvar = exports.deserializeAction = exports.deserializeActionData = exports.serializeAction = exports.serializeActionData = exports.transactionHeader = exports.getTypesFromAbi = exports.getType = exports.createTransactionTypes = exports.createTransactionExtensionTypes = exports.createAbiTypes = exports.createInitialTypes = exports.hexToUint8Array = exports.arrayToHex = exports.symbolToString = exports.stringToSymbol = exports.blockTimestampToDate = exports.dateToBlockTimestamp = exports.timePointSecToDate = exports.dateToTimePointSec = exports.timePointToDate = exports.dateToTimePoint = exports.supportedAbiVersion = exports.SerialBuffer = exports.SerializerState = void 0;
var numeric = require("./eosjs-numeric");
/** State for serialize() and deserialize() */
var SerializerState = /** @class */ (function () {
function SerializerState(options) {
if (options === void 0) { options = {}; }
/** Have any binary extensions been skipped? */
this.skippedBinaryExtension = false;
this.options = options;
}
return SerializerState;
}());
exports.SerializerState = SerializerState;
/** Serialize and deserialize data */
var SerialBuffer = /** @class */ (function () {
/**
* @param __namedParameters
* `array`: `null` if serializing, or binary data to deserialize
* `textEncoder`: `TextEncoder` instance to use. Pass in `null` if running in a browser
* `textDecoder`: `TextDecider` instance to use. Pass in `null` if running in a browser
*/
function SerialBuffer(_a) {
var _b = _a === void 0 ? {} : _a, textEncoder = _b.textEncoder, textDecoder = _b.textDecoder, array = _b.array;
/** Current position while reading (deserializing) */
this.readPos = 0;
this.array = array || new Uint8Array(1024);
this.length = array ? array.length : 0;
this.textEncoder = textEncoder || new TextEncoder();
this.textDecoder = textDecoder || new TextDecoder('utf-8', { fatal: true });
}
/** Resize `array` if needed to have at least `size` bytes free */
SerialBuffer.prototype.reserve = function (size) {
if (this.length + size <= this.array.length) {
return;
}
var l = this.array.length;
while (this.length + size > l) {
l = Math.ceil(l * 1.5);
}
var newArray = new Uint8Array(l);
newArray.set(this.array);
this.array = newArray;
};
/** Is there data available to read? */
SerialBuffer.prototype.haveReadData = function () {
return this.readPos < this.length;
};
/** Restart reading from the beginning */
SerialBuffer.prototype.restartRead = function () {
this.readPos = 0;
};
/** Return data with excess storage trimmed away */
SerialBuffer.prototype.asUint8Array = function () {
return new Uint8Array(this.array.buffer, this.array.byteOffset, this.length);
};
/** Append bytes */
SerialBuffer.prototype.pushArray = function (v) {
this.reserve(v.length);
this.array.set(v, this.length);
this.length += v.length;
};
/** Append bytes */
SerialBuffer.prototype.push = function () {
var v = [];
for (var _i = 0; _i < arguments.length; _i++) {
v[_i] = arguments[_i];
}
this.pushArray(v);
};
/** Get a single byte */
SerialBuffer.prototype.get = function () {
if (this.readPos < this.length) {
return this.array[this.readPos++];
}
throw new Error('Read past end of buffer');
};
/** Append bytes in `v`. Throws if `len` doesn't match `v.length` */
SerialBuffer.prototype.pushUint8ArrayChecked = function (v, len) {
if (v.length !== len) {
throw new Error('Binary data has incorrect size');
}
this.pushArray(v);
};
/** Get `len` bytes */
SerialBuffer.prototype.getUint8Array = function (len) {
if (this.readPos + len > this.length) {
throw new Error('Read past end of buffer');
}
var result = new Uint8Array(this.array.buffer, this.array.byteOffset + this.readPos, len);
this.readPos += len;
return result;
};
/** Skip `len` bytes */
SerialBuffer.prototype.skip = function (len) {
if (this.readPos + len > this.length) {
throw new Error('Read past end of buffer');
}
this.readPos += len;
};
/** Append a `uint16` */
SerialBuffer.prototype.pushUint16 = function (v) {
this.push((v >> 0) & 0xff, (v >> 8) & 0xff);
};
/** Get a `uint16` */
SerialBuffer.prototype.getUint16 = function () {
var v = 0;
v |= this.get() << 0;
v |= this.get() << 8;
return v;
};
/** Append a `uint32` */
SerialBuffer.prototype.pushUint32 = function (v) {
this.push((v >> 0) & 0xff, (v >> 8) & 0xff, (v >> 16) & 0xff, (v >> 24) & 0xff);
};
/** Get a `uint32` */
SerialBuffer.prototype.getUint32 = function () {
var v = 0;
v |= this.get() << 0;
v |= this.get() << 8;
v |= this.get() << 16;
v |= this.get() << 24;
return v >>> 0;
};
/** Append a `uint64`. *Caution*: `number` only has 53 bits of precision */
SerialBuffer.prototype.pushNumberAsUint64 = function (v) {
this.pushUint32(v >>> 0);
this.pushUint32(Math.floor(v / 4294967296) >>> 0);
};
/**
* Get a `uint64` as a `number`. *Caution*: `number` only has 53 bits of precision; some values will change.
* `numeric.binaryToDecimal(serialBuffer.getUint8Array(8))` recommended instead
*/
SerialBuffer.prototype.getUint64AsNumber = function () {
var low = this.getUint32();
var high = this.getUint32();
return (high >>> 0) * 4294967296 + (low >>> 0);
};
/** Append a `varuint32` */
SerialBuffer.prototype.pushVaruint32 = function (v) {
while (true) {
if (v >>> 7) {
this.push(0x80 | (v & 0x7f));
v = v >>> 7;
}
else {
this.push(v);
break;
}
}
};
/** Get a `varuint32` */
SerialBuffer.prototype.getVaruint32 = function () {
var v = 0;
var bit = 0;
while (true) {
var b = this.get();
v |= (b & 0x7f) << bit;
bit += 7;
if (!(b & 0x80)) {
break;
}
}
return v >>> 0;
};
/** Append a `varint32` */
SerialBuffer.prototype.pushVarint32 = function (v) {
this.pushVaruint32((v << 1) ^ (v >> 31));
};
/** Get a `varint32` */
SerialBuffer.prototype.getVarint32 = function () {
var v = this.getVaruint32();
if (v & 1) {
return ((~v) >> 1) | 2147483648;
}
else {
return v >>> 1;
}
};
/** Append a `float32` */
SerialBuffer.prototype.pushFloat32 = function (v) {
this.pushArray(new Uint8Array((new Float32Array([v])).buffer));
};
/** Get a `float32` */
SerialBuffer.prototype.getFloat32 = function () {
return new Float32Array(this.getUint8Array(4).slice().buffer)[0];
};
/** Append a `float64` */
SerialBuffer.prototype.pushFloat64 = function (v) {
this.pushArray(new Uint8Array((new Float64Array([v])).buffer));
};
/** Get a `float64` */
SerialBuffer.prototype.getFloat64 = function () {
return new Float64Array(this.getUint8Array(8).slice().buffer)[0];
};
/** Append a `name` */
SerialBuffer.prototype.pushName = function (s) {
if (typeof s !== 'string') {
throw new Error('Expected string containing name');
}
var regex = new RegExp(/^[.1-5a-z]{0,12}[.1-5a-j]?$/);
if (!regex.test(s)) {
throw new Error('Name should be less than 13 characters, or less than 14 if last character is between 1-5 or a-j, and only contain the following symbols .12345abcdefghijklmnopqrstuvwxyz'); // eslint-disable-line
}
var charToSymbol = function (c) {
if (c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
return (c - 'a'.charCodeAt(0)) + 6;
}
if (c >= '1'.charCodeAt(0) && c <= '5'.charCodeAt(0)) {
return (c - '1'.charCodeAt(0)) + 1;
}
return 0;
};
var a = new Uint8Array(8);
var bit = 63;
for (var i = 0; i < s.length; ++i) {
var c = charToSymbol(s.charCodeAt(i));
if (bit < 5) {
c = c << 1;
}
for (var j = 4; j >= 0; --j) {
if (bit >= 0) {
a[Math.floor(bit / 8)] |= ((c >> j) & 1) << (bit % 8);
--bit;
}
}
}
this.pushArray(a);
};
/** Get a `name` */
SerialBuffer.prototype.getName = function () {
var a = this.getUint8Array(8);
var result = '';
for (var bit = 63; bit >= 0;) {
var c = 0;
for (var i = 0; i < 5; ++i) {
if (bit >= 0) {
c = (c << 1) | ((a[Math.floor(bit / 8)] >> (bit % 8)) & 1);
--bit;
}
}
if (c >= 6) {
result += String.fromCharCode(c + 'a'.charCodeAt(0) - 6);
}
else if (c >= 1) {
result += String.fromCharCode(c + '1'.charCodeAt(0) - 1);
}
else {
result += '.';
}
}
while (result.endsWith('.')) {
result = result.substr(0, result.length - 1);
}
return result;
};
/** Append length-prefixed binary data */
SerialBuffer.prototype.pushBytes = function (v) {
this.pushVaruint32(v.length);
this.pushArray(v);
};
/** Get length-prefixed binary data */
SerialBuffer.prototype.getBytes = function () {
return this.getUint8Array(this.getVaruint32());
};
/** Append a string */
SerialBuffer.prototype.pushString = function (v) {
this.pushBytes(this.textEncoder.encode(v));
};
/** Get a string */
SerialBuffer.prototype.getString = function () {
return this.textDecoder.decode(this.getBytes());
};
/** Append a `symbol_code`. Unlike `symbol`, `symbol_code` doesn't include a precision. */
SerialBuffer.prototype.pushSymbolCode = function (name) {
if (typeof name !== 'string') {
throw new Error('Expected string containing symbol_code');
}
var a = [];
a.push.apply(a, __spreadArray([], __read(this.textEncoder.encode(name))));
while (a.length < 8) {
a.push(0);
}
this.pushArray(a.slice(0, 8));
};
/** Get a `symbol_code`. Unlike `symbol`, `symbol_code` doesn't include a precision. */
SerialBuffer.prototype.getSymbolCode = function () {
var a = this.getUint8Array(8);
var len;
for (len = 0; len < a.length; ++len) {
if (!a[len]) {
break;
}
}
var name = this.textDecoder.decode(new Uint8Array(a.buffer, a.byteOffset, len));
return name;
};
/** Append a `symbol` */
SerialBuffer.prototype.pushSymbol = function (_a) {
var name = _a.name, precision = _a.precision;
if (!/^[A-Z]{1,7}$/.test(name)) {
throw new Error('Expected symbol to be A-Z and between one and seven characters');
}
var a = [precision & 0xff];
a.push.apply(a, __spreadArray([], __read(this.textEncoder.encode(name))));
while (a.length < 8) {
a.push(0);
}
this.pushArray(a.slice(0, 8));
};
/** Get a `symbol` */
SerialBuffer.prototype.getSymbol = function () {
var precision = this.get();
var a = this.getUint8Array(7);
var len;
for (len = 0; len < a.length; ++len) {
if (!a[len]) {
break;
}
}
var name = this.textDecoder.decode(new Uint8Array(a.buffer, a.byteOffset, len));
return { name: name, precision: precision };
};
/** Append an asset */
SerialBuffer.prototype.pushAsset = function (s) {
if (typeof s !== 'string') {
throw new Error('Expected string containing asset');
}
s = s.trim();
var pos = 0;
var amount = '';
var precision = 0;
if (s[pos] === '-') {
amount += '-';
++pos;
}
var foundDigit = false;
while (pos < s.length && s.charCodeAt(pos) >= '0'.charCodeAt(0) && s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
foundDigit = true;
amount += s[pos];
++pos;
}
if (!foundDigit) {
throw new Error('Asset must begin with a number');
}
if (s[pos] === '.') {
++pos;
while (pos < s.length && s.charCodeAt(pos) >= '0'.charCodeAt(0) && s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
amount += s[pos];
++precision;
++pos;
}
}
var name = s.substr(pos).trim();
this.pushArray(numeric.signedDecimalToBinary(8, amount));
this.pushSymbol({ name: name, precision: precision });
};
/** Get an asset */
SerialBuffer.prototype.getAsset = function () {
var amount = this.getUint8Array(8);
var _a = this.getSymbol(), name = _a.name, precision = _a.precision;
var s = numeric.signedBinaryToDecimal(amount, precision + 1);
if (precision) {
s = s.substr(0, s.length - precision) + '.' + s.substr(s.length - precision);
}
return s + ' ' + name;
};
/** Append a public key */
SerialBuffer.prototype.pushPublicKey = function (s) {
var key = numeric.stringToPublicKey(s);
this.push(key.type);
this.pushArray(key.data);
};
/** Get a public key */
SerialBuffer.prototype.getPublicKey = function () {
var type = this.get();
var data;
if (type === numeric.KeyType.wa) {
var begin = this.readPos;
this.skip(34);
this.skip(this.getVaruint32());
data = new Uint8Array(this.array.buffer, this.array.byteOffset + begin, this.readPos - begin);
}
else {
data = this.getUint8Array(numeric.publicKeyDataSize);
}
return numeric.publicKeyToString({ type: type, data: data });
};
/** Append a private key */
SerialBuffer.prototype.pushPrivateKey = function (s) {
var key = numeric.stringToPrivateKey(s);
this.push(key.type);
this.pushArray(key.data);
};
/** Get a private key */
SerialBuffer.prototype.getPrivateKey = function () {
var type = this.get();
var data = this.getUint8Array(numeric.privateKeyDataSize);
return numeric.privateKeyToString({ type: type, data: data });
};
/** Append a signature */
SerialBuffer.prototype.pushSignature = function (s) {
var key = numeric.stringToSignature(s);
this.push(key.type);
this.pushArray(key.data);
};
/** Get a signature */
SerialBuffer.prototype.getSignature = function () {
var type = this.get();
var data;
if (type === numeric.KeyType.wa) {
var begin = this.readPos;
this.skip(65);
this.skip(this.getVaruint32());
this.skip(this.getVaruint32());
data = new Uint8Array(this.array.buffer, this.array.byteOffset + begin, this.readPos - begin);
}
else {
data = this.getUint8Array(numeric.signatureDataSize);
}
return numeric.signatureToString({ type: type, data: data });
};
return SerialBuffer;
}()); // SerialBuffer
exports.SerialBuffer = SerialBuffer;
/** Is this a supported ABI version? */
var supportedAbiVersion = function (version) {
return version.startsWith('eosio::abi/1.');
};
exports.supportedAbiVersion = supportedAbiVersion;
var checkDateParse = function (date) {
var result = Date.parse(date);
if (Number.isNaN(result)) {
throw new Error('Invalid time format');
}
return result;
};
/** Convert date in ISO format to `time_point` (miliseconds since epoch) */
var dateToTimePoint = function (date) {
return Math.round(checkDateParse(date + 'Z') * 1000);
};
exports.dateToTimePoint = dateToTimePoint;
/** Convert `time_point` (miliseconds since epoch) to date in ISO format */
var timePointToDate = function (us) {
var s = (new Date(us / 1000)).toISOString();
return s.substr(0, s.length - 1);
};
exports.timePointToDate = timePointToDate;
/** Convert date in ISO format to `time_point_sec` (seconds since epoch) */
var dateToTimePointSec = function (date) {
return Math.round(checkDateParse(date + 'Z') / 1000);
};
exports.dateToTimePointSec = dateToTimePointSec;
/** Convert `time_point_sec` (seconds since epoch) to to date in ISO format */
var timePointSecToDate = function (sec) {
var s = (new Date(sec * 1000)).toISOString();
return s.substr(0, s.length - 1);
};
exports.timePointSecToDate = timePointSecToDate;
/** Convert date in ISO format to `block_timestamp_type` (half-seconds since a different epoch) */
var dateToBlockTimestamp = function (date) {
return Math.round((checkDateParse(date + 'Z') - 946684800000) / 500);
};
exports.dateToBlockTimestamp = dateToBlockTimestamp;
/** Convert `block_timestamp_type` (half-seconds since a different epoch) to to date in ISO format */
var blockTimestampToDate = function (slot) {
var s = (new Date(slot * 500 + 946684800000)).toISOString();
return s.substr(0, s.length - 1);
};
exports.blockTimestampToDate = blockTimestampToDate;
/** Convert `string` to `Symbol`. format: `precision,NAME`. */
var stringToSymbol = function (s) {
if (typeof s !== 'string') {
throw new Error('Expected string containing symbol');
}
var m = s.match(/^([0-9]+),([A-Z]+)$/);
if (!m) {
throw new Error('Invalid symbol');
}
return { name: m[2], precision: +m[1] };
};
exports.stringToSymbol = stringToSymbol;
/** Convert `Symbol` to `string`. format: `precision,NAME`. */
var symbolToString = function (_a) {
var name = _a.name, precision = _a.precision;
return precision + ',' + name;
};
exports.symbolToString = symbolToString;
/** Convert binary data to hex */
var arrayToHex = function (data) {
var e_1, _a;
var result = '';
try {
for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
var x = data_1_1.value;
result += ('00' + x.toString(16)).slice(-2);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
}
finally { if (e_1) throw e_1.error; }
}
return result.toUpperCase();
};
exports.arrayToHex = arrayToHex;
/** Convert hex to binary data */
var hexToUint8Array = function (hex) {
if (typeof hex !== 'string') {
throw new Error('Expected string containing hex digits');
}
if (hex.length % 2) {
throw new Error('Odd number of hex digits');
}
var l = hex.length / 2;
var result = new Uint8Array(l);
for (var i = 0; i < l; ++i) {
var x = parseInt(hex.substr(i * 2, 2), 16);
if (Number.isNaN(x)) {
throw new Error('Expected hex string');
}
result[i] = x;
}
return result;
};
exports.hexToUint8Array = hexToUint8Array;
function serializeUnknown(buffer, data) {
throw new Error('Don\'t know how to serialize ' + this.name);
}
function deserializeUnknown(buffer) {
throw new Error('Don\'t know how to deserialize ' + this.name);
}
function serializeStruct(buffer, data, state, allowExtensions) {
var e_2, _a;
if (state === void 0) { state = new SerializerState(); }
if (allowExtensions === void 0) { allowExtensions = true; }
if (typeof data !== 'object') {
throw new Error('expected object containing data: ' + JSON.stringify(data));
}
if (this.base) {
this.base.serialize(buffer, data, state, allowExtensions);
}
try {
for (var _b = __values(this.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
var field = _c.value;
if (field.name in data) {
if (state.skippedBinaryExtension) {
throw new Error('unexpected ' + this.name + '.' + field.name);
}
field.type.serialize(buffer, data[field.name], state, allowExtensions && field === this.fields[this.fields.length - 1]);
}
else {
if (allowExtensions && field.type.extensionOf) {
state.skippedBinaryExtension = true;
}
else {
throw new Error('missing ' + this.name + '.' + field.name + ' (type=' + field.type.name + ')');
}
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
}
function deserializeStruct(buffer, state, allowExtensions) {
var e_3, _a;
if (state === void 0) { state = new SerializerState(); }
if (allowExtensions === void 0) { allowExtensions = true; }
var result;
if (this.base) {
result = this.base.deserialize(buffer, state, allowExtensions);
}
else {
result = {};
}
try {
for (var _b = __values(this.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
var field = _c.value;
if (allowExtensions && field.type.extensionOf && !buffer.haveReadData()) {
state.skippedBinaryExtension = true;
}
else {
result[field.name] = field.type.deserialize(buffer, state, allowExtensions);
}
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_3) throw e_3.error; }
}
return result;
}
function serializeVariant(buffer, data, state, allowExtensions) {
if (!Array.isArray(data) || data.length !== 2 || typeof data[0] !== 'string') {
throw new Error('expected variant: ["type", value]');
}
var i = this.fields.findIndex(function (field) { return field.name === data[0]; });
if (i < 0) {
throw new Error("type \"" + data[0] + "\" is not valid for variant");
}
buffer.pushVaruint32(i);
this.fields[i].type.serialize(buffer, data[1], state, allowExtensions);
}
function deserializeVariant(buffer, state, allowExtensions) {
var i = buffer.getVaruint32();
if (i >= this.fields.length) {
throw new Error("type index " + i + " is not valid for variant");
}
var field = this.fields[i];
return [field.name, field.type.deserialize(buffer, state, allowExtensions)];
}
function serializeArray(buffer, data, state, allowExtensions) {
var e_4, _a;
buffer.pushVaruint32(data.length);
try {
for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
var item = data_2_1.value;
this.arrayOf.serialize(buffer, item, state, false);
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (data_2_1 && !data_2_1.done && (_a = data_2.return)) _a.call(data_2);
}
finally { if (e_4) throw e_4.error; }
}
}
function deserializeArray(buffer, state, allowExtensions) {
var len = buffer.getVaruint32();
var result = [];
for (var i = 0; i < len; ++i) {
result.push(this.arrayOf.deserialize(buffer, state, false));
}
return result;
}
function serializeOptional(buffer, data, state, allowExtensions) {
if (data === null || data === undefined) {
buffer.push(0);
}
else {
buffer.push(1);
this.optionalOf.serialize(buffer, data, state, allowExtensions);
}
}
function deserializeOptional(buffer, state, allowExtensions) {
if (buffer.get()) {
return this.optionalOf.deserialize(buffer, state, allowExtensions);
}
else {
return null;
}
}
function serializeExtension(buffer, data, state, allowExtensions) {
this.extensionOf.serialize(buffer, data, state, allowExtensions);
}
function deserializeExtension(buffer, state, allowExtensions) {
return this.extensionOf.deserialize(buffer, state, allowExtensions);
}
function serializeObject(buffer, data, state, allowExtensions) {
var e_5, _a;
var entries = Object.entries(data);
buffer.pushVaruint32(entries.length);
try {
for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
var _b = __read(entries_1_1.value, 2), key = _b[0], value = _b[1];
var keyType = this.fields[0].type;
var dataType = this.fields[1].type;
keyType.serialize(buffer, key, state, allowExtensions);
dataType.serialize(buffer, value, state, allowExtensions);
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
}
finally { if (e_5) throw e_5.error; }
}
}
function deserializeObject(buffer, state, allowExtensions) {
var len = buffer.getVaruint32();
var result = {};
for (var i = 0; i < len; ++i) {
var keyType = this.fields[0].type;
var dataType = this.fields[1].type;
var key = keyType.deserialize(buffer, state, allowExtensions);
result[key] = dataType.deserialize(buffer, state, allowExtensions);
}
return result;
}
function serializePair(buffer, data, state, allowExtensions) {
var _this = this;
buffer.pushVaruint32(data.length);
data.forEach(function (item) {
_this.fields[0].type.serialize(buffer, item[0], state, allowExtensions);
_this.fields[1].type.serialize(buffer, item[1], state, allowExtensions);
});
}
function deserializePair(buffer, state, allowExtensions) {
var result = [];
var len = buffer.getVaruint32();
for (var i = 0; i < len; ++i) {
result.push(this.fields[0].type.deserialize(buffer, state, allowExtensions));
result.push(this.fields[1].type.deserialize(buffer, state, allowExtensions));
}
return result;
}
var createType = function (attrs) {
return __assign({ name: '<missing name>', aliasOfName: '', arrayOf: null, optionalOf: null, extensionOf: null, baseName: '', base: null, fields: [], serialize: serializeUnknown, deserialize: deserializeUnknown }, attrs);
};
var checkRange = function (orig, converted) {
if (Number.isNaN(+orig) || Number.isNaN(+converted) || (typeof orig !== 'number' && typeof orig !== 'string')) {
throw new Error('Expected number');
}
if (+orig !== +converted) {
throw new Error('Number is out of range');
}
return +orig;
};
/** Create the set of types built-in to the abi format */
var createInitialTypes = function () {
var result = new Map(Object.entries({
bool: createType({
name: 'bool',
serialize: function (buffer, data) {
if (!(typeof data === 'boolean' || typeof data === 'number' && (data === 1 || data === 0))) {
throw new Error('Expected boolean or number equal to 1 or 0');
}
buffer.push(data ? 1 : 0);
},
deserialize: function (buffer) { return !!buffer.get(); },
}),
uint8: createType({
name: 'uint8',
serialize: function (buffer, data) { buffer.push(checkRange(data, data & 0xff)); },
deserialize: function (buffer) { return buffer.get(); },
}),
int8: createType({
name: 'int8',
serialize: function (buffer, data) { buffer.push(checkRange(data, data << 24 >> 24)); },
deserialize: function (buffer) { return buffer.get() << 24 >> 24; },
}),
uint16: createType({
name: 'uint16',
serialize: function (buffer, data) { buffer.pushUint16(checkRange(data, data & 0xffff)); },
deserialize: function (buffer) { return buffer.getUint16(); },
}),
int16: createType({
name: 'int16',
serialize: function (buffer, data) { buffer.pushUint16(checkRange(data, data << 16 >> 16)); },
deserialize: function (buffer) { return buffer.getUint16() << 16 >> 16; },
}),
uint32: createType({
name: 'uint32',
serialize: function (buffer, data) { buffer.pushUint32(checkRange(data, data >>> 0)); },
deserialize: function (buffer) { return buffer.getUint32(); },
}),
uint64: createType({
name: 'uint64',
serialize: function (buffer, data) {
buffer.pushArray(numeric.decimalToBinary(8, '' + data));
},
deserialize: function (buffer) { return numeric.binaryToDecimal(buffer.getUint8Array(8)); },
}),
int64: createType({
name: 'int64',
serialize: function (buffer, data) {
buffer.pushArray(numeric.signedDecimalToBinary(8, '' + data));
},
deserialize: function (buffer) { return numeric.signedBinaryToDecimal(buffer.getUint8Array(8)); },
}),
int32: createType({
name: 'int32',
serialize: function (buffer, data) { buffer.pushUint32(checkRange(data, data | 0)); },
deserialize: function (buffer) { return buffer.getUint32() | 0; },
}),
varuint32: createType({
name: 'varuint32',
serialize: function (buffer, data) { buffer.pushVaruint32(checkRange(data, data >>> 0)); },
deserialize: function (buffer) { return buffer.getVaruint32(); },
}),
varint32: createType({
name: 'varint32',
serialize: function (buffer, data) { buffer.pushVarint32(checkRange(data, data | 0)); },
deserialize: function (buffer) { return buffer.getVarint32(); },
}),
uint128: createType({
name: 'uint128',
serialize: function (buffer, data) { buffer.pushArray(numeric.decimalToBinary(16, '' + data)); },
deserialize: function (buffer) { return numeric.binaryToDecimal(buffer.getUint8Array(16)); },
}),
int128: createType({
name: 'int128',
serialize: function (buffer, data) {
buffer.pushArray(numeric.signedDecimalToBinary(16, '' + data));
},
deserialize: function (buffer) { return numeric.signedBinaryToDecimal(buffer.getUint8Array(16)); },
}),
float32: createType({
name: 'float32',
serialize: function (buffer, data) { buffer.pushFloat32(data); },
deserialize: function (buffer) { return buffer.getFloat32(); },
}),
float64: createType({
name: 'float64',
serialize: function (buffer, data) { buffer.pushFloat64(data); },
deserialize: function (buffer) { return buffer.getFloat64(); },
}),
float128: createType({
name: 'float128',
serialize: function (buffer, data) { buffer.pushUint8ArrayChecked(exports.hexToUint8Array(data), 16); },
deserialize: function (buffer) { return exports.arrayToHex(buffer.getUint8Array(16)); },
}),
bytes: createType({
name: 'bytes',
serialize: function (buffer, data) {
if (data instanceof Uint8Array || Array.isArray(data)) {
buffer.pushBytes(data);
}
else {
buffer.pushBytes(exports.hexToUint8Array(data));
}
},
deserialize: function (buffer, state) {
if (state && state.options.bytesAsUint8Array) {
return buffer.getBytes();
}
else {
return exports.arrayToHex(buffer.getBytes());
}
},
}),
string: createType({
name: 'string',
serialize: function (buffer, data) { buffer.pushString(data); },
deserialize: function (buffer) { return buffer.getString(); },
}),
name: createType({
name: 'name',
serialize: function (buffer, data) { buffer.pushName(data); },
deserialize: function (buffer) { return buffer.getName(); },
}),
time_point: createType({
name: 'time_point',
serialize: function (buffer, data) { buffer.pushNumberAsUint64(exports.dateToTimePoint(data)); },
deserialize: function (buffer) { return exports.timePointToDate(buffer.getUint64AsNumber()); },
}),
time_point_sec: createType({
name: 'time_point_sec',
serialize: function (buffer, data) { buffer.pushUint32(exports.dateToTimePointSec(data)); },
deserialize: function (buffer) { return exports.timePointSecToDate(buffer.getUint32()); },
}),
block_timestamp_type: createType({
name: 'block_timestamp_type',
serialize: function (buffer, data) { buffer.pushUint32(exports.dateToBlockTimestamp(data)); },
deserialize: function (buffer) { return exports.blockTimestampToDate(buffer.getUint32()); },
}),
symbol_code: createType({
name: 'symbol_code',
serialize: function (buffer, data) { buffer.pushSymbolCode(data); },
deserialize: function (buffer) { return buffer.getSymbolCode(); },
}),
symbol: createType({
name: 'symbol',
serialize: function (buffer, data) { buffer.pushSymbol(exports.stringToSymbol(data)); },
deserialize: function (buffer) { return exports.symbolToString(buffer.getSymbol()); },
}),
asset: createType({
name: 'asset',
serialize: function (buffer, data) { buffer.pushAsset(data); },
deserialize: function (buffer) { return buffer.getAsset(); },
}),
checksum160: createType({
name: 'checksum160',
serialize: function (buffer, data) { buffer.pushUint8ArrayChecked(exports.hexToUint8Array(data), 20); },
deserialize: function (buffer) { return exports.arrayToHex(buffer.getUint8Array(20)); },
}),
checksum256: createType({
name: 'checksum256',
serialize: function (buffer, data) { buffer.pushUint8ArrayChecked(exports.hexToUint8Array(data), 32); },
deserialize: function (buffer) { return exports.arrayToHex(buffer.getUint8Array(32)); },
}),
checksum512: createType({
name: 'checksum512',
serialize: function (buffer, data) { buffer.pushUint8ArrayChecked(exports.hexToUint8Array(data), 64); },
deserialize: function (buffer) { return exports.arrayToHex(buffer.getUint8Array(64)); },
}),
public_key: createType({
name: 'public_key',
serialize: function (buffer, data) { buffer.pushPublicKey(data); },
deserialize: function (buffer) { return buffer.getPublicKey(); },
}),
private_key: createType({
name: 'private_key',
serialize: function (buffer, data) { buffer.pushPrivateKey(data); },
deserialize: function (buffer) { return buffer.getPrivateKey(); },
}),
signature: createType({
name: 'signature',
serialize: function (buffer, data) { buffer.pushSignature(data); },
deserialize: function (buffer) { return buffer.getSignature(); },
}),
}));
result.set('extended_asset', createType({
name: 'extended_asset',
baseName: '',
fields: [
{ name: 'quantity', typeName: 'asset', type: result.get('asset') },
{ name: 'contract', typeName: 'name', type: result.get('name') },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
return result;
}; // createInitialTypes()
exports.createInitialTypes = createInitialTypes;
var createAbiTypes = function () {
var initialTypes = exports.createInitialTypes();
initialTypes.set('extensions_entry', createType({
name: 'extensions_entry',
baseName: '',
fields: [
{ name: 'tag', typeName: 'uint16', type: null },
{ name: 'value', typeName: 'bytes', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('type_def', createType({
name: 'type_def',
baseName: '',
fields: [
{ name: 'new_type_name', typeName: 'string', type: null },
{ name: 'type', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('field_def', createType({
name: 'field_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'string', type: null },
{ name: 'type', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('struct_def', createType({
name: 'struct_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'string', type: null },
{ name: 'base', typeName: 'string', type: null },
{ name: 'fields', typeName: 'field_def[]', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('action_def', createType({
name: 'action_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'type', typeName: 'string', type: null },
{ name: 'ricardian_contract', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('table_def', createType({
name: 'table_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'index_type', typeName: 'string', type: null },
{ name: 'key_names', typeName: 'string[]', type: null },
{ name: 'key_types', typeName: 'string[]', type: null },
{ name: 'type', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('clause_pair', createType({
name: 'clause_pair',
baseName: '',
fields: [
{ name: 'id', typeName: 'string', type: null },
{ name: 'body', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('error_message', createType({
name: 'error_message',
baseName: '',
fields: [
{ name: 'error_code', typeName: 'uint64', type: null },
{ name: 'error_msg', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('variant_def', createType({
name: 'variant_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'string', type: null },
{ name: 'types', typeName: 'string[]', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('action_result', createType({
name: 'action_result',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'result_type', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('primary_key_index_def', createType({
name: 'primary_key_index_def',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'type', typeName: 'string', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('secondary_index_def', createType({
name: 'secondary_index_def',
baseName: '',
fields: [
{ name: 'type', typeName: 'string', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('secondary_indices', createType({
name: 'secondary_indices',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'secondary_index_def', typeName: 'secondary_index_def', type: null }
],
serialize: serializeObject,
deserialize: deserializeObject,
}));
initialTypes.set('kv_table_entry_def', createType({
name: 'kv_table_entry_def',
baseName: '',
fields: [
{ name: 'type', typeName: 'string', type: null },
{ name: 'primary_index', typeName: 'primary_key_index_def', type: null },
{ name: 'secondary_indices', typeName: 'secondary_indices', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('kv_table', createType({
name: 'kv_table',
baseName: '',
fields: [
{ name: 'name', typeName: 'name', type: null },
{ name: 'kv_table_entry_def', typeName: 'kv_table_entry_def', type: null }
],
serialize: serializeObject,
deserialize: deserializeObject
}));
initialTypes.set('abi_def', createType({
name: 'abi_def',
baseName: '',
fields: [
{ name: 'version', typeName: 'string', type: null },
{ name: 'types', typeName: 'type_def[]', type: null },
{ name: 'structs', typeName: 'struct_def[]', type: null },
{ name: 'actions', typeName: 'action_def[]', type: null },
{ name: 'tables', typeName: 'table_def[]', type: null },
{ name: 'ricardian_clauses', typeName: 'clause_pair[]', type: null },
{ name: 'error_messages', typeName: 'error_message[]', type: null },
{ name: 'abi_extensions', typeName: 'extensions_entry[]', type: null },
{ name: 'variants', typeName: 'variant_def[]$', type: null },
{ name: 'action_results', typeName: 'action_result[]$', type: null },
{ name: 'kv_tables', typeName: 'kv_table$', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
return initialTypes;
};
exports.createAbiTypes = createAbiTypes;
var createTransactionExtensionTypes = function () {
var initialTypes = exports.createInitialTypes();
initialTypes.set('resource_payer', createType({
name: 'resource_payer',
baseName: '',
fields: [
{ name: 'payer', typeName: 'name', type: null },
{ name: 'max_net_bytes', typeName: 'uint64', type: null },
{ name: 'max_cpu_us', typeName: 'uint64', type: null },
{ name: 'max_memory_bytes', typeName: 'uint64', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
return initialTypes;
};
exports.createTransactionExtensionTypes = createTransactionExtensionTypes;
var createTransactionTypes = function () {
var initialTypes = exports.createInitialTypes();
initialTypes.set('permission_level', createType({
name: 'permission_level',
baseName: '',
fields: [
{ name: 'actor', typeName: 'name', type: null },
{ name: 'permission', typeName: 'name', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('action', createType({
name: 'action',
baseName: '',
fields: [
{ name: 'account', typeName: 'name', type: null },
{ name: 'name', typeName: 'name', type: null },
{ name: 'authorization', typeName: 'permission_level[]', type: null },
{ name: 'data', typeName: 'bytes', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('extension', createType({
name: 'extension',
baseName: '',
fields: [
{ name: 'type', typeName: 'uint16', type: null },
{ name: 'data', typeName: 'bytes', type: null },
],
serialize: serializePair,
deserialize: deserializePair,
}));
initialTypes.set('transaction_header', createType({
name: 'transaction_header',
baseName: '',
fields: [
{ name: 'expiration', typeName: 'time_point_sec', type: null },
{ name: 'ref_block_num', typeName: 'uint16', type: null },
{ name: 'ref_block_prefix', typeName: 'uint32', type: null },
{ name: 'max_net_usage_words', typeName: 'varuint32', type: null },
{ name: 'max_cpu_usage_ms', typeName: 'uint8', type: null },
{ name: 'delay_sec', typeName: 'varuint32', type: null },
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
initialTypes.set('transaction', createType({
name: 'transaction',
baseName: 'transaction_header',
fields: [
{ name: 'context_free_actions', typeName: 'action[]', type: null },
{ name: 'actions', typeName: 'action[]', type: null },
{ name: 'transaction_extensions', typeName: 'extension', type: null }
],
serialize: serializeStruct,
deserialize: deserializeStruct,
}));
return initialTypes;
};
exports.createTransactionTypes = createTransactionTypes;
/** Get type from `types` */
var getType = function (types, name) {
var type = types.get(name);
if (type && type.aliasOfName) {
return exports.getType(types, type.aliasOfName);
}
if (type) {
return type;
}
if (name.endsWith('[]')) {
return createType({
name: name,
arrayOf: exports.getType(types, name.substr(0, name.length - 2)),
serialize: serializeArray,
deserialize: deserializeArray,
});
}
if (name.endsWith('?')) {
return createType({
name: name,
optionalOf: exports.getType(types, name.substr(0, name.length - 1)),
serialize: serializeOptional,
deserialize: deserializeOptional,
});
}
if (name.endsWith('$')) {
return createType({
name: name,
extensionOf: exports.getType(types, name.substr(0, name.length - 1)),
serialize: serializeExtension,
deserialize: deserializeExtension,
});
}
throw new Error('Unknown type: ' + name);
};
exports.getType = getType;
/**
* Get types from abi
*
* @param initialTypes Set of types to build on.
* In most cases, it's best to fill this from a