Atomic Transaction Question about algosigner HOT 5 CLOSED

        function base64ToArrayBuffer(base64) {
            var binary_string = window.atob(base64);
            var len = binary_string.length;
            var bytes = new Uint8Array(len);
            for (var i = 0; i < len; i++) {
                bytes[i] = binary_string.charCodeAt(i);
            }
            return bytes.buffer;
        }

        async function signGroupTransactions() {
            if (typeof AlgoSigner !== 'undefined') {
                await AlgoSigner.connect();

                // I have two accounts in algosigner.
                let accounts = await AlgoSigner.accounts({ ledger: `TestNet` });

                let txParams = await AlgoSigner.algod({
                    ledger: 'TestNet',
                    path: '/v2/transactions/params',
                });

                // First transaction from account 1 to account 2.
                let txn1 = {
                    from: accounts[0].address,
                    to: accounts[1].address,
                    fee: txParams['min-fee'],
                    type: 'pay',
                    amount: 1000000,
                    firstRound: txParams['last-round'],
                    lastRound: txParams['last-round'] + 1000,
                    genesisID: txParams['genesis-id'],
                    genesisHash: txParams['genesis-hash']
                };

                // Second transaction from account 2 to account 1.
                let txn2 = {
                    from: accounts[1].address,
                    to: accounts[1].address,
                    fee: txParams['min-fee'],
                    type: 'pay',
                    amount: 2000000,
                    firstRound: txParams['last-round'],
                    lastRound: txParams['last-round'] + 1000,
                    genesisID: txParams['genesis-id'],
                    genesisHash: txParams['genesis-hash']
                };

                // using the sdk to assign the group id.
                let txnGroup = algosdk.assignGroupID([txn1, txn2]);

                // Algosigner likes base64 encoded strings. So get the group id and set it on the two original transactions.
                let groupId = btoa(String.fromCharCode.apply(null, txnGroup[0].group));
                txn1.group = groupId;
                txn2.group = groupId;

                // Sign the transactions with AlgoSigner.
                let signedTxn1 = await AlgoSigner.sign(txn1);
                let signedTxn2 = await AlgoSigner.sign(txn2);

                // Get the signed transactions as arrays so that we cans send them with the sdk.
                // This is because I don't know how to send a transaction group through with AlgoSigner.
                let signed = [];
                signed.push(base64ToArrayBuffer(signedTxn1.blob));
                signed.push(base64ToArrayBuffer(signedTxn2.blob));

                try {
                    // Alas, this won't work.
                    let tx = (await algodClient.sendRawTransaction(signed).do());
                    console.log("Transaction : " + tx.txId);
                }
                catch (error) {
                    // Based on the error and decoded transactions, it looks like "group" was not in the signed transaction.
                    console.log(error);
                    console.log(algosdk.decodeSignedTransaction(base64ToArrayBuffer(signedTxn1.blob)));
                    console.log(algosdk.decodeSignedTransaction(base64ToArrayBuffer(signedTxn2.blob)));
                }
            }
        }