@algodex/algodex-sdk-patch/test/teal_tests/closeASAEscrowOrder.js

API calls for interacting with the Algorand blockchain

const testHelper = require('../../test_helper.js');
const transactionGenerator = require('../../generate_transaction_types.js');
const algosdk = require('algosdk');
const PRINT_TXNS = 0;

const Test = {
    runTest : async function (config, price, returnOuterTransactions = false) {
        console.log("STARTING close asa escrow order test");
        const client = config.client;
        const creatorAccount = config.creatorAccount;
        const assetId = config.assetId;
        const appId = config.appId;
        console.log("creator account is: " + creatorAccount.addr);
        
        let outerTxns = await transactionGenerator.getCloseASAEscrowOrderTxns(client, creatorAccount, price, assetId, appId);

        if (returnOuterTransactions) {
            return outerTxns;
        }
        let signedTxns = testHelper.groupAndSignTransactions(outerTxns);

        await testHelper.sendAndCheckConfirmed(client, signedTxns);

        return true;
    },

    getOuterTransactions: async function(config) {
        const outerTxns = await this.runTest(config, 1.45, true);
        return outerTxns;
    },

    runGroupSizeWrongTest : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        const lsig = outerTxns[0].lsig;

        outerTxns.push( {
            unsignedTxn: await transactionGenerator.getPayTxn(client, lsig.address(), maliciousAccount.addr,
                1000, false),
            lsig: lsig
        });

        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runGroupSizeWrongTest2 : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        const lsig = outerTxns[0].lsig;

        outerTxns.push( {
            unsignedTxn: await transactionGenerator.getPayTxn(client, maliciousAccount.addr, maliciousAccount.addr,
                1000, false),
            senderAcct: maliciousAccount
        });

        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    appCallMissing : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[0] = {
            unsignedTxn: await transactionGenerator.getPayTxn(client, maliciousAccount.addr, maliciousAccount.addr,
                1000, false),
            senderAcct: maliciousAccount
        };

        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    appCallMissing2 : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[0].unsignedTxn.appOnComplete = 0; // change to noop

        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    appCallWrongSender : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[0].unsignedTxn.from = algosdk.decodeAddress(maliciousAccount.addr);

        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runASAWrongAddrCloseToTest : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[1].unsignedTxn.closeRemainderTo = algosdk.decodeAddress(maliciousAccount.addr);
        
        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runAlgoWrongAddrCloseToTest : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[2].unsignedTxn.closeRemainderTo = algosdk.decodeAddress(maliciousAccount.addr);
        
        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runASACloseToTxnHasNonZeroAmount : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[1].unsignedTxn.amount = 1000;
        
        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runAlgoCloseToTxnHasNonZeroAmount : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[2].unsignedTxn.amount = 1000;
        
        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

    runWrongOwnerProofTest : async function (config) {
        const outerTxns = await this.getOuterTransactions(config);
        const client = config.client;
        const maliciousAccount = config.maliciousAccount;

        if (PRINT_TXNS) {
            testHelper.printOuterTransactions(outerTxns);
        }

        outerTxns[3].unsignedTxn.from = algosdk.decodeAddress(maliciousAccount.addr);
        
        const signedTxns = testHelper.groupAndSignTransactions(outerTxns);
        try {
            await testHelper.sendAndCheckConfirmed(client, signedTxns);
        } catch (e) {
            // An exception is expected. Return true for success
            return testHelper.checkFailureType(e);
        }

        return false;
    },

}
module.exports = Test;