@ledgerhq/coin-polkadot 0.0.2

package/lib/bridge.integration.test.js

@@ -0,0 +1,795 @@
+"use strict";
+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 __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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, 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));
+};
+exports.__esModule = true;
+exports.dataset = void 0;
+var api_1 = require("./api");
+var bignumber_js_1 = require("bignumber.js");
+var logic_1 = require("./logic");
+var errors_1 = require("@ledgerhq/errors");
+var errors_2 = require("./errors");
+var transaction_1 = require("./transaction");
+var ACCOUNT_SAME_STASHCONTROLLER = "12YA86tRQhHgwU3SSj56aesUKB7GKvdnZTTTXRop4vd3YgDV";
+var ACCOUNT_STASH = "13jAJfhpFkRZj1TSSdFopaiFeKnof2q7g4GNdcxcg8Lvx6QN";
+var ACCOUNT_CONTROLLER = "15oodc5d8DWJodZhTD6qsxxSQRYWhdkWCrwqNHajDirXRrAD";
+var ACCOUNT_EMPTY = "111111111111111111111111111111111HC1";
+var ACCOUNT_WITH_NO_OPERATION = "12EsPA79dvhtjp1bYvCiEWPsQmmdKGss44GzE3CT9tTo9g4Q";
+var polkadot = {
+    FIXME_ignoreAccountFields: [
+        "polkadotResources.unlockings",
+        "polkadotResources.nominations",
+        "polkadotResources.unlockedBalance", // It moved when an unbond is finished
+    ],
+    scanAccounts: [
+        {
+            name: "polkadot seed 1",
+            apdus: "\n        => 90010000142c00008062010080000000800000000000000000\n        <= c71b1e00ca34fdd14ea065917a67168675828927e3adc3b68f444bf85b4d24be3135573461755239707652335a5765616f50516f4562616d54535557347571335072515369564a4e4e7953385868314e9000\n        => 90010000142c00008062010080000000800000008000000080\n        <= 845175a888f0ced372bd352d59cb51242dff8438c3dd12a703835c25bdfa3f9231337a565838337a74575939446d69757446525738374262676b627631517031666366706f4a6964626448776b3335649000\n        => 90010000142c00008062010080010000800000008000000080\n        <= 3a521fa830998568da9c205c987dcd157a78b2bd30ece3d1b6c32213986864ca31324b5542335272346163346469354a47707a545935474e516b44564e6b50556b636a324d4746546d7a617a4d5364739000\n        => 90010000142c00008062010080020000800000008000000080\n        <= 7e52138bf614dddff1116623b027ea92d6015d8fe741575b78ac7773545066bd31337264523573727657463533566b4e654a757a35576b476b4736465358515141375a423551424769673441544373399000\n        => 90010000142c00008062010080030000800000008000000080\n        <= dfd77108b64b8173805852f7550f1f2d6c166968d31d5c4984187c9cb1969d9331363456674b366f6f5a3466557555346946567770537558774658474c55356e5454577a4736347672447167697077689000\n        "
+        },
+    ],
+    accounts: [
+        {
+            // Account which is stash and controller
+            raw: {
+                id: "js:2:polkadot:".concat(ACCOUNT_SAME_STASHCONTROLLER, ":polkadotbip44"),
+                seedIdentifier: ACCOUNT_SAME_STASHCONTROLLER,
+                name: "Polkadot 1",
+                derivationMode: "polkadotbip44",
+                index: 0,
+                freshAddress: ACCOUNT_SAME_STASHCONTROLLER,
+                freshAddressPath: "44'/354'/0'/0'/0'",
+                freshAddresses: [],
+                blockHeight: 0,
+                operations: [],
+                pendingOperations: [],
+                currencyId: "polkadot",
+                unitMagnitude: 10,
+                lastSyncDate: "",
+                balance: "21000310"
+            },
+            transactions: [
+                {
+                    name: "recipient and sender must not be the same",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "100000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        amount: new bignumber_js_1.BigNumber("100000000"),
+                        errors: {
+                            recipient: new errors_1.InvalidAddressBecauseDestinationIsAlsoSource()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "Not a valid address",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "ewrererewrew",
+                        amount: "100000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            recipient: new errors_1.InvalidAddress()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "Amount Required",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_CONTROLLER,
+                        amount: "0",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.AmountRequired()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "Not enough balance",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_CONTROLLER,
+                        amount: "1000000000000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalance()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "Not created account and deposit not existing",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_WITH_NO_OPERATION,
+                        amount: "1000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalanceBecauseDestinationNotCreated()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "New account and suffisent deposit",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_WITH_NO_OPERATION,
+                        amount: "10000000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        amount: new bignumber_js_1.BigNumber("10000000000"),
+                        errors: {},
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "nominate without true validator",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "0",
+                        mode: "nominate",
+                        era: null,
+                        validators: [ACCOUNT_SAME_STASHCONTROLLER],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotNotValidator()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "nominate is empty",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "0",
+                        mode: "nominate",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotValidatorsRequired()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "bond extra - not enough spendable",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "2000000000000000000",
+                        mode: "bond",
+                        era: null,
+                        validators: null,
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalance()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[Bond] New controller and suffisent deposit",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_EMPTY,
+                        amount: "10000000000",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        amount: new bignumber_js_1.BigNumber("10000000000"),
+                        errors: {},
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[unbond] no amount",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "0",
+                        mode: "unbond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.AmountRequired()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[unbond] not enough locked balance",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "2000000000000000",
+                        mode: "unbond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalance()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[rebond] no amount",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "0",
+                        mode: "rebond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.AmountRequired()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[unbond] use all amount",
+                    transaction: function (t) { return (__assign(__assign({}, t), { useAllAmount: true, mode: "unbond" })); },
+                    expectedStatus: function (a) {
+                        var _a;
+                        return ({
+                            errors: {},
+                            warnings: {},
+                            amount: (_a = a.polkadotResources) === null || _a === void 0 ? void 0 : _a.lockedBalance.minus(a.polkadotResources.unlockingBalance)
+                        });
+                    }
+                },
+                {
+                    name: "[rebond] use all amount",
+                    transaction: function (t) { return (__assign(__assign({}, t), { useAllAmount: true, mode: "rebond" })); },
+                    expectedStatus: function (a) {
+                        var _a;
+                        return ({
+                            errors: {},
+                            warnings: {},
+                            amount: (_a = a.polkadotResources) === null || _a === void 0 ? void 0 : _a.unlockingBalance
+                        });
+                    }
+                },
+            ]
+        },
+        {
+            raw: {
+                id: "js:2:polkadot:".concat(ACCOUNT_STASH, ":polkadotbip44"),
+                seedIdentifier: ACCOUNT_STASH,
+                name: "Polkadot 2",
+                derivationMode: "polkadotbip44",
+                index: 0,
+                freshAddress: ACCOUNT_STASH,
+                freshAddressPath: "44'/354'/2'/0'/0'",
+                freshAddresses: [],
+                blockHeight: 0,
+                operations: [],
+                pendingOperations: [],
+                currencyId: "polkadot",
+                unitMagnitude: 10,
+                lastSyncDate: "",
+                balance: "11000000000"
+            },
+            transactions: [
+                {
+                    name: "[send] use all amount - should warn all funds",
+                    transaction: function (t) { return (__assign(__assign({}, t), { useAllAmount: true, mode: "send", recipient: ACCOUNT_SAME_STASHCONTROLLER })); },
+                    expectedStatus: function (account) { return ({
+                        errors: {},
+                        warnings: {
+                            amount: new errors_2.PolkadotAllFundsWarning()
+                        },
+                        totalSpent: account.spendableBalance
+                    }); }
+                },
+                {
+                    name: "stash can't nominate",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "0",
+                        mode: "nominate",
+                        era: null,
+                        validators: [ACCOUNT_SAME_STASHCONTROLLER],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotUnauthorizedOperation()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[chill] unauthorized",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "1000",
+                        mode: "chill",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotUnauthorizedOperation()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[rebond] unauthorized",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "1000",
+                        mode: "rebond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotUnauthorizedOperation()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[withdrawUnbonded] unauthorized",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "1000",
+                        mode: "withdrawUnbonded",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            staking: new errors_2.PolkadotUnauthorizedOperation()
+                        },
+                        warnings: {}
+                    }
+                },
+            ]
+        },
+        // TODO: Write a setController test
+        {
+            raw: {
+                id: "js:2:polkadot:".concat(ACCOUNT_CONTROLLER, ":polkadotbip44"),
+                seedIdentifier: ACCOUNT_CONTROLLER,
+                name: "Polkadot 3",
+                derivationMode: "polkadotbip44",
+                index: 0,
+                freshAddress: ACCOUNT_CONTROLLER,
+                freshAddressPath: "44'/354'/3'/0'/0'",
+                freshAddresses: [],
+                blockHeight: 0,
+                operations: [],
+                pendingOperations: [],
+                currencyId: "polkadot",
+                unitMagnitude: 10,
+                lastSyncDate: "",
+                balance: "11000000000"
+            },
+            transactions: [
+                {
+                    name: "[send] Not enough balance",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "12000000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalance()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[send] Do Max Send Instead error",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "5000000000",
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_2.PolkadotDoMaxSendInstead()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[send] use all amount no warn",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_SAME_STASHCONTROLLER,
+                        amount: "0",
+                        useAllAmount: true,
+                        mode: "send",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {},
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[bond] no recipient",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "0",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            recipient: new errors_1.RecipientRequired()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[bond] recipient with invalid address",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "not a valid address",
+                        amount: "0",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            recipient: new errors_1.InvalidAddress()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[bond] is already controller",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_CONTROLLER,
+                        amount: "100000000",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            recipient: new errors_2.PolkadotUnauthorizedOperation("Recipient is already a controller")
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[bond] not minimum amount",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_CONTROLLER,
+                        amount: "1000000",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_2.PolkadotBondMinimumAmount()
+                        },
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[bond] success",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: ACCOUNT_CONTROLLER,
+                        amount: "10000000000",
+                        mode: "bond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {},
+                        warnings: {}
+                    }
+                },
+                {
+                    name: "[unbond] haveEnoughLockedBalance",
+                    transaction: (0, transaction_1.fromTransactionRaw)({
+                        family: "polkadot",
+                        recipient: "",
+                        amount: "100000",
+                        mode: "unbond",
+                        era: null,
+                        validators: [],
+                        fees: null,
+                        rewardDestination: null,
+                        numSlashingSpans: 0
+                    }),
+                    expectedStatus: {
+                        errors: {
+                            amount: new errors_1.NotEnoughBalance(),
+                            staking: new errors_2.PolkadotUnauthorizedOperation()
+                        },
+                        warnings: {}
+                    }
+                },
+            ]
+        },
+    ]
+};
+exports.dataset = {
+    implementations: ["js"],
+    currencies: {
+        polkadot: polkadot
+    }
+};
+// Disconnect all api clients that could be open.
+afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, api_1.disconnect)()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+describe("canUnbond", function () {
+    test("can unbond", function () {
+        var account = {
+            polkadotResources: {
+                controller: "",
+                stash: "",
+                nonce: 0,
+                numSlashingSpans: 0,
+                lockedBalance: new bignumber_js_1.BigNumber(10000),
+                unlockedBalance: new bignumber_js_1.BigNumber(0),
+                unlockingBalance: new bignumber_js_1.BigNumber(0),
+                nominations: [],
+                unlockings: __spreadArray([], __read(Array(logic_1.MAX_UNLOCKINGS - 1).map(function () { return ({
+                    amount: new bignumber_js_1.BigNumber(100000),
+                    completionDate: new Date()
+                }); })), false)
+            }
+        };
+        expect((0, logic_1.canUnbond)(account)).toBeTruthy();
+    });
+    test("can't unbond because unlockings is too much", function () {
+        var account = {
+            polkadotResources: {
+                controller: "",
+                stash: "",
+                nonce: 0,
+                numSlashingSpans: 0,
+                lockedBalance: new bignumber_js_1.BigNumber(1000000),
+                unlockedBalance: new bignumber_js_1.BigNumber(0),
+                unlockingBalance: new bignumber_js_1.BigNumber(0),
+                nominations: [],
+                unlockings: __spreadArray([], __read(Array(logic_1.MAX_UNLOCKINGS).map(function () { return ({
+                    amount: new bignumber_js_1.BigNumber(100000),
+                    completionDate: new Date()
+                }); })), false)
+            }
+        };
+        expect((0, logic_1.canUnbond)(account)).toBeFalsy();
+    });
+    test("can't unbond because not enough lockedBalance", function () {
+        var account = {
+            polkadotResources: {
+                controller: "",
+                stash: "",
+                nonce: 0,
+                numSlashingSpans: 0,
+                lockedBalance: new bignumber_js_1.BigNumber(100),
+                unlockedBalance: new bignumber_js_1.BigNumber(0),
+                unlockingBalance: new bignumber_js_1.BigNumber(100),
+                nominations: [],
+                unlockings: __spreadArray([], __read(Array(logic_1.MAX_UNLOCKINGS).map(function () { return ({
+                    amount: new bignumber_js_1.BigNumber(100000),
+                    completionDate: new Date()
+                }); })), false)
+            }
+        };
+        expect((0, logic_1.canUnbond)(account)).toBeFalsy();
+    });
+});
+//# sourceMappingURL=bridge.integration.test.js.map