stellar-plus/lib/tests/integration/classic-asset-management/index.integration.test.js

beta version of stellar-plus, an all-in-one sdk for the Stellar blockchain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const account_1 = require("../../../stellar-plus/account");
const asset_1 = require("../../../stellar-plus/asset");
const network_1 = require("../../../stellar-plus/network");
const stellar_test_ledger_1 = require("../../../stellar-plus/test/stellar-test-ledger");
const utils_1 = require("../../../tests/utils");
describe('Classic Asset Management Use Case: ', () => {
    const logLevel = 'TRACE';
    const stellarTestLedger = new stellar_test_ledger_1.StellarTestLedger({
        logLevel,
        network: stellar_test_ledger_1.TestLedgerNetwork.LOCAL,
        containerImageVersion: stellar_test_ledger_1.SupportedImageVersions.LASTEST,
    });
    let networkConfig;
    beforeAll(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
        const container = yield stellarTestLedger.start();
        expect(container).toBeDefined();
        networkConfig = (0, network_1.CustomNet)(yield stellarTestLedger.getNetworkConfiguration());
        expect(networkConfig.horizonUrl).toBeDefined();
        expect(networkConfig.networkPassphrase).toBeDefined();
        expect(networkConfig.rpcUrl).toBeDefined();
        expect(networkConfig.friendbotUrl).toBeDefined();
    }));
    afterAll(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
        yield stellarTestLedger.stop();
        yield stellarTestLedger.destroy();
    }));
    describe('Given an issuer with lumens', () => {
        let issuer;
        let userA;
        let userB;
        let userC;
        let userAExpectedBalance;
        let userBExpectedBalance;
        let userCExpectedBalance;
        beforeAll(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
            issuer = new account_1.DefaultAccountHandler({ networkConfig });
            yield issuer.initializeWithFriendbot();
            expect(issuer).toBeDefined();
            userA = new account_1.DefaultAccountHandler({ networkConfig });
            userB = new account_1.DefaultAccountHandler({ networkConfig });
            userC = new account_1.DefaultAccountHandler({ networkConfig });
            yield userA.initializeWithFriendbot();
            yield userB.initializeWithFriendbot();
            yield userC.initializeWithFriendbot();
            userAExpectedBalance = 0;
            userBExpectedBalance = 0;
            userCExpectedBalance = 0;
        }));
        describe('A Classic Asset Handler initialized with the issuer account handler', () => {
            let classicAssetMgnt;
            beforeAll(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                classicAssetMgnt = new asset_1.ClassicAssetHandler({
                    code: 'SPLUS',
                    issuerAccount: issuer,
                    networkConfig,
                });
                expect(classicAssetMgnt).toBeDefined();
            }));
            it('should fetch a "0" balance for an account with no trustline', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userAExpectedBalance = 0;
                yield expect(classicAssetMgnt.balance(userA.getPublicKey())).resolves.toBe(userAExpectedBalance);
            }));
            it('should add a trustline and mint to a target account', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userAExpectedBalance += 1000;
                yield expect(classicAssetMgnt.addTrustlineAndMint(Object.assign({ to: userA.getPublicKey(), amount: 1000 }, (0, utils_1.simpleTxInvocation)(userA)))).toResolve();
                yield expect(classicAssetMgnt.balance(userA.getPublicKey())).resolves.toBe(userAExpectedBalance);
            }));
            it;
            it('should add a trustline to a target account', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userBExpectedBalance = 0;
                yield expect(classicAssetMgnt.addTrustline(Object.assign({ to: userB.getPublicKey() }, (0, utils_1.simpleTxInvocation)(userB)))).toResolve();
                yield expect(classicAssetMgnt.balance(userB.getPublicKey())).resolves.toBe(userBExpectedBalance);
            }));
            it('should mint to a target account with a trustline', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userBExpectedBalance += 600;
                yield expect(classicAssetMgnt.mint(Object.assign({ to: userB.getPublicKey(), amount: 600 }, (0, utils_1.simpleTxInvocation)(issuer)))).toResolve();
                yield expect(classicAssetMgnt.balance(userB.getPublicKey())).resolves.toBe(userBExpectedBalance);
            }));
            it('should burn from a target account with a trustline', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userBExpectedBalance -= 100;
                yield expect(classicAssetMgnt.burn(Object.assign({ from: userB.getPublicKey(), amount: 100 }, (0, utils_1.simpleTxInvocation)(userB)))).toResolve();
                yield expect(classicAssetMgnt.balance(userB.getPublicKey())).resolves.toBe(userBExpectedBalance);
            }));
            it('should transfer from one account to another', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userAExpectedBalance -= 250;
                userBExpectedBalance += 250;
                yield expect(classicAssetMgnt.transfer(Object.assign({ from: userA.getPublicKey(), to: userB.getPublicKey(), amount: 250 }, (0, utils_1.simpleTxInvocation)(userA)))).toResolve();
                yield expect(classicAssetMgnt.balance(userA.getPublicKey())).resolves.toBe(userAExpectedBalance);
                yield expect(classicAssetMgnt.balance(userB.getPublicKey())).resolves.toBe(userBExpectedBalance);
            }));
        });
        describe('A Classic Asset Handler initialized with the issuer public key', () => {
            let classicAsset;
            beforeAll(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                classicAsset = new asset_1.ClassicAssetHandler({
                    code: 'SPLUS',
                    issuerAccount: issuer.getPublicKey(),
                    networkConfig,
                });
                expect(classicAsset).toBeDefined();
            }));
            it('should add a trustline to a target account', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userCExpectedBalance = 0;
                yield expect(classicAsset.addTrustline(Object.assign({ to: userC.getPublicKey() }, (0, utils_1.simpleTxInvocation)(userC)))).toResolve();
                yield expect(classicAsset.balance(userC.getPublicKey())).resolves.toBe(userCExpectedBalance);
            }));
            it('should transfer from one account to another', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                userAExpectedBalance -= 250;
                userCExpectedBalance += 250;
                yield expect(classicAsset.transfer(Object.assign({ from: userA.getPublicKey(), to: userC.getPublicKey(), amount: 250 }, (0, utils_1.simpleTxInvocation)(userA)))).toResolve();
                yield expect(classicAsset.balance(userA.getPublicKey())).resolves.toBe(userAExpectedBalance);
                yield expect(classicAsset.balance(userC.getPublicKey())).resolves.toBe(userCExpectedBalance);
            }));
            it('should not mint', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                yield expect(classicAsset.mint(Object.assign({ to: userB.getPublicKey(), amount: 600 }, (0, utils_1.simpleTxInvocation)(userB)))).rejects.toThrow();
            }));
        });
    });
});