@airgap/substrate 0.13.7-beta.11

package/index.d.ts

@@ -0,0 +1,18 @@
+import { SubstrateAddress } from './protocol/common/data/account/SubstrateAddress';
+import { SubstrateElectionStatus } from './protocol/common/data/staking/SubstrateEraElectionStatus';
+import { SubstrateNominationStatus } from './protocol/common/data/staking/SubstrateNominationStatus';
+import { SubstrateNominatorDetails, SubstrateStakingDetails } from './protocol/common/data/staking/SubstrateNominatorDetails';
+import { SubstratePayee } from './protocol/common/data/staking/SubstratePayee';
+import { SubstrateStakingActionType } from './protocol/common/data/staking/SubstrateStakingActionType';
+import { SubstrateValidatorDetails } from './protocol/common/data/staking/SubstrateValidatorDetails';
+import { SubstrateTransaction } from './protocol/common/data/transaction/SubstrateTransaction';
+import { SubstrateNodeClient } from './protocol/common/node/SubstrateNodeClient';
+import { SubstrateCryptoClient } from './protocol/SubstrateCryptoClient';
+import { SubstrateDelegateProtocol } from './protocol/SubstrateDelegateProtocol';
+import { SubstrateNetwork } from './protocol/SubstrateNetwork';
+import { SubstrateProtocol } from './protocol/SubstrateProtocol';
+import { SubstrateProtocolConfig, SubstrateProtocolNetwork, SubstrateProtocolNetworkExtras, SubstrateProtocolOptions } from './protocol/SubstrateProtocolOptions';
+import { SignedSubstrateTransaction } from './types/signed-transaction-substrate';
+import { RawSubstrateTransaction } from './types/transaction-substrate';
+import { UnsignedSubstrateTransaction } from './types/unsigned-transaction-substrate';
+export { SubstrateProtocol, SubstrateDelegateProtocol, SubstrateNetwork, SubstratePayee, SubstrateCryptoClient, SubstrateProtocolNetworkExtras, SubstrateProtocolConfig, SubstrateProtocolNetwork, SubstrateProtocolOptions, SubstrateNodeClient, SubstrateElectionStatus, SubstrateNominationStatus, SubstrateNominatorDetails, SubstrateStakingDetails, SubstrateStakingActionType, SubstrateValidatorDetails, SubstrateTransaction, SubstrateAddress, RawSubstrateTransaction, UnsignedSubstrateTransaction, SignedSubstrateTransaction };

package/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstrateAddress = exports.SubstrateTransaction = exports.SubstrateStakingActionType = exports.SubstrateNominationStatus = exports.SubstrateElectionStatus = exports.SubstrateNodeClient = exports.SubstrateProtocolOptions = exports.SubstrateProtocolNetwork = exports.SubstrateProtocolConfig = exports.SubstrateProtocolNetworkExtras = exports.SubstrateCryptoClient = exports.SubstratePayee = exports.SubstrateNetwork = exports.SubstrateDelegateProtocol = exports.SubstrateProtocol = void 0;
+var SubstrateAddress_1 = require("./protocol/common/data/account/SubstrateAddress");
+Object.defineProperty(exports, "SubstrateAddress", { enumerable: true, get: function () { return SubstrateAddress_1.SubstrateAddress; } });
+var SubstrateEraElectionStatus_1 = require("./protocol/common/data/staking/SubstrateEraElectionStatus");
+Object.defineProperty(exports, "SubstrateElectionStatus", { enumerable: true, get: function () { return SubstrateEraElectionStatus_1.SubstrateElectionStatus; } });
+var SubstrateNominationStatus_1 = require("./protocol/common/data/staking/SubstrateNominationStatus");
+Object.defineProperty(exports, "SubstrateNominationStatus", { enumerable: true, get: function () { return SubstrateNominationStatus_1.SubstrateNominationStatus; } });
+var SubstratePayee_1 = require("./protocol/common/data/staking/SubstratePayee");
+Object.defineProperty(exports, "SubstratePayee", { enumerable: true, get: function () { return SubstratePayee_1.SubstratePayee; } });
+var SubstrateStakingActionType_1 = require("./protocol/common/data/staking/SubstrateStakingActionType");
+Object.defineProperty(exports, "SubstrateStakingActionType", { enumerable: true, get: function () { return SubstrateStakingActionType_1.SubstrateStakingActionType; } });
+var SubstrateTransaction_1 = require("./protocol/common/data/transaction/SubstrateTransaction");
+Object.defineProperty(exports, "SubstrateTransaction", { enumerable: true, get: function () { return SubstrateTransaction_1.SubstrateTransaction; } });
+var SubstrateNodeClient_1 = require("./protocol/common/node/SubstrateNodeClient");
+Object.defineProperty(exports, "SubstrateNodeClient", { enumerable: true, get: function () { return SubstrateNodeClient_1.SubstrateNodeClient; } });
+var SubstrateCryptoClient_1 = require("./protocol/SubstrateCryptoClient");
+Object.defineProperty(exports, "SubstrateCryptoClient", { enumerable: true, get: function () { return SubstrateCryptoClient_1.SubstrateCryptoClient; } });
+var SubstrateDelegateProtocol_1 = require("./protocol/SubstrateDelegateProtocol");
+Object.defineProperty(exports, "SubstrateDelegateProtocol", { enumerable: true, get: function () { return SubstrateDelegateProtocol_1.SubstrateDelegateProtocol; } });
+var SubstrateNetwork_1 = require("./protocol/SubstrateNetwork");
+Object.defineProperty(exports, "SubstrateNetwork", { enumerable: true, get: function () { return SubstrateNetwork_1.SubstrateNetwork; } });
+var SubstrateProtocol_1 = require("./protocol/SubstrateProtocol");
+Object.defineProperty(exports, "SubstrateProtocol", { enumerable: true, get: function () { return SubstrateProtocol_1.SubstrateProtocol; } });
+var SubstrateProtocolOptions_1 = require("./protocol/SubstrateProtocolOptions");
+Object.defineProperty(exports, "SubstrateProtocolConfig", { enumerable: true, get: function () { return SubstrateProtocolOptions_1.SubstrateProtocolConfig; } });
+Object.defineProperty(exports, "SubstrateProtocolNetwork", { enumerable: true, get: function () { return SubstrateProtocolOptions_1.SubstrateProtocolNetwork; } });
+Object.defineProperty(exports, "SubstrateProtocolNetworkExtras", { enumerable: true, get: function () { return SubstrateProtocolOptions_1.SubstrateProtocolNetworkExtras; } });
+Object.defineProperty(exports, "SubstrateProtocolOptions", { enumerable: true, get: function () { return SubstrateProtocolOptions_1.SubstrateProtocolOptions; } });
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oFAAkF;AAyChF,iGAzCO,mCAAgB,OAyCP;AAxClB,wGAAmG;AAiCjG,wGAjCO,oDAAuB,OAiCP;AAhCzB,sGAAoG;AAiClG,0GAjCO,qDAAyB,OAiCP;AA/B3B,gFAA8E;AAuB5E,+FAvBO,+BAAc,OAuBP;AAtBhB,wGAAsG;AAiCpG,2GAjCO,uDAA0B,OAiCP;AA/B5B,gGAA8F;AAiC5F,qGAjCO,2CAAoB,OAiCP;AAhCtB,kFAAgF;AAyB9E,oGAzBO,yCAAmB,OAyBP;AAxBrB,0EAAwE;AAmBtE,sGAnBO,6CAAqB,OAmBP;AAlBvB,kFAAgF;AAe9E,0GAfO,qDAAyB,OAeP;AAd3B,gEAA8D;AAe5D,iGAfO,mCAAgB,OAeP;AAdlB,kEAAgE;AAY9D,kGAZO,qCAAiB,OAYP;AAXnB,gFAK4C;AAY1C,wGAhBA,kDAAuB,OAgBA;AACvB,yGAhBA,mDAAwB,OAgBA;AAFxB,+GAbA,yDAA8B,OAaA;AAG9B,yGAfA,mDAAwB,OAeA"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@airgap/substrate",
+  "version": "0.13.7-beta.11",
+  "description": "The @airgap/substrate is a Substrate base implementation of the ICoinProtocol interface from @airgap/coinlib-core.",
+  "keywords": [
+    "airgap",
+    "blockchain",
+    "crypto",
+    "substrate",
+    "polkadot",
+    "kusama"
+  ],
+  "license": "MIT",
+  "homepage": "https://www.airgap.it",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/airgap-it/airgap-coin-lib"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && node scripts/node-module-es-module-interop.js && tsc && node scripts/copy-files-after-build.js && node scripts/make-ts-declaration-files-backwards-compatible.js",
+    "build-scripts": "tsc scripts/*.ts",
+    "lint": "tslint -c ./tslint.json --project ./tsconfig.json --format stylish --fix",
+    "lint:prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint-ci": "tslint -t json -o ../../lint-reports/substrate.json --project . || true",
+    "lint-ci:prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --list-different",
+    "test": "",
+    "test-ci": "nyc --reporter=lcov npm test",
+    "test-legacy": "",
+    "browserify": "browserify ./dist/index.js -p realpathify -s airgapCoinLibSubstrate > ./dist/airgap-coinlib-substrate.min.js"
+  },
+  "author": "Papers GmbH <contact@papers.ch> (https://papers.ch)",
+  "dependencies": {
+    "@polkadot/util": "2.0.1",
+    "@polkadot/wasm-crypto": "0.20.1"
+  },
+  "peerDependencies": {
+    "@airgap/coinlib-core": "^0.13.7-beta.0"
+  },
+  "localDependencies": {},
+  "nyc": {
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "test/**/*.spec.ts"
+    ],
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "text",
+      "text-summary"
+    ],
+    "report-dir": "../../coverage/substrate",
+    "sourceMap": true,
+    "instrument": true
+  },
+  "gitHead": "8e8feb6788204501b7173aa825f5456c2a5f185b"
+}

package/protocol/SubstrateCryptoClient.d.ts

@@ -0,0 +1,9 @@
+import { Sr25519CryptoClient } from '@airgap/coinlib-core/protocols/Sr25519CryptoClient';
+export declare class SubstrateCryptoClient extends Sr25519CryptoClient {
+    constructor();
+    signMessage(message: string, keypair: {
+        publicKey: string;
+        privateKey: string;
+    }): Promise<string>;
+    verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
+}

package/protocol/SubstrateCryptoClient.js

@@ -0,0 +1,98 @@
+"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 __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstrateCryptoClient = void 0;
+var util_1 = require("@polkadot/util");
+var wasm_crypto_1 = require("@polkadot/wasm-crypto");
+var Sr25519CryptoClient_1 = require("@airgap/coinlib-core/protocols/Sr25519CryptoClient");
+var SubstrateCryptoClient = /** @class */ (function (_super) {
+    __extends(SubstrateCryptoClient, _super);
+    function SubstrateCryptoClient() {
+        return _super.call(this) || this;
+    }
+    SubstrateCryptoClient.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var privateKeyBuffer, publicKeyBuffer, messageU8a;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wasm_crypto_1.waitReady()];
+                    case 1:
+                        _a.sent();
+                        privateKeyBuffer = Buffer.from(keypair.privateKey, 'hex');
+                        publicKeyBuffer = Buffer.from(keypair.publicKey, 'hex');
+                        util_1.assert((publicKeyBuffer === null || publicKeyBuffer === void 0 ? void 0 : publicKeyBuffer.length) === 32, 'Expected a valid publicKey, 32-bytes');
+                        util_1.assert(privateKeyBuffer.length === 64, 'Expected a valid secretKey, 64-bytes');
+                        messageU8a = util_1.u8aToU8a(message);
+                        return [2 /*return*/, "0x" + Buffer.from(wasm_crypto_1.sr25519Sign(publicKeyBuffer, privateKeyBuffer, messageU8a)).toString('hex')];
+                }
+            });
+        });
+    };
+    SubstrateCryptoClient.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messageU8a, publicKeyU8a, signatureU8a;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wasm_crypto_1.waitReady()];
+                    case 1:
+                        _a.sent();
+                        messageU8a = util_1.u8aToU8a(message);
+                        publicKeyU8a = util_1.u8aToU8a(Buffer.from(publicKey, 'hex'));
+                        signatureU8a = util_1.u8aToU8a(signature);
+                        return [2 /*return*/, wasm_crypto_1.sr25519Verify(signatureU8a, messageU8a, publicKeyU8a)];
+                }
+            });
+        });
+    };
+    return SubstrateCryptoClient;
+}(Sr25519CryptoClient_1.Sr25519CryptoClient));
+exports.SubstrateCryptoClient = SubstrateCryptoClient;
+//# sourceMappingURL=SubstrateCryptoClient.js.map

package/protocol/SubstrateCryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubstrateCryptoClient.js","sourceRoot":"","sources":["../../src/protocol/SubstrateCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAiD;AACjD,qDAA6E;AAE7E,0FAAwF;AAExF;IAA2C,yCAAmB;IAC5D;eACE,iBAAO;IACT,CAAC;IAEY,2CAAW,GAAxB,UAAyB,OAAe,EAAE,OAAkD;;;;;4BAC1F,qBAAM,uBAAS,EAAE,EAAA;;wBAAjB,SAAiB,CAAA;wBAEX,gBAAgB,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;wBACzD,eAAe,GAAW,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;wBACrE,aAAM,CAAC,CAAA,eAAe,aAAf,eAAe,uBAAf,eAAe,CAAE,MAAM,MAAK,EAAE,EAAE,sCAAsC,CAAC,CAAA;wBAC9E,aAAM,CAAC,gBAAgB,CAAC,MAAM,KAAK,EAAE,EAAE,sCAAsC,CAAC,CAAA;wBAExE,UAAU,GAAe,eAAQ,CAAC,OAAO,CAAC,CAAA;wBAEhD,sBAAO,OAAK,MAAM,CAAC,IAAI,CAAC,yBAAW,CAAC,eAAe,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAG,EAAA;;;;KACtG;IAEY,6CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;;4BAC9E,qBAAM,uBAAS,EAAE,EAAA;;wBAAjB,SAAiB,CAAA;wBAEX,UAAU,GAAe,eAAQ,CAAC,OAAO,CAAC,CAAA;wBAC1C,YAAY,GAAe,eAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAA;wBAClE,YAAY,GAAe,eAAQ,CAAC,SAAS,CAAC,CAAA;wBAEpD,sBAAO,2BAAa,CAAC,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,EAAA;;;;KAC7D;IACH,4BAAC;AAAD,CAAC,AA3BD,CAA2C,yCAAmB,GA2B7D;AA3BY,sDAAqB"}

package/protocol/SubstrateDelegateProtocol.d.ts

@@ -0,0 +1,31 @@
+import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { DelegateeDetails, DelegationDetails, DelegatorDetails, ICoinDelegateProtocol } from '@airgap/coinlib-core/protocols/ICoinDelegateProtocol';
+import { RawSubstrateTransaction } from '../types/transaction-substrate';
+import { SubstratePayee } from './common/data/staking/SubstratePayee';
+import { SubstrateStakingActionType } from './common/data/staking/SubstrateStakingActionType';
+import { SubstrateNetwork } from './SubstrateNetwork';
+import { SubstrateProtocol } from './SubstrateProtocol';
+export declare abstract class SubstrateDelegateProtocol<Network extends SubstrateNetwork> extends SubstrateProtocol<Network> implements ICoinDelegateProtocol {
+    protected defaultValidator?: string;
+    getDefaultDelegatee(): Promise<string>;
+    getCurrentDelegateesForPublicKey(publicKey: string): Promise<string[]>;
+    getCurrentDelegateesForAddress(address: string): Promise<string[]>;
+    getDelegateeDetails(address: string): Promise<DelegateeDetails>;
+    isPublicKeyDelegating(publicKey: string): Promise<boolean>;
+    isAddressDelegating(address: string): Promise<boolean>;
+    getDelegatorDetailsFromPublicKey(publicKey: string): Promise<DelegatorDetails>;
+    getDelegatorDetailsFromAddress(address: string): Promise<DelegatorDetails>;
+    getDelegationDetailsFromPublicKey(publicKey: string, delegatees: string[]): Promise<DelegationDetails>;
+    getDelegationDetailsFromAddress(address: string, delegatees: string[]): Promise<DelegationDetails>;
+    prepareDelegatorActionFromPublicKey(publicKey: string, type: SubstrateStakingActionType, data?: any): Promise<RawSubstrateTransaction[]>;
+    prepareNomination(publicKey: string, tip: string | number | BigNumber, targets: string[] | string, controller?: string, value?: string | number | BigNumber, payee?: string | SubstratePayee): Promise<RawSubstrateTransaction[]>;
+    prepareRebondNominate(publicKey: string, tip: string | number | BigNumber, targets: string[] | string, value: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareScheduleUndelegate(publicKey: string, tip: string | number | BigNumber, value?: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareChangeValidator(publicKey: string, tip: string | number | BigNumber, targets: string[] | string): Promise<RawSubstrateTransaction[]>;
+    prepareUnbond(publicKey: string, tip: string | number | BigNumber, value: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareRebond(publicKey: string, tip: string | number | BigNumber, value: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareBondExtra(publicKey: string, tip: string | number | BigNumber, value: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareRebondExtra(publicKey: string, tip: string | number | BigNumber, value: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    prepareWithdrawUnbonded(publicKey: string, tip: string | number | BigNumber): Promise<RawSubstrateTransaction[]>;
+    estimateMaxDelegationValueFromAddress(address: string): Promise<string>;
+}