MyAlgo Wallet test cases

packages/web/test/mocks/myalgowallet-mock.ts

@@ -0,0 +1,91 @@
+import type {
+    Options,
+    Accounts,
+    Address,
+    AlgorandTxn,
+    Base64,
+    ConnectionSettings,
+    EncodedTransaction,
+    SignedTx,
+    SignTransactionOptions,
+} from "@randlabs/myalgo-connect";
+
+export default class MyAlgoConnectMock {
+
+    /**
+     * @param {Options} options Override default popup options.
+     */
+    constructor(options?: Options) {
+
+    };
+
+    /**
+     * @async
+     * @description Receives user's accounts from MyAlgo.
+     * @param {ConnectionSettings} [settings] Connection settings
+     * @returns Returns an array of Algorand addresses.
+     */
+    connect(settings?: ConnectionSettings): Promise<Accounts[]> {
+        return new Promise((resolve, reject) => {
+            return resolve([{
+                address: "",
+                name: ""
+            }]);
+        });
+    };
+
+    /**
+     * @async
+     * @description Sign an Algorand Transaction.
+     * @param transaction Expect a valid Algorand transaction
+     * @param signOptions Sign transactions options object.
+     * @returns Returns signed transaction
+     */
+    signTransaction(transaction: AlgorandTxn | EncodedTransaction, signOptions?: SignTransactionOptions): Promise<SignedTx>;
+
+    /**
+     * @async
+     * @description Sign an Algorand Transaction.
+     * @param transaction Expect a valid Algorand transaction array.
+     * @param signOptions Sign transactions options object.
+     * @returns Returns signed an array of signed transactions.
+     */
+    signTransaction(transaction: (AlgorandTxn | EncodedTransaction)[], signOptions?: SignTransactionOptions): Promise<SignedTx[]>;
+
+    signTransaction(transaction: AlgorandTxn | EncodedTransaction | (AlgorandTxn | EncodedTransaction)[], signOptions?: SignTransactionOptions): Promise<SignedTx | SignedTx[]> {
+        return new Promise((resolve, reject) => {
+            return resolve([{
+                blob: new Uint8Array(),
+                txID: ""
+            }]);
+        });
+    }
+
+
+    /**
+     * @async
+     * @description Sign a teal program
+     * @param logic Teal program
+     * @param address Signer Address
+     * @returns Returns signed teal
+     */
+    signLogicSig(logic: Uint8Array | Base64, address: Address): Promise<Uint8Array> {
+        return new Promise((resolve, reject) => {
+            return resolve(new Uint8Array());
+        });
+    };
+
+    /**
+     * @async
+     * @description Creates a signature the data that can later be verified by the contract through the ed25519verify opcode
+     * @param data Arbitrary data to sign
+     * @param contractAddress Contract address/TEAL program hash
+     * @param address Signer Address
+     * @returns Returns the data signature
+     */
+    tealSign(data: Uint8Array | Base64, contractAddress: Address, address: Address): Promise<Uint8Array> {
+        return new Promise((resolve, reject) => {
+            return resolve(new Uint8Array());
+        });
+    };
+}

packages/web/test/src/lib/myalgowallet-mode.ts

@@ -0,0 +1,109 @@
+import algosdk, { Account, Transaction } from "algosdk";
+import assert from "assert";
+
+import { MyAlgoWalletSession, testnetURL, types } from "../../../src";
+import { algoexplorerAlgod, getSuggestedParams } from "../../../src/lib/api";
+import { HttpNetworkConfig } from "../../../src/types";
+import MyAlgoConnectMock from "../../mocks/myalgowallet-mock";
+
+describe("Webmode - MyAlgo Wallet test cases ", () => {
+	let connector: MyAlgoWalletSession;
+	let sender: Account;
+	let receiver: Account;
+	let algodClient: algosdk.Algodv2;
+	const walletURL: HttpNetworkConfig = {
+		token: "",
+		server: testnetURL,
+		port: "",
+	}
+	algodClient = algoexplorerAlgod(walletURL);
+
+	beforeEach(() => {
+		sender = algosdk.generateAccount();
+		receiver = algosdk.generateAccount();
+		connector = new MyAlgoWalletSession(walletURL, new MyAlgoConnectMock());
+
+	});
+
+	it("Should executeTx without throwing an error", async function () {
+		const txnParams: types.AlgoTransferParam = {
+			type: types.TransactionType.TransferAlgo,
+			sign: types.SignType.SecretKey,
+			fromAccount: sender,
+			toAccountAddr: receiver.addr,
+			amountMicroAlgos: 1e6,
+			payFlags: {},
+		};
+
+		assert.doesNotThrow(async () => {
+			await connector.executeTx([txnParams]);
+		});
+	});
+
+	describe("Helper functions", function () {
+		it("Should return a transaction object based on provided execParams", async function () {
+			const execParams: types.AlgoTransferParam = {
+				type: types.TransactionType.TransferAlgo,
+				sign: types.SignType.SecretKey,
+				fromAccount: sender,
+				toAccountAddr: receiver.addr,
+				amountMicroAlgos: 1e6,
+				payFlags: {},
+			};
+			const txnParams = await getSuggestedParams(algodClient);
+			const transactions: Transaction[] = connector.makeTx([execParams], txnParams);
+			assert.deepEqual(transactions[0].type, algosdk.TransactionType.pay);
+			assert.deepEqual(algosdk.encodeAddress(transactions[0].from.publicKey), sender.addr);
+			assert.deepEqual(algosdk.encodeAddress(transactions[0].to.publicKey), receiver.addr);
+			assert.deepEqual(transactions[0].amount, 1e6);
+		});
+
+		it("Should sign a transaction and return a SignedTransaction object", async function () {
+			const execParams: types.AlgoTransferParam = {
+				type: types.TransactionType.TransferAlgo,
+				sign: types.SignType.SecretKey,
+				fromAccount: sender,
+				toAccountAddr: receiver.addr,
+				amountMicroAlgos: 1e6,
+				payFlags: {},
+			};
+			const txnParams = await getSuggestedParams(algodClient);
+			const transactions: Transaction[] = connector.makeTx([execParams], txnParams);
+			assert.doesNotThrow(async () => {
+				await connector.signTx(transactions[0]);
+			});
+		});
+
+		it("Should return a SignedTransaction object based on ExecParams", async function () {
+			const execParams: types.AlgoTransferParam = {
+				type: types.TransactionType.TransferAlgo,
+				sign: types.SignType.SecretKey,
+				fromAccount: sender,
+				toAccountAddr: receiver.addr,
+				amountMicroAlgos: 1e6,
+				payFlags: {},
+			};
+			const txnParams = await getSuggestedParams(algodClient);
+			assert.doesNotThrow(async () => {
+				await connector.makeAndSignTx([execParams], txnParams);
+			});
+		});
+
+		it("Should send a signed transaction and wait specified rounds for confirmation", async function () {
+			const execParams: types.AlgoTransferParam = {
+				type: types.TransactionType.TransferAlgo,
+				sign: types.SignType.SecretKey,
+				fromAccount: sender,
+				toAccountAddr: receiver.addr,
+				amountMicroAlgos: 1e6,
+				payFlags: {},
+			};
+			const txnParams = await getSuggestedParams(algodClient);
+			const signedTx = await connector.makeAndSignTx([execParams], txnParams);
+			assert.doesNotThrow(async () => {
+				await connector.sendTxAndWait(signedTx);
+			});
+		});
+	});
+
+});