@airgap/substrate 0.13.11-beta.1 → 0.13.11-beta.3

package/v1/data/transaction/method/SubstrateTransactionMethod.d.ts

@@ -0,0 +1,18 @@
+import { AirGapTransaction } from '@airgap/module-kit';
+import { SubstrateProtocolConfiguration } from '../../../types/configuration';
+import { SCALEDecodeResult } from '../../scale/SCALEDecoder';
+import { SCALEClass } from '../../scale/type/SCALEClass';
+import { SCALEInt } from '../../scale/type/SCALEInt';
+import { SCALEType } from '../../scale/type/SCALEType';
+import { SubstrateTransactionType } from '../SubstrateTransaction';
+export declare class SubstrateTransactionMethod extends SCALEClass {
+    readonly moduleIndex: SCALEInt;
+    readonly callIndex: SCALEInt;
+    readonly args: [string, SCALEType][];
+    readonly toAirGapTransactionParts: () => Partial<AirGapTransaction>[];
+    static create<C extends SubstrateProtocolConfiguration>(configuration: C, type: SubstrateTransactionType<C>, moduleIndex: number, callIndex: number, args: any): SubstrateTransactionMethod;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, type: SubstrateTransactionType<C>, raw: string): SCALEDecodeResult<SubstrateTransactionMethod>;
+    protected readonly scaleFields: (SCALEType | SCALEInt)[];
+    private constructor();
+    toString(): string;
+}

package/v1/data/transaction/method/SubstrateTransactionMethod.js

@@ -0,0 +1,86 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstrateTransactionMethod = void 0;
+var SCALEDecoder_1 = require("../../scale/SCALEDecoder");
+var SCALEClass_1 = require("../../scale/type/SCALEClass");
+var SCALEInt_1 = require("../../scale/type/SCALEInt");
+var SubstrateTransactionMethodArgs_1 = require("./SubstrateTransactionMethodArgs");
+var SubstrateTransactionMethod = /** @class */ (function (_super) {
+    __extends(SubstrateTransactionMethod, _super);
+    function SubstrateTransactionMethod(moduleIndex, callIndex, args, toAirGapTransactionParts) {
+        var _this = _super.call(this) || this;
+        _this.moduleIndex = moduleIndex;
+        _this.callIndex = callIndex;
+        _this.args = args;
+        _this.toAirGapTransactionParts = toAirGapTransactionParts;
+        _this.scaleFields = __spreadArray([_this.moduleIndex, _this.callIndex], _this.args.map(function (arg) { return arg[1]; }), true);
+        return _this;
+    }
+    SubstrateTransactionMethod.create = function (configuration, type, moduleIndex, callIndex, args) {
+        var argsFactory = SubstrateTransactionMethodArgs_1.TransactionMethodArgsFactory.create(configuration, type, args);
+        return new SubstrateTransactionMethod(SCALEInt_1.SCALEInt.from(moduleIndex), SCALEInt_1.SCALEInt.from(callIndex), argsFactory.createFields(), argsFactory.createToAirGapTransactionParts());
+    };
+    SubstrateTransactionMethod.decode = function (configuration, runtimeVersion, type, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var moduleIndex = decoder.decodeNextInt(8);
+        var callIndex = decoder.decodeNextInt(8);
+        var argsDecoder = SubstrateTransactionMethodArgs_1.TransactionMethodArgsDecoder.create(configuration, type);
+        var args = decoder.decodeNextObject(function (configuration, runtimeVersion, hex) { return argsDecoder.decode(configuration, runtimeVersion, hex); });
+        return {
+            bytesDecoded: moduleIndex.bytesDecoded + callIndex.bytesDecoded + args.bytesDecoded,
+            decoded: SubstrateTransactionMethod.create(configuration, type, moduleIndex.decoded.toNumber(), callIndex.decoded.toNumber(), args.decoded)
+        };
+    };
+    SubstrateTransactionMethod.prototype.toString = function () {
+        return JSON.stringify(__assign({ moduleIndex: this.moduleIndex.toNumber(), callIndex: this.callIndex.toNumber() }, this.args.reduce(function (prev, _a) {
+            var _b;
+            var key = _a[0], value = _a[1];
+            var valueString = value.toString();
+            try {
+                valueString = JSON.parse(valueString);
+            }
+            catch (_c) { }
+            return Object.assign(prev, (_b = {},
+                _b[key] = valueString,
+                _b));
+        }, {})), null, 2);
+    };
+    return SubstrateTransactionMethod;
+}(SCALEClass_1.SCALEClass));
+exports.SubstrateTransactionMethod = SubstrateTransactionMethod;
+//# sourceMappingURL=SubstrateTransactionMethod.js.map

package/v1/data/transaction/method/SubstrateTransactionMethod.js.map

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

package/v1/data/transaction/method/SubstrateTransactionMethodArgs.d.ts

@@ -0,0 +1,18 @@
+import { AirGapTransaction } from '@airgap/module-kit';
+import { SubstrateProtocolConfiguration } from '../../../types/configuration';
+import { SCALEDecoder, SCALEDecodeResult } from '../../scale/SCALEDecoder';
+import { SCALEType } from '../../scale/type/SCALEType';
+import { SubstrateTransactionType } from '../SubstrateTransaction';
+export declare abstract class TransactionMethodArgsFactory<T, C extends SubstrateProtocolConfiguration> {
+    protected readonly configuration: C;
+    protected readonly args: T;
+    static create<C extends SubstrateProtocolConfiguration>(configuration: C, type: SubstrateTransactionType<C>, args: any): TransactionMethodArgsFactory<any, C>;
+    constructor(configuration: C, args: T);
+    abstract createFields(): [string, SCALEType][];
+    abstract createToAirGapTransactionParts(): () => Partial<AirGapTransaction>[];
+}
+export declare abstract class TransactionMethodArgsDecoder<T, C extends SubstrateProtocolConfiguration> {
+    static create<C extends SubstrateProtocolConfiguration>(configuration: C, type: SubstrateTransactionType<C>): TransactionMethodArgsDecoder<any, C>;
+    decode(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<T>;
+    protected abstract _decode(decoder: SCALEDecoder<C>): SCALEDecodeResult<T>;
+}

package/v1/data/transaction/method/SubstrateTransactionMethodArgs.js

@@ -0,0 +1,99 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionMethodArgsDecoder = exports.TransactionMethodArgsFactory = void 0;
+var assert_1 = require("@airgap/coinlib-core/utils/assert");
+var module_kit_1 = require("@airgap/module-kit");
+var SubstrateAddressFactory_1 = require("../../account/address/SubstrateAddressFactory");
+var SCALEDecoder_1 = require("../../scale/SCALEDecoder");
+var SCALECompactInt_1 = require("../../scale/type/SCALECompactInt");
+var TransactionMethodArgsFactory = /** @class */ (function () {
+    function TransactionMethodArgsFactory(configuration, args) {
+        this.configuration = configuration;
+        this.args = args;
+    }
+    TransactionMethodArgsFactory.create = function (configuration, type, args) {
+        switch (type) {
+            case 'transfer':
+                (0, assert_1.assertFields)(type, args, 'to', 'value');
+                return new TransferArgsFactory(configuration, args);
+            default:
+                return configuration.transaction.types[type].createArgsFactory(configuration, args);
+        }
+    };
+    return TransactionMethodArgsFactory;
+}());
+exports.TransactionMethodArgsFactory = TransactionMethodArgsFactory;
+var TransactionMethodArgsDecoder = /** @class */ (function () {
+    function TransactionMethodArgsDecoder() {
+    }
+    TransactionMethodArgsDecoder.create = function (configuration, type) {
+        switch (type) {
+            case 'transfer':
+                return new TransferArgsDecoder();
+            default:
+                return configuration.transaction.types[type].createArgsDecoder(configuration);
+        }
+    };
+    TransactionMethodArgsDecoder.prototype.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        return this._decode(decoder);
+    };
+    return TransactionMethodArgsDecoder;
+}());
+exports.TransactionMethodArgsDecoder = TransactionMethodArgsDecoder;
+var TransferArgsFactory = /** @class */ (function (_super) {
+    __extends(TransferArgsFactory, _super);
+    function TransferArgsFactory() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TransferArgsFactory.prototype.createFields = function () {
+        return [
+            ['destination', (0, SubstrateAddressFactory_1.scaleAddressFactory)(this.configuration).from(this.args.to, this.configuration)],
+            ['value', SCALECompactInt_1.SCALECompactInt.from(this.args.value)]
+        ];
+    };
+    TransferArgsFactory.prototype.createToAirGapTransactionParts = function () {
+        var _this = this;
+        return function () { return [
+            {
+                to: [(0, SubstrateAddressFactory_1.substrateAddressFactory)(_this.configuration).from(_this.args.to).asString()],
+                amount: (0, module_kit_1.newAmount)(_this.args.value.toString(), 'blockchain')
+            }
+        ]; };
+    };
+    return TransferArgsFactory;
+}(TransactionMethodArgsFactory));
+var TransferArgsDecoder = /** @class */ (function (_super) {
+    __extends(TransferArgsDecoder, _super);
+    function TransferArgsDecoder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TransferArgsDecoder.prototype._decode = function (decoder) {
+        var destination = decoder.decodeNextAccount();
+        var value = decoder.decodeNextCompactInt();
+        return {
+            bytesDecoded: destination.bytesDecoded + value.bytesDecoded,
+            decoded: {
+                to: destination.decoded.toString(),
+                value: value.decoded.value
+            }
+        };
+    };
+    return TransferArgsDecoder;
+}(TransactionMethodArgsDecoder));
+//# sourceMappingURL=SubstrateTransactionMethodArgs.js.map

package/v1/data/transaction/method/SubstrateTransactionMethodArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubstrateTransactionMethodArgs.js","sourceRoot":"","sources":["../../../../../src/v1/data/transaction/method/SubstrateTransactionMethodArgs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAEA,4DAAgE;AAChE,iDAAiE;AAIjE,yFAAmI;AACnI,yDAA0E;AAC1E,oEAAkE;AASlE;IAgBE,sCAAsC,aAAgB,EAAqB,IAAO;QAA5C,kBAAa,GAAb,aAAa,CAAG;QAAqB,SAAI,GAAJ,IAAI,CAAG;IAAG,CAAC;IAfxE,mCAAM,GAApB,UACE,aAAgB,EAChB,IAAiC,EACjC,IAAS;QAET,QAAQ,IAAI,EAAE;YACZ,KAAK,UAAU;gBACb,IAAA,qBAAY,EAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;gBAEvC,OAAO,IAAI,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAA;YACrD;gBACE,OAAO,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAA;SACtF;IACH,CAAC;IAMH,mCAAC;AAAD,CAAC,AApBD,IAoBC;AApBqB,oEAA4B;AAsBlD;IAAA;IAoBA,CAAC;IAnBe,mCAAM,GAApB,UACE,aAAgB,EAChB,IAAiC;QAEjC,QAAQ,IAAI,EAAE;YACZ,KAAK,UAAU;gBACb,OAAO,IAAI,mBAAmB,EAAE,CAAA;YAClC;gBACE,OAAO,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAA;SAChF;IACH,CAAC;IAEM,6CAAM,GAAb,UAAc,aAAgB,EAAE,cAAkC,EAAE,GAAW;QAC7E,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9B,CAAC;IAGH,mCAAC;AAAD,CAAC,AApBD,IAoBC;AApBqB,oEAA4B;AAsBlD;IAA4E,uCAAgD;IAA5H;;IAgBA,CAAC;IAfQ,0CAAY,GAAnB;QACE,OAAO;YACL,CAAC,aAAa,EAAE,IAAA,6CAAmB,EAAC,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YAC/F,CAAC,OAAO,EAAE,iCAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACjD,CAAA;IACH,CAAC;IAEM,4DAA8B,GAArC;QAAA,iBAOC;QANC,OAAO,cAAM,OAAA;YACX;gBACE,EAAE,EAAE,CAAC,IAAA,iDAAuB,EAAC,KAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC/E,MAAM,EAAE,IAAA,sBAAS,EAAC,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,YAAY,CAAC;aAC5D;SACF,EALY,CAKZ,CAAA;IACH,CAAC;IACH,0BAAC;AAAD,CAAC,AAhBD,CAA4E,4BAA4B,GAgBvG;AAED;IAA4E,uCAAgD;IAA5H;;IAaA,CAAC;IAZW,qCAAO,GAAjB,UAAkB,OAAwB;QACxC,IAAM,WAAW,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAA;QAC/C,IAAM,KAAK,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAE5C,OAAO;YACL,YAAY,EAAE,WAAW,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY;YAC3D,OAAO,EAAE;gBACP,EAAE,EAAE,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE;gBAClC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK;aAC3B;SACF,CAAA;IACH,CAAC;IACH,0BAAC;AAAD,CAAC,AAbD,CAA4E,4BAA4B,GAavG"}

package/v1/index.d.ts

@@ -0,0 +1,56 @@
+import { SubscanBlockExplorer } from './block-explorer/subscan/SubscanBlockExplorer';
+import { SubscanBlockExplorerClient } from './block-explorer/subscan/SubscanBlockExplorerClient';
+import { SubstrateBlockExplorerClient } from './block-explorer/SubstrateBlockExplorerClient';
+import { SubstrateAccountController } from './controller/account/SubstrateAccountController';
+import { SubstrateCommonAccountController } from './controller/account/SubstrateCommonAccountController';
+import { SubstrateCommonTransactionController } from './controller/transaction/SubstrateCommonTransactionController';
+import { SubstrateTransactionController, SubstrateTransactionParameters } from './controller/transaction/SubstrateTransactionController';
+import { SubstrateAccountId, SubstrateAddress } from './data/account/address/SubstrateAddress';
+import { scaleAddressFactory, substrateAddressFactory, TypedSubstrateAddress } from './data/account/address/SubstrateAddressFactory';
+import { SubstrateEthAddress } from './data/account/address/SubstrateEthAddress';
+import { SubstrateSS58Address } from './data/account/address/SubstrateSS58Address';
+import { SubstrateAccountBalance } from './data/account/SubstrateAccountBalance';
+import { SubstrateAccountInfo } from './data/account/SubstrateAccountInfo';
+import { SubstrateRegistration } from './data/account/SubstrateRegistration';
+import { SCALEDecoder, SCALEDecodeResult } from './data/scale/SCALEDecoder';
+import { SCALEAccountId } from './data/scale/type/SCALEAccountId';
+import { SCALEArray } from './data/scale/type/SCALEArray';
+import { SCALEBoolean } from './data/scale/type/SCALEBoolean';
+import { SCALEBytes } from './data/scale/type/SCALEBytes';
+import { SCALEClass } from './data/scale/type/SCALEClass';
+import { SCALECompactInt } from './data/scale/type/SCALECompactInt';
+import { SCALEData } from './data/scale/type/SCALEData';
+import { SCALEEnum } from './data/scale/type/SCALEEnum';
+import { SCALEEra } from './data/scale/type/SCALEEra';
+import { SCALEHash } from './data/scale/type/SCALEHash';
+import { SCALEInt } from './data/scale/type/SCALEInt';
+import { SCALEMultiAddress } from './data/scale/type/SCALEMultiAddress';
+import { SCALEOptional } from './data/scale/type/SCALEOptional';
+import { SCALEString } from './data/scale/type/SCALEString';
+import { SCALETuple } from './data/scale/type/SCALETuple';
+import { SCALEType } from './data/scale/type/SCALEType';
+import { SubstrateRuntimeVersion } from './data/state/SubstrateRuntimeVersion';
+import { SubstrateTransactionMethod } from './data/transaction/method/SubstrateTransactionMethod';
+import { TransactionMethodArgsDecoder, TransactionMethodArgsFactory } from './data/transaction/method/SubstrateTransactionMethodArgs';
+import { SubstrateSignature, SubstrateSignatureType } from './data/transaction/SubstrateSignature';
+import { SubstrateTransaction, SubstrateTransactionType } from './data/transaction/SubstrateTransaction';
+import { SubstrateTransactionPayload } from './data/transaction/SubstrateTransactionPayload';
+import { SubstrateCommonNodeClient } from './node/SubstrateCommonNodeClient';
+import { SubstrateNodeClient } from './node/SubstrateNodeClient';
+import { SubstrateProtocol, SubstrateProtocolImpl } from './protocol/SubstrateProtocol';
+import { substrateSignedTransactionToResponse, substrateTransactionSignRequestToUnsigned, substrateTransactionSignResponseToSigned, substrateUnsignedTransactionToRequest } from './serializer/v3/schemas/converter/transaction-converter';
+import { SubstrateTransactionSignRequest } from './serializer/v3/schemas/definitions/transaction-sign-request-substrate';
+import { SubstrateTransactionSignResponse } from './serializer/v3/schemas/definitions/transaction-sign-response-substrate';
+import { SubstrateTransactionValidator } from './serializer/v3/validators/transaction-validator';
+import { substrateValidators } from './serializer/v3/validators/validators';
+import { SubstrateAccountConfiguration, SubstrateEthAccountConfiguration, SubstrateProtocolConfiguration, SubstrateRpcConfiguration, SubstrateSS58AccountConfiguration, SubstrateTransactionConfiguration } from './types/configuration';
+import { SubstrateCryptoConfiguration } from './types/crypto';
+import { SubstrateProtocolNetwork, SubstrateProtocolOptions } from './types/protocol';
+import { SubstrateSignedTransaction, SubstrateTransactionCursor, SubstrateUnsignedTransaction } from './types/transaction';
+export { SubstrateProtocol, SubstrateProtocolImpl };
+export { SubstrateBlockExplorerClient, SubscanBlockExplorerClient, SubscanBlockExplorer };
+export { SubstrateAccountController, SubstrateCommonAccountController, SubstrateTransactionController, SubstrateTransactionParameters, SubstrateCommonTransactionController };
+export { SubstrateNodeClient, SubstrateCommonNodeClient };
+export { SubstrateAddress, SubstrateEthAddress, SubstrateSS58Address, substrateAddressFactory, scaleAddressFactory, TypedSubstrateAddress, SubstrateAccountId, SubstrateAccountBalance, SubstrateAccountInfo, SubstrateRegistration, SCALEAccountId, SCALEArray, SCALEBoolean, SCALEBytes, SCALEClass, SCALECompactInt, SCALEData, SCALEEnum, SCALEEra, SCALEHash, SCALEInt, SCALEMultiAddress, SCALEOptional, SCALEString, SCALETuple, SCALEType, SCALEDecoder, SCALEDecodeResult, SubstrateRuntimeVersion, SubstrateTransactionMethod, TransactionMethodArgsFactory as SubstrateTransactionMethodArgsFactory, TransactionMethodArgsDecoder as SubstrateTransactionMethodArgsDecoder, SubstrateSignature, SubstrateSignatureType, SubstrateTransaction, SubstrateTransactionType, SubstrateTransactionPayload };
+export { SubstrateCryptoConfiguration, SubstrateProtocolConfiguration, SubstrateAccountConfiguration, SubstrateSS58AccountConfiguration, SubstrateEthAccountConfiguration, SubstrateTransactionConfiguration, SubstrateRpcConfiguration, SubstrateProtocolNetwork, SubstrateProtocolOptions, SubstrateUnsignedTransaction, SubstrateSignedTransaction, SubstrateTransactionCursor };
+export { SubstrateTransactionSignRequest, SubstrateTransactionSignResponse, SubstrateTransactionValidator, substrateValidators, substrateUnsignedTransactionToRequest, substrateSignedTransactionToResponse, substrateTransactionSignRequestToUnsigned, substrateTransactionSignResponseToSigned };

package/v1/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substrateTransactionSignResponseToSigned = exports.substrateTransactionSignRequestToUnsigned = exports.substrateSignedTransactionToResponse = exports.substrateUnsignedTransactionToRequest = exports.substrateValidators = exports.SubstrateTransactionValidator = exports.SubstrateTransactionPayload = exports.SubstrateTransaction = exports.SubstrateSignatureType = exports.SubstrateSignature = exports.SubstrateTransactionMethodArgsDecoder = exports.SubstrateTransactionMethodArgsFactory = exports.SubstrateTransactionMethod = exports.SCALEDecoder = exports.SCALEType = exports.SCALETuple = exports.SCALEString = exports.SCALEOptional = exports.SCALEMultiAddress = exports.SCALEInt = exports.SCALEHash = exports.SCALEEra = exports.SCALEEnum = exports.SCALEData = exports.SCALECompactInt = exports.SCALEClass = exports.SCALEBytes = exports.SCALEBoolean = exports.SCALEArray = exports.SCALEAccountId = exports.SubstrateRegistration = exports.SubstrateAccountInfo = exports.scaleAddressFactory = exports.substrateAddressFactory = exports.SubstrateSS58Address = exports.SubstrateEthAddress = exports.SubstrateCommonNodeClient = exports.SubstrateCommonTransactionController = exports.SubstrateCommonAccountController = exports.SubscanBlockExplorer = exports.SubscanBlockExplorerClient = exports.SubstrateProtocolImpl = void 0;
+var SubscanBlockExplorer_1 = require("./block-explorer/subscan/SubscanBlockExplorer");
+Object.defineProperty(exports, "SubscanBlockExplorer", { enumerable: true, get: function () { return SubscanBlockExplorer_1.SubscanBlockExplorer; } });
+var SubscanBlockExplorerClient_1 = require("./block-explorer/subscan/SubscanBlockExplorerClient");
+Object.defineProperty(exports, "SubscanBlockExplorerClient", { enumerable: true, get: function () { return SubscanBlockExplorerClient_1.SubscanBlockExplorerClient; } });
+var SubstrateCommonAccountController_1 = require("./controller/account/SubstrateCommonAccountController");
+Object.defineProperty(exports, "SubstrateCommonAccountController", { enumerable: true, get: function () { return SubstrateCommonAccountController_1.SubstrateCommonAccountController; } });
+var SubstrateCommonTransactionController_1 = require("./controller/transaction/SubstrateCommonTransactionController");
+Object.defineProperty(exports, "SubstrateCommonTransactionController", { enumerable: true, get: function () { return SubstrateCommonTransactionController_1.SubstrateCommonTransactionController; } });
+var SubstrateAddressFactory_1 = require("./data/account/address/SubstrateAddressFactory");
+Object.defineProperty(exports, "scaleAddressFactory", { enumerable: true, get: function () { return SubstrateAddressFactory_1.scaleAddressFactory; } });
+Object.defineProperty(exports, "substrateAddressFactory", { enumerable: true, get: function () { return SubstrateAddressFactory_1.substrateAddressFactory; } });
+var SubstrateEthAddress_1 = require("./data/account/address/SubstrateEthAddress");
+Object.defineProperty(exports, "SubstrateEthAddress", { enumerable: true, get: function () { return SubstrateEthAddress_1.SubstrateEthAddress; } });
+var SubstrateSS58Address_1 = require("./data/account/address/SubstrateSS58Address");
+Object.defineProperty(exports, "SubstrateSS58Address", { enumerable: true, get: function () { return SubstrateSS58Address_1.SubstrateSS58Address; } });
+var SubstrateAccountInfo_1 = require("./data/account/SubstrateAccountInfo");
+Object.defineProperty(exports, "SubstrateAccountInfo", { enumerable: true, get: function () { return SubstrateAccountInfo_1.SubstrateAccountInfo; } });
+var SubstrateRegistration_1 = require("./data/account/SubstrateRegistration");
+Object.defineProperty(exports, "SubstrateRegistration", { enumerable: true, get: function () { return SubstrateRegistration_1.SubstrateRegistration; } });
+var SCALEDecoder_1 = require("./data/scale/SCALEDecoder");
+Object.defineProperty(exports, "SCALEDecoder", { enumerable: true, get: function () { return SCALEDecoder_1.SCALEDecoder; } });
+var SCALEAccountId_1 = require("./data/scale/type/SCALEAccountId");
+Object.defineProperty(exports, "SCALEAccountId", { enumerable: true, get: function () { return SCALEAccountId_1.SCALEAccountId; } });
+var SCALEArray_1 = require("./data/scale/type/SCALEArray");
+Object.defineProperty(exports, "SCALEArray", { enumerable: true, get: function () { return SCALEArray_1.SCALEArray; } });
+var SCALEBoolean_1 = require("./data/scale/type/SCALEBoolean");
+Object.defineProperty(exports, "SCALEBoolean", { enumerable: true, get: function () { return SCALEBoolean_1.SCALEBoolean; } });
+var SCALEBytes_1 = require("./data/scale/type/SCALEBytes");
+Object.defineProperty(exports, "SCALEBytes", { enumerable: true, get: function () { return SCALEBytes_1.SCALEBytes; } });
+var SCALEClass_1 = require("./data/scale/type/SCALEClass");
+Object.defineProperty(exports, "SCALEClass", { enumerable: true, get: function () { return SCALEClass_1.SCALEClass; } });
+var SCALECompactInt_1 = require("./data/scale/type/SCALECompactInt");
+Object.defineProperty(exports, "SCALECompactInt", { enumerable: true, get: function () { return SCALECompactInt_1.SCALECompactInt; } });
+var SCALEData_1 = require("./data/scale/type/SCALEData");
+Object.defineProperty(exports, "SCALEData", { enumerable: true, get: function () { return SCALEData_1.SCALEData; } });
+var SCALEEnum_1 = require("./data/scale/type/SCALEEnum");
+Object.defineProperty(exports, "SCALEEnum", { enumerable: true, get: function () { return SCALEEnum_1.SCALEEnum; } });
+var SCALEEra_1 = require("./data/scale/type/SCALEEra");
+Object.defineProperty(exports, "SCALEEra", { enumerable: true, get: function () { return SCALEEra_1.SCALEEra; } });
+var SCALEHash_1 = require("./data/scale/type/SCALEHash");
+Object.defineProperty(exports, "SCALEHash", { enumerable: true, get: function () { return SCALEHash_1.SCALEHash; } });
+var SCALEInt_1 = require("./data/scale/type/SCALEInt");
+Object.defineProperty(exports, "SCALEInt", { enumerable: true, get: function () { return SCALEInt_1.SCALEInt; } });
+var SCALEMultiAddress_1 = require("./data/scale/type/SCALEMultiAddress");
+Object.defineProperty(exports, "SCALEMultiAddress", { enumerable: true, get: function () { return SCALEMultiAddress_1.SCALEMultiAddress; } });
+var SCALEOptional_1 = require("./data/scale/type/SCALEOptional");
+Object.defineProperty(exports, "SCALEOptional", { enumerable: true, get: function () { return SCALEOptional_1.SCALEOptional; } });
+var SCALEString_1 = require("./data/scale/type/SCALEString");
+Object.defineProperty(exports, "SCALEString", { enumerable: true, get: function () { return SCALEString_1.SCALEString; } });
+var SCALETuple_1 = require("./data/scale/type/SCALETuple");
+Object.defineProperty(exports, "SCALETuple", { enumerable: true, get: function () { return SCALETuple_1.SCALETuple; } });
+var SCALEType_1 = require("./data/scale/type/SCALEType");
+Object.defineProperty(exports, "SCALEType", { enumerable: true, get: function () { return SCALEType_1.SCALEType; } });
+var SubstrateTransactionMethod_1 = require("./data/transaction/method/SubstrateTransactionMethod");
+Object.defineProperty(exports, "SubstrateTransactionMethod", { enumerable: true, get: function () { return SubstrateTransactionMethod_1.SubstrateTransactionMethod; } });
+var SubstrateTransactionMethodArgs_1 = require("./data/transaction/method/SubstrateTransactionMethodArgs");
+Object.defineProperty(exports, "SubstrateTransactionMethodArgsDecoder", { enumerable: true, get: function () { return SubstrateTransactionMethodArgs_1.TransactionMethodArgsDecoder; } });
+Object.defineProperty(exports, "SubstrateTransactionMethodArgsFactory", { enumerable: true, get: function () { return SubstrateTransactionMethodArgs_1.TransactionMethodArgsFactory; } });
+var SubstrateSignature_1 = require("./data/transaction/SubstrateSignature");
+Object.defineProperty(exports, "SubstrateSignature", { enumerable: true, get: function () { return SubstrateSignature_1.SubstrateSignature; } });
+Object.defineProperty(exports, "SubstrateSignatureType", { enumerable: true, get: function () { return SubstrateSignature_1.SubstrateSignatureType; } });
+var SubstrateTransaction_1 = require("./data/transaction/SubstrateTransaction");
+Object.defineProperty(exports, "SubstrateTransaction", { enumerable: true, get: function () { return SubstrateTransaction_1.SubstrateTransaction; } });
+var SubstrateTransactionPayload_1 = require("./data/transaction/SubstrateTransactionPayload");
+Object.defineProperty(exports, "SubstrateTransactionPayload", { enumerable: true, get: function () { return SubstrateTransactionPayload_1.SubstrateTransactionPayload; } });
+var SubstrateCommonNodeClient_1 = require("./node/SubstrateCommonNodeClient");
+Object.defineProperty(exports, "SubstrateCommonNodeClient", { enumerable: true, get: function () { return SubstrateCommonNodeClient_1.SubstrateCommonNodeClient; } });
+var SubstrateProtocol_1 = require("./protocol/SubstrateProtocol");
+Object.defineProperty(exports, "SubstrateProtocolImpl", { enumerable: true, get: function () { return SubstrateProtocol_1.SubstrateProtocolImpl; } });
+var transaction_converter_1 = require("./serializer/v3/schemas/converter/transaction-converter");
+Object.defineProperty(exports, "substrateSignedTransactionToResponse", { enumerable: true, get: function () { return transaction_converter_1.substrateSignedTransactionToResponse; } });
+Object.defineProperty(exports, "substrateTransactionSignRequestToUnsigned", { enumerable: true, get: function () { return transaction_converter_1.substrateTransactionSignRequestToUnsigned; } });
+Object.defineProperty(exports, "substrateTransactionSignResponseToSigned", { enumerable: true, get: function () { return transaction_converter_1.substrateTransactionSignResponseToSigned; } });
+Object.defineProperty(exports, "substrateUnsignedTransactionToRequest", { enumerable: true, get: function () { return transaction_converter_1.substrateUnsignedTransactionToRequest; } });
+var transaction_validator_1 = require("./serializer/v3/validators/transaction-validator");
+Object.defineProperty(exports, "SubstrateTransactionValidator", { enumerable: true, get: function () { return transaction_validator_1.SubstrateTransactionValidator; } });
+var validators_1 = require("./serializer/v3/validators/validators");
+Object.defineProperty(exports, "substrateValidators", { enumerable: true, get: function () { return validators_1.substrateValidators; } });
+//# sourceMappingURL=index.js.map

package/v1/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/v1/index.ts"],"names":[],"mappings":";;;AAAA,sFAAoF;AAoEjB,qGApE1D,2CAAoB,OAoE0D;AAnEvF,kGAAgG;AAmEzD,2GAnE9B,uDAA0B,OAmE8B;AAhEjE,0GAAwG;AAsEtG,iHAtEO,mEAAgC,OAsEP;AArElC,sHAAoH;AAwElH,qHAxEO,2EAAoC,OAwEP;AArEtC,0FAAoI;AAmFlI,oGAnFO,6CAAmB,OAmFP;AADnB,wGAlF4B,iDAAuB,OAkF5B;AAjFzB,kFAAgF;AA+E9E,oGA/EO,yCAAmB,OA+EP;AA9ErB,oFAAkF;AA+EhF,qGA/EO,2CAAoB,OA+EP;AA7EtB,4EAA0E;AAmFxE,qGAnFO,2CAAoB,OAmFP;AAlFtB,8EAA4E;AAmF1E,sGAnFO,6CAAqB,OAmFP;AAlFvB,0DAA2E;AAmGzE,6FAnGO,2BAAY,OAmGP;AAlGd,mEAAiE;AAkF/D,+FAlFO,+BAAc,OAkFP;AAjFhB,2DAAyD;AAkFvD,2FAlFO,uBAAU,OAkFP;AAjFZ,+DAA6D;AAkF3D,6FAlFO,2BAAY,OAkFP;AAjFd,2DAAyD;AAkFvD,2FAlFO,uBAAU,OAkFP;AAjFZ,2DAAyD;AAkFvD,2FAlFO,uBAAU,OAkFP;AAjFZ,qEAAmE;AAkFjE,gGAlFO,iCAAe,OAkFP;AAjFjB,yDAAuD;AAkFrD,0FAlFO,qBAAS,OAkFP;AAjFX,yDAAuD;AAkFrD,0FAlFO,qBAAS,OAkFP;AAjFX,uDAAqD;AAkFnD,yFAlFO,mBAAQ,OAkFP;AAjFV,yDAAuD;AAkFrD,0FAlFO,qBAAS,OAkFP;AAjFX,uDAAqD;AAkFnD,yFAlFO,mBAAQ,OAkFP;AAjFV,yEAAuE;AAkFrE,kGAlFO,qCAAiB,OAkFP;AAjFnB,iEAA+D;AAkF7D,8FAlFO,6BAAa,OAkFP;AAjFf,6DAA2D;AAkFzD,4FAlFO,yBAAW,OAkFP;AAjFb,2DAAyD;AAkFvD,2FAlFO,uBAAU,OAkFP;AAjFZ,yDAAuD;AAkFrD,0FAlFO,qBAAS,OAkFP;AAhFX,mGAAiG;AAoF/F,2GApFO,uDAA0B,OAoFP;AAnF5B,2GAAqI;AAqFnG,sHArFzB,6DAA4B,OAqFkC;AADrC,sHApFK,6DAA4B,OAoFI;AAnFvE,4EAAkG;AAqFhG,mGArFO,uCAAkB,OAqFP;AAClB,uGAtF2B,2CAAsB,OAsF3B;AArFxB,gFAAwG;AAsFtG,qGAtFO,2CAAoB,OAsFP;AArFtB,8FAA4F;AAuF1F,4GAvFO,yDAA2B,OAuFP;AAtF7B,8EAA4E;AA6C9C,0GA7CrB,qDAAyB,OA6CqB;AA3CvD,kEAAuF;AAyB3D,sGAzBA,yCAAqB,OAyBA;AAxBjD,iGAKgE;AA0G9D,qHA9GA,4DAAoC,OA8GA;AACpC,0HA9GA,iEAAyC,OA8GA;AACzC,yHA9GA,gEAAwC,OA8GA;AAHxC,sHA1GA,6DAAqC,OA0GA;AAtGvC,0FAAgG;AAoG9F,8GApGO,qDAA6B,OAoGP;AAnG/B,oEAA2E;AAoGzE,oGApGO,gCAAmB,OAoGP"}

package/v1/node/SubstrateCommonNodeClient.d.ts

@@ -0,0 +1,84 @@
+import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { Cache } from '@airgap/coinlib-core/utils/cache';
+import { TypedSubstrateAddress } from '../data/account/address/SubstrateAddressFactory';
+import { SubstrateAccountInfo } from '../data/account/SubstrateAccountInfo';
+import { SubstrateCall } from '../data/metadata/decorator/call/SubstrateCall';
+import { MetadataDecorator } from '../data/metadata/decorator/MetadataDecorator';
+import { SCALEType } from '../data/scale/type/SCALEType';
+import { SubstrateRuntimeVersion } from '../data/state/SubstrateRuntimeVersion';
+import { SubstrateTransactionType } from '../data/transaction/SubstrateTransaction';
+import { SubstrateProtocolConfiguration, SubstrateRpcConfiguration } from '../types/configuration';
+import { SubstrateNodeClient } from './SubstrateNodeClient';
+interface ConnectionConfig {
+    allowCache: boolean;
+}
+export declare class SubstrateCommonNodeClient<C extends SubstrateProtocolConfiguration> implements SubstrateNodeClient<C> {
+    protected readonly configuration: C;
+    protected readonly url: string;
+    protected metadata: MetadataDecorator | undefined;
+    protected runtimeVersion: number | undefined;
+    protected readonly lastFees: Map<SubstrateTransactionType<C>, BigNumber>;
+    protected initApiPromise: Promise<void> | null;
+    protected readonly storageEntries: Record<string, string[]>;
+    protected readonly calls: Record<string, string[]>;
+    protected readonly constants: Record<string, string[]>;
+    protected readonly callEndpoints: SubstrateCallEndpoints<C>;
+    protected readonly cache: Cache;
+    constructor(configuration: C, url: string);
+    getAccountInfo(address: TypedSubstrateAddress<C>): Promise<SubstrateAccountInfo | undefined>;
+    getExistentialDeposit(): Promise<BigNumber | undefined>;
+    getBlockTime(): Promise<BigNumber>;
+    getFirstBlockHash(): Promise<string | undefined>;
+    getLastBlockHash(): Promise<string | undefined>;
+    protected getBlockHash(blockNumber?: number): Promise<string | undefined>;
+    getCurrentHeight(): Promise<BigNumber>;
+    getRuntimeVersion(): Promise<SubstrateRuntimeVersion | undefined>;
+    getTransferFeeEstimate(transaction: string | Uint8Array): Promise<BigNumber | undefined>;
+    saveLastFee(type: SubstrateTransactionType<C>, fee: BigNumber): void;
+    getSavedLastFee(type: SubstrateTransactionType<C>, defaultValue: 'undefined' | 'largest'): BigNumber | undefined;
+    getTransactionMetadata(type: SubstrateTransactionType<C>): Promise<SubstrateCall>;
+    submitTransaction(encoded: string): Promise<string>;
+    protected fromStorage<Module extends SubstrateStorageModuleName<C>, Entry extends SubstrateStorageEntryName<C, Module>>(moduleName: Module, entryName: Entry, ...args: SCALEType[]): Promise<string | null>;
+    protected getCall<Module extends SubstrateCallModuleName<C>, Call extends SubstrateCallName<C, Module>>(moduleName: Module, callName: Call): Promise<SubstrateCall>;
+    protected getConstant<Module extends SubstrateConstantModuleName<C>, Constant extends SubstrateConstantName<C, Module>>(moduleName: Module, constantName: Constant): Promise<string>;
+    protected initApi(): Promise<void>;
+    protected initCache(): Promise<void>;
+    protected send<T extends SubstrateRpcModuleName<C>, S extends SubstrateRpcMethodName<C, T>>(module: T, method: S, params?: string[], config?: ConnectionConfig): Promise<any>;
+    private sendRepeat;
+    protected registerCallEntrypointEntries(entries: [SubstrateTransactionType<C>, [SubstrateCallModuleName<C>, SubstrateCallName<C, any>]][]): void;
+    protected createCallEndpointEntry<Module extends SubstrateCallModuleName<C>, Call extends SubstrateCallName<C, Module>>(transactionType: SubstrateTransactionType<C>, moduleName: Module, callName: Call): [SubstrateTransactionType<C>, [SubstrateCallModuleName<C>, SubstrateCallName<C, any>]];
+    protected mergeSupportedCalls(configured: Record<string, Readonly<string[]>>, common: Record<string, Readonly<string[]>>): Record<string, string[]>;
+}
+declare const commonRpcMethods: {
+    author: readonly ["submitExtrinsic"];
+    chain: readonly ["getBlock", "getBlockHash"];
+    state: readonly ["getMetadata", "getStorage", "getRuntimeVersion"];
+    payment: readonly ["queryInfo"];
+};
+export declare type SubstrateRpcModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'methods', typeof commonRpcMethods>;
+export declare type SubstrateRpcMethodName<C extends SubstrateProtocolConfiguration, T extends SubstrateRpcModuleName<C>> = ModuleEntry<C, 'methods', typeof commonRpcMethods, T>;
+declare const commonStorageEntries: {
+    System: readonly ["Account"];
+};
+declare type SubstrateStorageModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'storageEntries', typeof commonStorageEntries>;
+declare type SubstrateStorageEntryName<C extends SubstrateProtocolConfiguration, T extends SubstrateStorageModuleName<C>> = ModuleEntry<C, 'storageEntries', typeof commonStorageEntries, T>;
+declare const commonCalls: {
+    Balances: readonly ["transfer"];
+};
+declare type SubstrateCallModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'calls', typeof commonCalls>;
+declare type SubstrateCallName<C extends SubstrateProtocolConfiguration, T extends SubstrateCallModuleName<C>> = ModuleEntry<C, 'calls', typeof commonCalls, T>;
+declare const commonConstants: {
+    Balances: readonly ["ExistentialDeposit"];
+};
+declare type SubstrateConstantModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'constants', typeof commonConstants>;
+declare type SubstrateConstantName<C extends SubstrateProtocolConfiguration, T extends SubstrateConstantModuleName<C>> = ModuleEntry<C, 'constants', typeof commonConstants, T>;
+declare type SubstrateCallEndpoints<C extends SubstrateProtocolConfiguration> = Map<SubstrateTransactionType<C>, [
+    SubstrateCallModuleName<C>,
+    SubstrateCallName<C, any>
+]>;
+declare type ModuleName<C extends SubstrateProtocolConfiguration, Type extends keyof SubstrateRpcConfiguration, Defaults extends Object> = keyof Defaults | (C['rpc'] extends Object ? (keyof C['rpc'][Type] extends string ? keyof C['rpc'][Type] : never) : never);
+declare type ModuleEntry<C extends SubstrateProtocolConfiguration, Type extends keyof SubstrateRpcConfiguration, Defaults extends Record<string, Readonly<string[]>>, T extends ModuleName<C, Type, Defaults>> = ReadonlyEntries<T, Defaults> | (C['rpc'] extends Object ? ReadonlyEntries<T, C['rpc'][Type]> : never);
+declare type ReadonlyEntries<T, C> = T extends keyof C ? {
+    [S in T]: C[S] extends Readonly<string[]> ? C[S][number] : never;
+}[T] : never;
+export {};