@airgap/substrate 0.13.7-beta.11

package/protocol/common/data/scale/SCALEDecoder.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { SCALECompatAddressType } from '../../../compat/SubstrateCompatAddress';
+import { SubstrateNetwork } from '../../../SubstrateNetwork';
+import { SCALEAccountId } from './type/SCALEAccountId';
+import { SCALEArray } from './type/SCALEArray';
+import { SCALEBoolean } from './type/SCALEBoolean';
+import { SCALEBytes } from './type/SCALEBytes';
+import { SCALECompactInt } from './type/SCALECompactInt';
+import { SCALEData } from './type/SCALEData';
+import { SCALEEnum } from './type/SCALEEnum';
+import { SCALEEra } from './type/SCALEEra';
+import { SCALEHash } from './type/SCALEHash';
+import { SCALEInt } from './type/SCALEInt';
+import { SCALEMultiAddress, SCALEMultiAddressType } from './type/SCALEMultiAddress';
+import { SCALEOptional } from './type/SCALEOptional';
+import { SCALEString } from './type/SCALEString';
+import { SCALETuple } from './type/SCALETuple';
+import { SCALEType } from './type/SCALEType';
+export declare type DecoderMethod<T, Network extends SubstrateNetwork> = (network: Network, runtimeVersion: number | undefined, hex: string) => SCALEDecodeResult<T>;
+export declare type DecoderPartialMethod<T> = (hex: string) => SCALEDecodeResult<T>;
+export interface SCALEDecodeResult<T> {
+    bytesDecoded: number;
+    decoded: T;
+}
+export declare class SCALEDecoder<Network extends SubstrateNetwork> {
+    private readonly network;
+    private readonly runtimeVersion;
+    private hex;
+    constructor(network: Network, runtimeVersion: number | undefined, bytes: string | Uint8Array | Buffer);
+    decodeNextAccount(): SCALEDecodeResult<SCALECompatAddressType[Network]>;
+    decodeNextAccountId(byteLength?: number): SCALEDecodeResult<SCALEAccountId<Network>>;
+    decodeNextArray<T extends SCALEType>(decoderMethod: DecoderMethod<T, Network>): SCALEDecodeResult<SCALEArray<T>>;
+    decodeNextBoolean(): SCALEDecodeResult<SCALEBoolean>;
+    decodeNextBytes(): SCALEDecodeResult<SCALEBytes>;
+    decodeNextCompactInt(): SCALEDecodeResult<SCALECompactInt>;
+    decodeNextEra(): SCALEDecodeResult<SCALEEra>;
+    decodeNextHash(bitLength: number): SCALEDecodeResult<SCALEHash>;
+    decodeNextInt(bitLength: number): SCALEDecodeResult<SCALEInt>;
+    decodeNextMultiAccount<T extends SCALEMultiAddressType>(type?: T): SCALEDecodeResult<SCALEMultiAddress<T, Network>>;
+    decodeNextOptional<T extends SCALEType>(decoderMethod: DecoderMethod<T, Network>): SCALEDecodeResult<SCALEOptional<T>>;
+    decodeNextString(): SCALEDecodeResult<SCALEString>;
+    decodeNextTuple<T extends SCALEType, R extends SCALEType>(firstDecoderMethod: DecoderMethod<T, Network>, secondDecoderMethod: DecoderMethod<R, Network>): SCALEDecodeResult<SCALETuple<T, R>>;
+    decodeNextEnum<T>(getEnumValue: (value: number) => T | null): SCALEDecodeResult<SCALEEnum<T>>;
+    decodeNextData(): SCALEDecodeResult<SCALEData>;
+    decodeNextObject<T>(decoderMethod: DecoderMethod<T, Network>): SCALEDecodeResult<T>;
+    private decodeNextValuePartial;
+    private decodeNextValue;
+    private moveCursor;
+}

package/protocol/common/data/scale/SCALEDecoder.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCALEDecoder = void 0;
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var SubstrateCompatAddress_1 = require("../../../compat/SubstrateCompatAddress");
+var SCALEAccountId_1 = require("./type/SCALEAccountId");
+var SCALEArray_1 = require("./type/SCALEArray");
+var SCALEBoolean_1 = require("./type/SCALEBoolean");
+var SCALEBytes_1 = require("./type/SCALEBytes");
+var SCALECompactInt_1 = require("./type/SCALECompactInt");
+var SCALEData_1 = require("./type/SCALEData");
+var SCALEEnum_1 = require("./type/SCALEEnum");
+var SCALEEra_1 = require("./type/SCALEEra");
+var SCALEHash_1 = require("./type/SCALEHash");
+var SCALEInt_1 = require("./type/SCALEInt");
+var SCALEMultiAddress_1 = require("./type/SCALEMultiAddress");
+var SCALEOptional_1 = require("./type/SCALEOptional");
+var SCALEString_1 = require("./type/SCALEString");
+var SCALETuple_1 = require("./type/SCALETuple");
+var SCALEDecoder = /** @class */ (function () {
+    function SCALEDecoder(network, runtimeVersion, bytes) {
+        this.network = network;
+        this.runtimeVersion = runtimeVersion;
+        this.hex = typeof bytes === 'string' ? hex_1.stripHexPrefix(bytes) : Buffer.from(bytes).toString('hex');
+    }
+    SCALEDecoder.prototype.decodeNextAccount = function () {
+        var _this = this;
+        return this.decodeNextValue(function (network, runtimeVersion, hex) { return SubstrateCompatAddress_1.scaleAddressFactory(_this.network).decode(network, runtimeVersion, hex); });
+    };
+    SCALEDecoder.prototype.decodeNextAccountId = function (byteLength) {
+        if (byteLength === void 0) { byteLength = 32; }
+        return this.decodeNextValue(function (network, _, hex) { return SCALEAccountId_1.SCALEAccountId.decode(network, hex, byteLength); });
+    };
+    SCALEDecoder.prototype.decodeNextArray = function (decoderMethod) {
+        return this.decodeNextValue(function (network, runtimeVersion, hex) { return SCALEArray_1.SCALEArray.decode(network, runtimeVersion, hex, decoderMethod); });
+    };
+    SCALEDecoder.prototype.decodeNextBoolean = function () {
+        return this.decodeNextValuePartial(SCALEBoolean_1.SCALEBoolean.decode);
+    };
+    SCALEDecoder.prototype.decodeNextBytes = function () {
+        return this.decodeNextValuePartial(SCALEBytes_1.SCALEBytes.decode);
+    };
+    SCALEDecoder.prototype.decodeNextCompactInt = function () {
+        return this.decodeNextValuePartial(SCALECompactInt_1.SCALECompactInt.decode);
+    };
+    SCALEDecoder.prototype.decodeNextEra = function () {
+        return this.decodeNextValuePartial(SCALEEra_1.SCALEEra.decode);
+    };
+    SCALEDecoder.prototype.decodeNextHash = function (bitLength) {
+        return this.decodeNextValue(function (_network, _runtimeVersion, hex) { return SCALEHash_1.SCALEHash.decode(hex, bitLength); });
+    };
+    SCALEDecoder.prototype.decodeNextInt = function (bitLength) {
+        return this.decodeNextValue(function (_network, _runtimeVersion, hex) { return SCALEInt_1.SCALEInt.decode(hex, bitLength); });
+    };
+    SCALEDecoder.prototype.decodeNextMultiAccount = function (type) {
+        return this.decodeNextValue(function (network, runtimeVersion, hex) { return SCALEMultiAddress_1.SCALEMultiAddress.decode(network, hex, type, runtimeVersion); });
+    };
+    SCALEDecoder.prototype.decodeNextOptional = function (decoderMethod) {
+        return this.decodeNextValue(function (network, runtimeVersion, hex) { return SCALEOptional_1.SCALEOptional.decode(network, runtimeVersion, hex, decoderMethod); });
+    };
+    SCALEDecoder.prototype.decodeNextString = function () {
+        return this.decodeNextValuePartial(SCALEString_1.SCALEString.decode);
+    };
+    SCALEDecoder.prototype.decodeNextTuple = function (firstDecoderMethod, secondDecoderMethod) {
+        return this.decodeNextValue(function (network, runtimeVersion, hex) {
+            return SCALETuple_1.SCALETuple.decode(network, runtimeVersion, hex, firstDecoderMethod, secondDecoderMethod);
+        });
+    };
+    SCALEDecoder.prototype.decodeNextEnum = function (getEnumValue) {
+        return this.decodeNextValue(function (_network, _runtimeVersion, hex) { return SCALEEnum_1.SCALEEnum.decode(hex, getEnumValue); });
+    };
+    SCALEDecoder.prototype.decodeNextData = function () {
+        return this.decodeNextValue(function (_network, _runtimeVersion, hex) { return SCALEData_1.SCALEData.decode(hex); });
+    };
+    SCALEDecoder.prototype.decodeNextObject = function (decoderMethod) {
+        return this.decodeNextValue(decoderMethod);
+    };
+    SCALEDecoder.prototype.decodeNextValuePartial = function (decoderPartialMethod, nibbleLength) {
+        return this.decodeNextValue(function (_network, _runtimeVersion, hex) { return decoderPartialMethod(hex); }, nibbleLength);
+    };
+    SCALEDecoder.prototype.decodeNextValue = function (decoderMethod, nibbleLength) {
+        var decoded = decoderMethod(this.network, this.runtimeVersion, this.hex.substr(0, nibbleLength));
+        this.moveCursor(decoded.bytesDecoded);
+        return decoded;
+    };
+    SCALEDecoder.prototype.moveCursor = function (bytes) {
+        this.hex = this.hex.slice(bytes * 2);
+    };
+    return SCALEDecoder;
+}());
+exports.SCALEDecoder = SCALEDecoder;
+//# sourceMappingURL=SCALEDecoder.js.map

package/protocol/common/data/scale/SCALEDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEDecoder.js","sourceRoot":"","sources":["../../../../../src/protocol/common/data/scale/SCALEDecoder.ts"],"names":[],"mappings":"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"}

package/protocol/common/data/scale/type/SCALEAccountId.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { SubstrateAccountId, SubstrateCompatAddressType } from '../../../../compat/SubstrateCompatAddress';
+import { SubstrateNetwork } from '../../../../SubstrateNetwork';
+import { SCALEDecodeResult } from '../SCALEDecoder';
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+export declare class SCALEAccountId<Network extends SubstrateNetwork> extends SCALEType {
+    readonly address: SubstrateCompatAddressType[Network];
+    static from<Network extends SubstrateNetwork>(value: string | Uint8Array | Buffer | SubstrateCompatAddressType[Network], network: Network): SCALEAccountId<Network>;
+    static decode<Network extends SubstrateNetwork>(network: Network, hex: string, byteLength?: number): SCALEDecodeResult<SCALEAccountId<Network>>;
+    private constructor();
+    compare(other: SCALEAccountId<Network> | SubstrateAccountId<SubstrateCompatAddressType[Network]>): number;
+    asAddress(): string;
+    asBytes(): Buffer;
+    toString(): string;
+    protected _encode(config?: SCALEEncodeConfig): string;
+}

package/protocol/common/data/scale/type/SCALEAccountId.js

@@ -0,0 +1,64 @@
+"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) {
+        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.SCALEAccountId = void 0;
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var SubstrateCompatAddress_1 = require("../../../../compat/SubstrateCompatAddress");
+var SCALEType_1 = require("./SCALEType");
+var SCALEAccountId = /** @class */ (function (_super) {
+    __extends(SCALEAccountId, _super);
+    function SCALEAccountId(address) {
+        var _this = _super.call(this) || this;
+        _this.address = address;
+        return _this;
+    }
+    SCALEAccountId.from = function (value, network) {
+        var address = SubstrateCompatAddress_1.isSubstrateCompatAddress(value)
+            ? value
+            : SubstrateCompatAddress_1.substrateAddressFactory(network).from(hex_1.bytesToHex(value));
+        return new SCALEAccountId(address);
+    };
+    SCALEAccountId.decode = function (network, hex, byteLength) {
+        if (byteLength === void 0) { byteLength = 32; }
+        var _hex = hex_1.stripHexPrefix(hex).substr(0, byteLength * 2);
+        return {
+            bytesDecoded: Math.ceil(_hex.length / 2),
+            decoded: SCALEAccountId.from(_hex, network)
+        };
+    };
+    SCALEAccountId.prototype.compare = function (other) {
+        if (typeof other === 'string' || SubstrateCompatAddress_1.isSubstrateCompatAddress(other)) {
+            return this.address.compare(other);
+        }
+        else {
+            return this.address.compare(other.address);
+        }
+    };
+    SCALEAccountId.prototype.asAddress = function () {
+        return this.address.asString();
+    };
+    SCALEAccountId.prototype.asBytes = function () {
+        return this.address.getBufferBytes();
+    };
+    SCALEAccountId.prototype.toString = function () {
+        return this.address.getHexBytes();
+    };
+    SCALEAccountId.prototype._encode = function (config) {
+        return this.address.getHexBytes();
+    };
+    return SCALEAccountId;
+}(SCALEType_1.SCALEType));
+exports.SCALEAccountId = SCALEAccountId;
+//# sourceMappingURL=SCALEAccountId.js.map

package/protocol/common/data/scale/type/SCALEAccountId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEAccountId.js","sourceRoot":"","sources":["../../../../../../src/protocol/common/data/scale/type/SCALEAccountId.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAA2E;AAC3E,oFAMkD;AAIlD,yCAA0D;AAE1D;IAAsE,kCAAS;IAyB7E,wBAA6B,OAA4C;QAAzE,YACE,iBAAO,SACR;QAF4B,aAAO,GAAP,OAAO,CAAqC;;IAEzE,CAAC;IA1Ba,mBAAI,GAAlB,UACE,KAAyE,EACzE,OAAgB;QAEhB,IAAM,OAAO,GAAwC,iDAAwB,CAAC,KAAK,CAAC;YAClF,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,gDAAuB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,gBAAU,CAAC,KAAK,CAAC,CAAC,CAAA;QAE5D,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAA;IACpC,CAAC;IAEa,qBAAM,GAApB,UACE,OAAgB,EAChB,GAAW,EACX,UAAuB;QAAvB,2BAAA,EAAA,eAAuB;QAEvB,IAAM,IAAI,GAAG,oBAAc,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,CAAA;QAE1D,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;YACxC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC;SAC5C,CAAA;IACH,CAAC;IAMM,gCAAO,GAAd,UAAe,KAAwF;QACrG,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,iDAAwB,CAAC,KAAK,CAAC,EAAE;YAChE,OAAQ,IAAI,CAAC,OAAkC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;SAC/D;aAAM;YACL,OAAQ,IAAI,CAAC,OAAkC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SACvE;IACH,CAAC;IAEM,kCAAS,GAAhB;QACE,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAA;IAChC,CAAC;IAEM,gCAAO,GAAd;QACE,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAA;IACtC,CAAC;IAEM,iCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAA;IACnC,CAAC;IAES,gCAAO,GAAjB,UAAkB,MAA0B;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAA;IACnC,CAAC;IACH,qBAAC;AAAD,CAAC,AApDD,CAAsE,qBAAS,GAoD9E;AApDY,wCAAc"}

package/protocol/common/data/scale/type/SCALEArray.d.ts

@@ -0,0 +1,11 @@
+import { SubstrateNetwork } from '../../../../SubstrateNetwork';
+import { DecoderMethod, SCALEDecodeResult } from '../SCALEDecoder';
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+export declare class SCALEArray<T extends SCALEType> extends SCALEType {
+    readonly elements: T[];
+    static from<T extends SCALEType>(elements: T[]): SCALEArray<T>;
+    static decode<T extends SCALEType, Network extends SubstrateNetwork>(network: Network, runtimeVersion: number | undefined, hex: string, decodeElement: DecoderMethod<T, Network>): SCALEDecodeResult<SCALEArray<T>>;
+    protected constructor(elements: T[]);
+    toString(): string;
+    protected _encode(config?: SCALEEncodeConfig): string;
+}

package/protocol/common/data/scale/type/SCALEArray.js

@@ -0,0 +1,63 @@
+"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) {
+        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.SCALEArray = void 0;
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var SCALECompactInt_1 = require("./SCALECompactInt");
+var SCALEType_1 = require("./SCALEType");
+var SCALEArray = /** @class */ (function (_super) {
+    __extends(SCALEArray, _super);
+    function SCALEArray(elements) {
+        var _this = _super.call(this) || this;
+        _this.elements = elements;
+        return _this;
+    }
+    SCALEArray.from = function (elements) {
+        return new SCALEArray(elements);
+    };
+    SCALEArray.decode = function (network, runtimeVersion, hex, decodeElement) {
+        var _hex = hex_1.stripHexPrefix(hex);
+        var arrayLength = SCALECompactInt_1.SCALECompactInt.decode(_hex);
+        _hex = _hex.slice(arrayLength.bytesDecoded * 2);
+        var elements = [];
+        var bytesDecoded = 0;
+        for (var i = 0; i < arrayLength.decoded.toNumber(); i++) {
+            var element = decodeElement(network, runtimeVersion, _hex);
+            elements.push(element.decoded);
+            bytesDecoded += element.bytesDecoded;
+            _hex = _hex.slice(element.bytesDecoded * 2);
+        }
+        return {
+            bytesDecoded: arrayLength.bytesDecoded + bytesDecoded,
+            decoded: SCALEArray.from(elements)
+        };
+    };
+    SCALEArray.prototype.toString = function () {
+        return JSON.stringify(this.elements.map(function (element) {
+            var elementString = element.toString();
+            try {
+                elementString = JSON.parse(elementString);
+            }
+            catch (_a) { }
+            return elementString;
+        }));
+    };
+    SCALEArray.prototype._encode = function (config) {
+        return SCALECompactInt_1.SCALECompactInt.from(this.elements.length).encode(config) + this.elements.map(function (element) { return element.encode(config); }).join('');
+    };
+    return SCALEArray;
+}(SCALEType_1.SCALEType));
+exports.SCALEArray = SCALEArray;
+//# sourceMappingURL=SCALEArray.js.map

package/protocol/common/data/scale/type/SCALEArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEArray.js","sourceRoot":"","sources":["../../../../../../src/protocol/common/data/scale/type/SCALEArray.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAA+D;AAI/D,qDAAmD;AACnD,yCAA0D;AAE1D;IAAqD,8BAAS;IAgC5D,oBAA+B,QAAa;QAA5C,YACE,iBAAO,SACR;QAF8B,cAAQ,GAAR,QAAQ,CAAK;;IAE5C,CAAC;IAjCa,eAAI,GAAlB,UAAwC,QAAa;QACnD,OAAO,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAA;IACjC,CAAC;IAEa,iBAAM,GAApB,UACE,OAAgB,EAChB,cAAkC,EAClC,GAAW,EACX,aAAwC;QAExC,IAAI,IAAI,GAAG,oBAAc,CAAC,GAAG,CAAC,CAAA;QAE9B,IAAM,WAAW,GAAG,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAEhD,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,GAAG,CAAC,CAAC,CAAA;QAE/C,IAAM,QAAQ,GAAQ,EAAE,CAAA;QACxB,IAAI,YAAY,GAAG,CAAC,CAAA;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,EAAE;YACvD,IAAM,OAAO,GAAG,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,CAAA;YAC5D,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;YAC9B,YAAY,IAAI,OAAO,CAAC,YAAY,CAAA;YACpC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC,CAAA;SAC5C;QAED,OAAO;YACL,YAAY,EAAE,WAAW,CAAC,YAAY,GAAG,YAAY;YACrD,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC;SACnC,CAAA;IACH,CAAC;IAMM,6BAAQ,GAAf;QACE,OAAO,IAAI,CAAC,SAAS,CACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAC,OAAO;YACxB,IAAI,aAAa,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAA;YACtC,IAAI;gBACF,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;aAC1C;YAAC,WAAM,GAAE;YAEV,OAAO,aAAa,CAAA;QACtB,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IAES,4BAAO,GAAjB,UAAkB,MAA0B;QAC1C,OAAO,iCAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAC,OAAO,IAAK,OAAA,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAtB,CAAsB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IACpI,CAAC;IACH,iBAAC;AAAD,CAAC,AApDD,CAAqD,qBAAS,GAoD7D;AApDY,gCAAU"}

package/protocol/common/data/scale/type/SCALEBoolean.d.ts

@@ -0,0 +1,10 @@
+import { SCALEDecodeResult } from '../SCALEDecoder';
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+export declare class SCALEBoolean extends SCALEType {
+    readonly value: boolean;
+    static from(value: boolean | number): SCALEBoolean;
+    static decode(hex: string): SCALEDecodeResult<SCALEBoolean>;
+    private constructor();
+    toString(): string;
+    protected _encode(config?: SCALEEncodeConfig): string;
+}

package/protocol/common/data/scale/type/SCALEBoolean.js

@@ -0,0 +1,46 @@
+"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) {
+        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.SCALEBoolean = void 0;
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var SCALEType_1 = require("./SCALEType");
+var SCALEBoolean = /** @class */ (function (_super) {
+    __extends(SCALEBoolean, _super);
+    function SCALEBoolean(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    SCALEBoolean.from = function (value) {
+        return new SCALEBoolean(!!value);
+    };
+    SCALEBoolean.decode = function (hex) {
+        var _hex = hex_1.stripHexPrefix(hex);
+        var value = parseInt(_hex.substr(0, 2), 16);
+        return {
+            bytesDecoded: 1,
+            decoded: SCALEBoolean.from(value)
+        };
+    };
+    SCALEBoolean.prototype.toString = function () {
+        return String(this.value);
+    };
+    SCALEBoolean.prototype._encode = function (config) {
+        return hex_1.toHexStringRaw(this.value ? 1 : 0);
+    };
+    return SCALEBoolean;
+}(SCALEType_1.SCALEType));
+exports.SCALEBoolean = SCALEBoolean;
+//# sourceMappingURL=SCALEBoolean.js.map

package/protocol/common/data/scale/type/SCALEBoolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEBoolean.js","sourceRoot":"","sources":["../../../../../../src/protocol/common/data/scale/type/SCALEBoolean.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAA+E;AAG/E,yCAA0D;AAE1D;IAAkC,gCAAS;IAgBzC,sBAA6B,KAAc;QAA3C,YACE,iBAAO,SACR;QAF4B,WAAK,GAAL,KAAK,CAAS;;IAE3C,CAAC;IAjBa,iBAAI,GAAlB,UAAmB,KAAuB;QACxC,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC;IAEa,mBAAM,GAApB,UAAqB,GAAW;QAC9B,IAAM,IAAI,GAAG,oBAAc,CAAC,GAAG,CAAC,CAAA;QAEhC,IAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAE7C,OAAO;YACL,YAAY,EAAE,CAAC;YACf,OAAO,EAAE,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;SAClC,CAAA;IACH,CAAC;IAMM,+BAAQ,GAAf;QACE,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;IAES,8BAAO,GAAjB,UAAkB,MAA0B;QAC1C,OAAO,oBAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC3C,CAAC;IACH,mBAAC;AAAD,CAAC,AA3BD,CAAkC,qBAAS,GA2B1C;AA3BY,oCAAY"}

package/protocol/common/data/scale/type/SCALEBytes.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { SCALEDecodeResult } from '../SCALEDecoder';
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+export declare class SCALEBytes extends SCALEType {
+    readonly bytes: Buffer;
+    static from(bytes: string | Buffer | Uint8Array): SCALEBytes;
+    static decode(hex: string): SCALEDecodeResult<SCALEBytes>;
+    private constructor();
+    toString(encoding?: BufferEncoding): string;
+    protected _encode(config?: SCALEEncodeConfig): string;
+}

package/protocol/common/data/scale/type/SCALEBytes.js

@@ -0,0 +1,61 @@
+"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) {
+        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.SCALEBytes = void 0;
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var SCALECompactInt_1 = require("./SCALECompactInt");
+var SCALEType_1 = require("./SCALEType");
+var SCALEBytes = /** @class */ (function (_super) {
+    __extends(SCALEBytes, _super);
+    function SCALEBytes(bytes) {
+        var _this = _super.call(this) || this;
+        _this.bytes = bytes;
+        return _this;
+    }
+    SCALEBytes.from = function (bytes) {
+        var buffer;
+        if (typeof bytes === 'string' && hex_1.isHex(bytes)) {
+            buffer = Buffer.from(hex_1.stripHexPrefix(bytes), 'hex');
+        }
+        else if (!(typeof bytes === 'string')) {
+            buffer = Buffer.from(bytes);
+        }
+        else {
+            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.SUBSTRATE, 'SCALEBytes#from: Unknown bytes type.');
+        }
+        return new SCALEBytes(buffer);
+    };
+    SCALEBytes.decode = function (hex) {
+        var _hex = hex_1.stripHexPrefix(hex);
+        var length = SCALECompactInt_1.SCALECompactInt.decode(_hex);
+        var bytes = _hex.substr(length.bytesDecoded * 2, length.decoded.toNumber() * 2);
+        return {
+            bytesDecoded: length.bytesDecoded + length.decoded.toNumber(),
+            decoded: SCALEBytes.from(bytes)
+        };
+    };
+    SCALEBytes.prototype.toString = function (encoding) {
+        if (encoding === void 0) { encoding = 'hex'; }
+        return this.bytes.toString(encoding);
+    };
+    SCALEBytes.prototype._encode = function (config) {
+        return SCALECompactInt_1.SCALECompactInt.from(this.bytes.length).encode(config) + this.bytes.toString('hex');
+    };
+    return SCALEBytes;
+}(SCALEType_1.SCALEType));
+exports.SCALEBytes = SCALEBytes;
+//# sourceMappingURL=SCALEBytes.js.map

package/protocol/common/data/scale/type/SCALEBytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEBytes.js","sourceRoot":"","sources":["../../../../../../src/protocol/common/data/scale/type/SCALEBytes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAA+D;AAC/D,2EAAkE;AAClE,sDAAsE;AAGtE,qDAAmD;AACnD,yCAA0D;AAE1D;IAAgC,8BAAS;IA0BvC,oBAA6B,KAAa;QAA1C,YACE,iBAAO,SACR;QAF4B,WAAK,GAAL,KAAK,CAAQ;;IAE1C,CAAC;IA3Ba,eAAI,GAAlB,UAAmB,KAAmC;QACpD,IAAI,MAAc,CAAA;QAClB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,WAAK,CAAC,KAAK,CAAC,EAAE;YAC7C,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,oBAAc,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAA;SACnD;aAAM,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,EAAE;YACvC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;SAC5B;aAAM;YACL,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,SAAS,EAAE,sCAAsC,CAAC,CAAA;SACtF;QAED,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;IAC/B,CAAC;IAEa,iBAAM,GAApB,UAAqB,GAAW;QAC9B,IAAM,IAAI,GAAG,oBAAc,CAAC,GAAG,CAAC,CAAA;QAEhC,IAAM,MAAM,GAAG,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAC3C,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,GAAG,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAA;QAEjF,OAAO;YACL,YAAY,EAAE,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE;YAC7D,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC;SAChC,CAAA;IACH,CAAC;IAMM,6BAAQ,GAAf,UAAgB,QAAgC;QAAhC,yBAAA,EAAA,gBAAgC;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACtC,CAAC;IAES,4BAAO,GAAjB,UAAkB,MAA0B;QAC1C,OAAO,iCAAe,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAC5F,CAAC;IACH,iBAAC;AAAD,CAAC,AArCD,CAAgC,qBAAS,GAqCxC;AArCY,gCAAU"}

package/protocol/common/data/scale/type/SCALEClass.d.ts

@@ -0,0 +1,6 @@
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+export declare abstract class SCALEClass extends SCALEType {
+    protected abstract readonly scaleFields: SCALEType[];
+    toString(): string;
+    protected _encode(config?: SCALEEncodeConfig): string;
+}

package/protocol/common/data/scale/type/SCALEClass.js

@@ -0,0 +1,32 @@
+"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) {
+        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.SCALEClass = void 0;
+var SCALEType_1 = require("./SCALEType");
+var SCALEClass = /** @class */ (function (_super) {
+    __extends(SCALEClass, _super);
+    function SCALEClass() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SCALEClass.prototype.toString = function () {
+        return "[" + this.scaleFields.map(function (field) { return field.toString(); }).join() + "]";
+    };
+    SCALEClass.prototype._encode = function (config) {
+        return this.scaleFields.reduce(function (encoded, current) { return encoded + current.encode(config); }, '');
+    };
+    return SCALEClass;
+}(SCALEType_1.SCALEType));
+exports.SCALEClass = SCALEClass;
+//# sourceMappingURL=SCALEClass.js.map

package/protocol/common/data/scale/type/SCALEClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCALEClass.js","sourceRoot":"","sources":["../../../../../../src/protocol/common/data/scale/type/SCALEClass.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAA0D;AAE1D;IAAyC,8BAAS;IAAlD;;IAUA,CAAC;IAPQ,6BAAQ,GAAf;QACE,OAAO,MAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,QAAQ,EAAE,EAAhB,CAAgB,CAAC,CAAC,IAAI,EAAE,MAAG,CAAA;IACxE,CAAC;IAES,4BAAO,GAAjB,UAAkB,MAA0B;QAC1C,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,UAAC,OAAe,EAAE,OAAkB,IAAK,OAAA,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAhC,CAAgC,EAAE,EAAE,CAAC,CAAA;IAC/G,CAAC;IACH,iBAAC;AAAD,CAAC,AAVD,CAAyC,qBAAS,GAUjD;AAVqB,gCAAU"}

package/protocol/common/data/scale/type/SCALECompactInt.d.ts

@@ -0,0 +1,26 @@
+import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { SCALEDecodeResult } from '../SCALEDecoder';
+import { SCALEInt } from './SCALEInt';
+import { SCALEEncodeConfig, SCALEType } from './SCALEType';
+declare type Number = SCALECompactInt | SCALEInt | BigNumber | number;
+export declare class SCALECompactInt extends SCALEType {
+    readonly value: BigNumber;
+    static from(value: number | BigNumber | string): SCALECompactInt;
+    static decode(hex: string): SCALEDecodeResult<SCALECompactInt>;
+    private constructor();
+    toString(base?: number): string;
+    toNumber(): number;
+    plus(other: Number): SCALECompactInt;
+    minus(other: Number): SCALECompactInt;
+    multiply(other: Number): SCALECompactInt;
+    divide(other: Number): SCALECompactInt;
+    lt(other: Number): boolean;
+    lte(other: Number): boolean;
+    gt(other: Number): boolean;
+    gte(other: Number): boolean;
+    eq(other: Number): boolean;
+    protected _encode(config?: SCALEEncodeConfig): string;
+    private applyOperation;
+    private performOperation;
+}
+export {};