@txnlab/use-wallet 1.0.4 → 1.0.5

package/dist/cjs/clients/algosigner/client.d.ts

@@ -26,7 +26,7 @@ declare class AlgoSignerClient extends BaseWallet {
     }>;
     reconnect(onDisconnect: () => void): Promise<null>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecated */
     formatTransactionsArray(transactions: TransactionsArray): AlgoSignerTransaction[];
     /** @deprecated */

package/dist/cjs/clients/base/base.d.ts

@@ -9,7 +9,7 @@ declare abstract class BaseClient {
     abstract connect(onDisconnect: () => void): Promise<Wallet>;
     abstract disconnect(): Promise<void>;
     abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
-    abstract signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    abstract signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>, indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     abstract signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
     protected constructor(metadata: Metadata, algosdk: typeof _algosdk, algodClient: _algosdk.Algodv2);
     healthCheck(): Promise<{}>;

package/dist/cjs/clients/defly/client.d.ts

@@ -28,7 +28,7 @@ declare class DeflyWalletClient extends BaseWallet {
         isWalletConnect: boolean;
     } | null>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecated */
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
     /** @deprecated */

package/dist/cjs/clients/exodus/client.d.ts

@@ -26,7 +26,7 @@ declare class ExodusClient extends BaseWallet {
     }>;
     reconnect(onDisconnect: () => void): Promise<null>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>, indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecated */
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }

package/dist/cjs/clients/kmd/client.d.ts

@@ -23,7 +23,7 @@ declare class KMDWalletClient extends BaseWallet {
     releaseToken(token: string): Promise<void>;
     listWallets(): Promise<Record<string, string>>;
     listAccounts(wallet: string, password: string): Promise<Array<Account>>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
 export default KMDWalletClient;

package/dist/cjs/clients/myalgo/client.d.ts

@@ -30,7 +30,7 @@ declare class MyAlgoWalletClient extends BaseWallet {
     }>;
     reconnect(): Promise<null>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecated */
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }

package/dist/cjs/clients/pera/client.d.ts

@@ -26,7 +26,7 @@ declare class PeraWalletClient extends BaseWallet {
         isWalletConnect: boolean;
     } | null>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecated */
     formatTransactionsArray(transactions: TransactionsArray): PeraTransaction[];
     /** @deprecated */

package/dist/cjs/clients/walletconnect/client.d.ts

@@ -27,7 +27,7 @@ declare class WalletConnectClient extends BaseWallet {
     } | null>;
     check(): boolean;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
     /** @deprecarted */
     formatTransactionsArray(transactions: TransactionsArray): WalletConnectTransaction[];
     /** @deprecated */

package/dist/cjs/hooks/useWallet.d.ts

@@ -17,7 +17,7 @@ export default function useWallet(): {
     activeAccount: import("../types").Account | null;
     activeAddress: string | undefined;
     signer: algosdk.TransactionSigner;
-    signTransactions: (transactions: Array<Uint8Array>) => Promise<Uint8Array[]>;
+    signTransactions: (transactions: Array<Uint8Array>, indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
     sendTransactions: (transactions: Uint8Array[], waitRoundsToConfirm?: number) => Promise<{
         "confirmed-round": number;
         "global-state-delta": Record<string, unknown>[];

package/dist/cjs/index.js

@@ -1133,7 +1133,6 @@ class PeraWalletClient extends BaseClient {
     }
     async reconnect(onDisconnect) {
         const accounts = await this.#client.reconnectSession().catch(console.info);
-        console.log("accounts?", accounts);
         this.#client.connector?.on("disconnect", onDisconnect);
         if (!accounts) {
             onDisconnect();
@@ -1151,37 +1150,56 @@ class PeraWalletClient extends BaseClient {
     async disconnect() {
         await this.#client.disconnect();
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
         });
+        const signedIndexes = [];
         // Marshal the transactions,
         // and add the signers property if they shouldn't be signed.
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn) &&
+            const isSigned = "txn" in txn;
+            // If the indexes to be signed is specified, designate that it should be signed
+            if (indexesToSign && indexesToSign.length && indexesToSign.includes(i)) {
+                signedIndexes.push(i);
+                acc.push({
+                    txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
+                });
+                // If the transaction is unsigned and is to be sent from a connected account,
+                // designate that it should be signed
+            }
+            else if (!isSigned &&
                 connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
+                signedIndexes.push(i);
                 acc.push({
                     txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
                 });
+                // Otherwise, designate that it should not be signed
             }
-            else {
+            else if (isSigned) {
                 acc.push({
                     txn: this.algosdk.decodeSignedTransaction(transactions[i]).txn,
                     signers: [],
                 });
             }
+            else if (!isSigned) {
+                acc.push({
+                    txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
+                    signers: [],
+                });
+            }
             return acc;
         }, []);
         // Sign them with the client.
         const result = await this.#client.signTransaction([txnsToSign]);
         // Join the newly signed transactions with the original group of transactions.
-        const signedTxns = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn)) {
+        const signedTxns = transactions.reduce((acc, txn, i) => {
+            if (signedIndexes.includes(i)) {
                 const signedByUser = result.shift();
                 signedByUser && acc.push(signedByUser);
             }
-            else {
+            else if (returnGroup) {
                 acc.push(transactions[i]);
             }
             return acc;
@@ -1290,31 +1308,38 @@ class MyAlgoWalletClient extends BaseClient {
     async disconnect() {
         return;
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
         });
-        // Get the unsigned transactions.
+        const signedIndexes = [];
+        // Get the transactions to be signed
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
-            // If the transaction isn't already signed and is to be sent from a connected account,
-            // add it to the arrays of transactions to be signed.
-            if (!("txn" in txn) &&
+            const isSigned = "txn" in txn;
+            // If the indexes to be signed is specified, add it to the transactions to be signed,
+            if (indexesToSign && indexesToSign.length && indexesToSign?.includes(i)) {
+                signedIndexes.push(i);
+                acc.push(transactions[i]);
+                // Otherwise, if the transaction is unsigned and is to be sent from a connected account,
+                // add it to the transactions to be signed
+            }
+            else if (!isSigned &&
                 connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
+                signedIndexes.push(i);
                 acc.push(transactions[i]);
             }
             return acc;
         }, []);
         // Sign them with the client.
         const result = await this.#client.signTransaction(txnsToSign);
-        // Join the newly signed transactions with the original group of transactions.
-        const signedTxns = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn)) {
+        const signedTxns = transactions.reduce((acc, txn, i) => {
+            if (signedIndexes.includes(i)) {
                 const signedByUser = result.shift()?.blob;
                 signedByUser && acc.push(signedByUser);
             }
-            else {
-                acc.push(transactions[i]);
+            else if (returnGroup) {
+                acc.push(txn);
             }
             return acc;
         }, []);
@@ -1421,37 +1446,57 @@ class DeflyWalletClient extends BaseClient {
     async disconnect() {
         await this.#client.disconnect();
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
         });
+        const signedIndexes = [];
         // Marshal the transactions,
         // and add the signers property if they shouldn't be signed.
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn) &&
+            const isSigned = "txn" in txn;
+            // If the indexes to be signed is specified, designate that it should be signed
+            if (indexesToSign && indexesToSign.length && indexesToSign.includes(i)) {
+                signedIndexes.push(i);
+                acc.push({
+                    txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
+                });
+                // If the transaction is unsigned and is to be sent from a connected account,
+                // designate that it should be signed
+            }
+            else if (!isSigned &&
                 connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
+                signedIndexes.push(i);
                 acc.push({
                     txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
                 });
+                // Otherwise, designate that it should not be signed
             }
-            else {
+            else if (isSigned) {
                 acc.push({
                     txn: this.algosdk.decodeSignedTransaction(transactions[i]).txn,
                     signers: [],
                 });
             }
+            else if (!isSigned) {
+                acc.push({
+                    txn: this.algosdk.decodeUnsignedTransaction(transactions[i]),
+                    signers: [],
+                });
+            }
             return acc;
         }, []);
         // Sign them with the client.
         const result = await this.#client.signTransaction([txnsToSign]);
-        // Join the newly signed transactions with the original group of transactions.
-        const signedTxns = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn)) {
+        // Join the newly signed transactions with the original group of transactions
+        // if 'returnGroup' param is specified
+        const signedTxns = transactions.reduce((acc, txn, i) => {
+            if (signedIndexes.includes(i)) {
                 const signedByUser = result.shift();
                 signedByUser && acc.push(signedByUser);
             }
-            else {
+            else if (returnGroup) {
                 acc.push(transactions[i]);
             }
             return acc;
@@ -1571,17 +1616,26 @@ class ExodusClient extends BaseClient {
     async disconnect() {
         return;
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
         });
+        const signedIndexes = [];
         // Get the unsigned transactions.
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
-            // If the transaction isn't already signed and is to be sent from a connected account,
+            const isSigned = "txn" in txn;
+            // If the indexes to be signed is specified
             // add it to the arrays of transactions to be signed.
-            if (!("txn" in txn) &&
+            if (indexesToSign && indexesToSign.length && indexesToSign.includes(i)) {
+                signedIndexes.push(i);
+                acc.push(transactions[i]);
+                // If the transaction isn't already signed and is to be sent from a connected account,
+                // add it to the arrays of transactions to be signed
+            }
+            else if (!isSigned &&
                 connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
+                signedIndexes.push(i);
                 acc.push(transactions[i]);
             }
             return acc;
@@ -1589,12 +1643,12 @@ class ExodusClient extends BaseClient {
         // Sign them with the client.
         const result = await this.#client.signTransaction(txnsToSign);
         // Join the newly signed transactions with the original group of transactions.
-        const signedTxns = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn)) {
+        const signedTxns = transactions.reduce((acc, txn, i) => {
+            if (signedIndexes.includes(i)) {
                 const signedByUser = result.shift();
                 signedByUser && acc.push(signedByUser);
             }
-            else {
+            else if (returnGroup) {
                 acc.push(transactions[i]);
             }
             return acc;
@@ -1709,7 +1763,7 @@ class AlgoSignerClient extends BaseClient {
     async disconnect() {
         return;
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
@@ -1717,12 +1771,26 @@ class AlgoSignerClient extends BaseClient {
         // Marshal the transactions,
         // and add the signers property if they shouldn't be signed.
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
+            const isSigned = "txn" in txn;
             const txnObj = {
                 txn: this.#client.encoding.msgpackToBase64(transactions[i]),
             };
-            if ("txn" in txn ||
-                !connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
-                txnObj.txn = this.#client.encoding.msgpackToBase64(this.algosdk.decodeSignedTransaction(transactions[i]).txn.toByte());
+            if (indexesToSign &&
+                indexesToSign.length &&
+                !indexesToSign.includes(i)) {
+                txnObj.txn = this.#client.encoding.msgpackToBase64(isSigned
+                    ? this.algosdk
+                        .decodeSignedTransaction(transactions[i])
+                        .txn.toByte()
+                    : this.algosdk.decodeUnsignedTransaction(transactions[i]).toByte());
+                txnObj.signers = [];
+            }
+            else if (!connectedAccounts.includes(this.algosdk.encodeAddress(isSigned ? txn.txn["snd"] : txn["snd"]))) {
+                txnObj.txn = this.#client.encoding.msgpackToBase64(isSigned
+                    ? this.algosdk
+                        .decodeSignedTransaction(transactions[i])
+                        .txn.toByte()
+                    : this.algosdk.decodeUnsignedTransaction(transactions[i]).toByte());
                 txnObj.signers = [];
             }
             acc.push(txnObj);
@@ -1730,12 +1798,13 @@ class AlgoSignerClient extends BaseClient {
         }, []);
         // Sign them with the client.
         const result = await this.#client.signTxn(txnsToSign);
-        // Join the newly signed transactions with the original group of transactions.
+        // Join the newly signed transactions with the original group of transactions
+        // if 'returnGroup' param is specified
         const signedTxns = result.reduce((acc, txn, i) => {
             if (txn) {
                 acc.push(new Uint8Array(Buffer.from(txn.blob, "base64")));
             }
-            else {
+            else if (returnGroup) {
                 acc.push(transactions[i]);
             }
             return acc;
@@ -1808,8 +1877,8 @@ class WalletConnectClient extends BaseClient {
             const walletConnect = new WalletConnect({
                 bridge: "https://bridge.walletconnect.org",
                 qrcodeModal: QRCodeModal,
-                storageId: 'walletconnect-generic',
-                ...(clientOptions || {})
+                storageId: "walletconnect-generic",
+                ...(clientOptions || {}),
             });
             const algosdk = algosdkStatic || (await Algod.init(algodOptions)).algosdk;
             const algodClient = await getAlgodClient(algosdk, algodOptions);
@@ -1894,7 +1963,7 @@ class WalletConnectClient extends BaseClient {
             console.error("Error disconnecting", e);
         }
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
@@ -1902,7 +1971,15 @@ class WalletConnectClient extends BaseClient {
         // Marshal the transactions,
         // and add the signers property if they shouldn't be signed.
         const txnsToSign = decodedTxns.reduce((acc, txn, i) => {
-            if (!("txn" in txn) &&
+            const isSigned = "txn" in txn;
+            if (indexesToSign &&
+                indexesToSign.length &&
+                indexesToSign.includes(i)) {
+                acc.push({
+                    txn: Buffer.from(transactions[i]).toString("base64"),
+                });
+            }
+            else if (!isSigned &&
                 connectedAccounts.includes(this.algosdk.encodeAddress(txn["snd"]))) {
                 acc.push({
                     txn: Buffer.from(transactions[i]).toString("base64"),
@@ -1910,7 +1987,9 @@ class WalletConnectClient extends BaseClient {
             }
             else {
                 acc.push({
-                    txn: Buffer.from(transactions[i]).toString("base64"),
+                    txn: isSigned
+                        ? Buffer.from(this.algosdk.encodeUnsignedTransaction(this.algosdk.decodeSignedTransaction(transactions[i]).txn)).toString("base64")
+                        : Buffer.from(transactions[i]).toString("base64"),
                     signers: [],
                 });
             }
@@ -1929,7 +2008,7 @@ class WalletConnectClient extends BaseClient {
             if (txn) {
                 signedTxns.push(new Uint8Array(Buffer.from(txn, "base64")));
             }
-            if (txn === null) {
+            if (returnGroup) {
                 signedTxns.push(transactions[i]);
             }
             return signedTxns;
@@ -2075,7 +2154,7 @@ class KMDWalletClient extends BaseClient {
         this.releaseToken(token);
         return mappedAccounts;
     }
-    async signTransactions(connectedAccounts, transactions) {
+    async signTransactions(connectedAccounts, transactions, indexesToSign, returnGroup = true) {
         // Decode the transactions to access their properties.
         const decodedTxns = transactions.map((txn) => {
             return this.algosdk.decodeObj(txn);
@@ -2088,14 +2167,23 @@ class KMDWalletClient extends BaseClient {
         const signingPromises = [];
         for (const idx in decodedTxns) {
             const dtxn = decodedTxns[idx];
+            const isSigned = "txn" in dtxn;
             // push the incoming txn into signed, we'll overwrite it later
             signedTxns.push(transactions[idx]);
             // Its already signed, skip it
-            if (!("snd" in dtxn))
+            if (isSigned) {
                 continue;
+                // Not specified in indexes to sign, skip it
+            }
+            else if (indexesToSign &&
+                indexesToSign.length &&
+                !indexesToSign.includes(Number(idx))) {
+                continue;
+            }
             // Not to be signed by our signer, skip it
-            if (!connectedAccounts.includes(this.algosdk.encodeAddress(dtxn.snd)))
+            else if (!connectedAccounts.includes(this.algosdk.encodeAddress(dtxn.snd))) {
                 continue;
+            }
             // overwrite with an empty blob
             signedTxns[idx] = new Uint8Array();
             const txn = this.algosdk.Transaction.from_obj_for_encoding(dtxn);
@@ -2104,15 +2192,19 @@ class KMDWalletClient extends BaseClient {
         const signingResults = await Promise.all(signingPromises);
         // Restore the newly signed txns in the correct order
         let signedIdx = 0;
-        for (const idx in signedTxns) {
+        const formattedTxns = signedTxns.reduce((acc, txn, i) => {
             // If its an empty array, infer that it is one of the
             // ones we wanted to have signed and overwrite the empty buff
-            if (signedTxns[idx].length === 0) {
-                signedTxns[idx] = signingResults[signedIdx];
+            if (txn.length === 0) {
+                acc.push(signingResults[signedIdx]);
                 signedIdx += 1;
             }
-        }
-        return signedTxns;
+            else if (returnGroup) {
+                acc.push(txn);
+            }
+            return acc;
+        }, []);
+        return formattedTxns;
     }
     signEncodedTransactions(transactions) {
         throw new Error("Method not implemented.");
@@ -2251,12 +2343,12 @@ function useWallet() {
             console.error(e);
         }
     };
-    const signTransactions = async (transactions) => {
+    const signTransactions = async (transactions, indexesToSign, returnGroup = true) => {
         const walletClient = await getClient(activeAccount?.providerId);
         if (!walletClient || !activeAccount?.address) {
             throw new Error("No wallet found.");
         }
-        const signedTransactions = await walletClient.signTransactions(connectedActiveAccounts.map((acct) => acct.address), transactions);
+        const signedTransactions = await walletClient.signTransactions(connectedActiveAccounts.map((acct) => acct.address), transactions, indexesToSign, returnGroup);
         return signedTransactions;
     };
     const sendTransactions = async (transactions, waitRoundsToConfirm) => {
@@ -2267,8 +2359,7 @@ function useWallet() {
     const signer = async (txnGroup, indexesToSign) => {
         const algosdk = await getAlgosdk();
         const txnBlobs = txnGroup.map(algosdk.encodeUnsignedTransaction);
-        const txns = await Promise.resolve(signTransactions(txnBlobs));
-        return txns.filter((_, index) => indexesToSign.includes(index));
+        return await Promise.resolve(signTransactions(txnBlobs, indexesToSign, false));
     };
     const getAccountInfo = async () => {
         if (!activeAccount)