@ledgerhq/coin-stacks/lib/test/bot-specs.js

Ledger Stacks Coin integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const invariant_1 = __importDefault(require("invariant"));
const devices_1 = require("@ledgerhq/devices");
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const expect_1 = __importDefault(require("expect"));
const currencies_1 = require("@ledgerhq/cryptoassets/currencies");
const specs_1 = require("@ledgerhq/coin-framework/bot/specs");
const bot_deviceActions_1 = require("./bot-deviceActions");
const MIN_SAFE = new bignumber_js_1.default(10000);
// Define account types enum if not already defined in bridge/utils
var AccountType;
(function (AccountType) {
    AccountType["Account"] = "Account";
    AccountType["TokenAccount"] = "TokenAccount";
})(AccountType || (AccountType = {}));
const stacksSpecs = {
    name: "Stacks",
    currency: (0, currencies_1.getCryptoCurrencyById)("stacks"),
    appQuery: {
        model: devices_1.DeviceModelId.nanoSP,
        appName: "Stacks",
    },
    genericDeviceAction: bot_deviceActions_1.acceptTransaction,
    // FIXME Stacks operations can take much longer to be confirmed
    // Need an evolution of the bot to tolerate unconfirmed ops and just warn maybe instead of error
    testTimeout: 25 * 60 * 1000,
    minViableAmount: MIN_SAFE,
    transactionCheck: ({ maxSpendable }) => {
        (0, invariant_1.default)(maxSpendable.gt(MIN_SAFE), "balance is too low");
    },
    mutations: [
        {
            name: "Send 50%~",
            feature: "send",
            maxRun: 1,
            transaction: ({ account, siblings, bridge }) => {
                const sibling = (0, specs_1.pickSiblings)(siblings, 2);
                const recipient = sibling.freshAddress;
                let amount = account.spendableBalance.div(1.9 + 0.2 * Math.random()).integerValue();
                if (!sibling.used && amount.lt(MIN_SAFE)) {
                    (0, invariant_1.default)(account.spendableBalance.gt(MIN_SAFE), "send is too low to activate account");
                    amount = MIN_SAFE;
                }
                const transaction = bridge.createTransaction(account);
                const updates = [{ recipient }, { amount }];
                return {
                    transaction,
                    updates,
                };
            },
            test: ({ account, accountBeforeTransaction, operation }) => {
                (0, specs_1.botTest)("account balance decreased with operation value", () => (0, expect_1.default)(account.balance.toFixed()).toBe(accountBeforeTransaction.balance.minus(operation.value).toFixed()));
            },
        },
        {
            name: "Transfer Max",
            feature: "sendMax",
            maxRun: 1,
            transaction: ({ account, siblings, bridge }) => {
                const sibling = (0, specs_1.pickSiblings)(siblings, 2);
                const recipient = sibling.freshAddress;
                const transaction = bridge.createTransaction(account);
                const updates = [{ recipient }, { useAllAmount: true }];
                return {
                    transaction,
                    updates,
                };
            },
            test: ({ account }) => {
                (0, specs_1.botTest)("account balance is 0", () => (0, expect_1.default)(account.balance.toFixed()).toBe("0"));
            },
        },
        {
            name: "Send ~50% Token",
            feature: "tokens",
            maxRun: 1,
            deviceAction: bot_deviceActions_1.acceptTokenTransfer,
            transaction: ({ account, siblings, bridge, maxSpendable }) => {
                const sibling = (0, specs_1.pickSiblings)(siblings, 2);
                const recipient = sibling.freshAddress;
                (0, invariant_1.default)(maxSpendable.gt(0), "Spendable balance is too low");
                // Find a token subaccount with positive balance
                const subAccount = account.subAccounts?.find(a => a.type === AccountType.TokenAccount && a.spendableBalance.gt(0));
                (0, invariant_1.default)(subAccount && subAccount.type === AccountType.TokenAccount, "no token subAccount found with positive balance");
                // Calculate amount to send (around 50% of available balance)
                const amount = subAccount.balance.div(1.9 + 0.2 * Math.random()).integerValue();
                return {
                    transaction: bridge.createTransaction(account),
                    updates: [
                        {
                            subAccountId: subAccount.id,
                        },
                        {
                            recipient,
                        },
                        {
                            amount,
                        },
                    ],
                };
            },
            test: ({ account, accountBeforeTransaction, transaction, status }) => {
                const subAccountId = transaction.subAccountId;
                const subAccount = account.subAccounts?.find(sa => sa.id === subAccountId);
                const subAccountBeforeTransaction = accountBeforeTransaction.subAccounts?.find(sa => sa.id === subAccountId);
                (0, specs_1.botTest)("subAccount balance decreased with the tx amount", () => (0, expect_1.default)(subAccount?.balance.toString()).toBe(subAccountBeforeTransaction?.balance.minus(status.amount).toString()));
            },
        },
    ],
};
exports.default = {
    stacksSpecs,
};
//# sourceMappingURL=bot-specs.js.map