@txnlab/use-wallet 0.0.1

package/README.md

@@ -0,0 +1,143 @@
+### @txnlab/use-wallet
+
+React hooks for using Algorand compatible wallets with web applications.
+
+### Quick Start
+
+Install with Yarn.
+
+```bash
+yarn add @txnlab/use-wallet
+```
+
+Install with NPM.
+
+```bash
+npm install @txnlab/use-wallet
+```
+
+Install the peer dependencies if you don't have them.
+
+With Yarn.
+
+```bash
+yarn add @blockshake/defly-connect @perawallet/connect @randlabs/myalgo-connect @walletconnect/client algosdk
+```
+
+With NPM.
+
+```bash
+npm install algosdk @blockshake/defly-connect @perawallet/connect @randlabs/myalgo-connect @walletconnect/client
+```
+
+Setup the wallet providers
+
+```jsx
+import React from "react";
+import { useConnectWallet } from "../../index";
+
+type ConnectWalletProps = {
+  foo?: string;
+};
+
+export default function ConnectWallet(props: ConnectWalletProps) {
+  const { providers, reconnectProviders, accounts, activeAccount } =
+    useConnectWallet();
+
+  // Reconnect the session when the user returns to the dApp
+  React.useEffect(() => {
+    reconnectProviders();
+  }, []);
+
+  // Use these properties to display connected accounts to users.
+  React.useEffect(() => {
+    console.log("connected accounts", accounts);
+    console.log("active account", activeAccount);
+  });
+
+  // Map through the providers, and render "connect", "set active", and "disconnect" buttons
+  return (
+    <div>
+      {providers.map((provider) => (
+        <div key={"provider-" + provider.id}>
+          <h4>
+            <img width={30} height={30} src={provider.icon} />
+            {provider.name} {provider.isActive && "[active]"}
+          </h4>
+          <div>
+            {/* If the wallet provider isn't connected, render a "connect" button */}
+            {!provider.isConnected && (
+              <button onClick={provider.connect}>Connect</button>
+            )}
+            {/* If the wallet provider is connected and active, render a "disconnect" button */}
+            {provider.isConnected && (
+              <button onClick={provider.disconnect}>Disonnect</button>
+            )}
+            {/* If the wallet provider is connected but not active, render a "set active" button */}
+            {provider.isConnected && !provider.isActive && (
+              <button onClick={provider.setActive}>Set Active</button>
+            )}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+Sign and send transactions
+
+```jsx
+const Wallet = (props: WalletProps) => {
+  const { activeAccount, signTransactions, sendTransactions } = useWallet();
+
+  const sendTransaction = async (
+    from?: string,
+    to?: string,
+    amount?: number
+  ) => {
+    if (!from || !to || !amount) {
+      throw new Error("Missing transaction params.");
+    }
+
+    const params = await algodClient.getTransactionParams().do();
+
+    const transaction = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
+      from,
+      to,
+      amount,
+      suggestedParams: params,
+    });
+
+    const encodedTransaction = algosdk.encodeUnsignedTransaction(transaction);
+    const signedTransactions = await signTransactions([encodedTransaction]);
+
+    const { id } = await sendTransactions(signedTransactions);
+
+    console.log("Successfully sent transaction. Transaction ID: ", id);
+  };
+
+  if (!activeAccount) {
+    return <p>Connect an account first.</p>;
+  }
+
+  return (
+    <div>
+      {
+        <button
+          onClick={() =>
+            sendTransaction(
+              activeAccount?.address,
+              activeAccount?.address,
+              1000
+            )
+          }
+          className="button"
+        >
+          Sign and send transactions
+        </button>
+      }
+    </div>
+  );
+};
+```

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

@@ -0,0 +1,62 @@
+/**
+ * Helpful resources:
+ * https://github.com/PureStake/algosigner/blob/develop/docs/dApp-integration.md
+ */
+import BaseWallet from "./base";
+import type { InitAlgodClient } from "./base";
+import { PROVIDER_ID } from "../constants";
+import { providers } from "../providers";
+import type { WalletProvider } from "../types";
+import { TransactionsArray } from "../types";
+declare type AlgoSignerTransaction = {
+    txn: string;
+    signers?: [];
+    multisig?: string;
+};
+declare type SupportedLedgers = "MainNet" | "TestNet" | "BetaNet" | "devmodenet";
+declare type AlgoSigner = {
+    connect: () => Promise<Record<string, never>>;
+    accounts: (ledger: {
+        ledger: SupportedLedgers;
+    }) => Promise<{
+        address: string;
+    }[]>;
+    signTxn: (transactions: AlgoSignerTransaction[]) => Promise<{
+        txID: string;
+        blob: string;
+    }[]>;
+    encoding: {
+        msgpackToBase64(transaction: Uint8Array): string;
+        byteArrayToString(transaction: Uint8Array): string;
+    };
+};
+declare type InitWallet = {
+    client: AlgoSigner;
+    id: PROVIDER_ID;
+    providers: typeof providers;
+};
+declare class AlgoSignerClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    static init(): Promise<AlgoSignerClient>;
+    connect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    }>;
+    reconnect(onDisconnect: () => void): Promise<null>;
+    disconnect(): Promise<void>;
+    formatTransactionsArray(transactions: TransactionsArray): AlgoSignerTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+declare const _default: Promise<void | AlgoSignerClient>;
+export default _default;

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

@@ -0,0 +1,72 @@
+import type _algosdk from "algosdk";
+import { PROVIDER_ID } from "../constants";
+import type { WalletProvider, Asset, Wallet, AccountInfo } from "../types";
+import { ConfirmedTxn } from "../types";
+import { TransactionsArray, TxnInfo } from "../types";
+/** @todo implement audio hack */
+export declare type InitAlgodClient = {
+    algosdk: typeof _algosdk;
+    token: string;
+    server: string;
+    port: string;
+};
+export interface BaseWalletInterface {
+    connect(onDisconnect: () => void): Promise<Wallet>;
+    healthCheck(): Promise<Record<string, never>>;
+    disconnect(): Promise<void>;
+    reconnect(onDisconnect: () => void): Promise<Wallet | null>;
+    decodeTransaction(txn: string, isSigned: boolean): _algosdk.Transaction;
+    logEncodedTransaction(txn: string, isSigned: boolean): void;
+    groupTransactionsBySender(transactions: TransactionsArray): Record<string, TxnInfo[]>;
+    signTransactions(activeAddress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+    sendRawTransactions(transactions: Uint8Array[]): Promise<ConfirmedTxn & {
+        id: string;
+    }>;
+    getAccountInfo(address: string): Promise<AccountInfo>;
+    getAssets(address: string): Promise<Asset[]>;
+    waitForConfirmation(txId: string, timeout?: number): Promise<ConfirmedTxn>;
+}
+declare abstract class BaseWallet implements BaseWalletInterface {
+    algodClient: _algosdk.Algodv2;
+    algosdk: typeof _algosdk;
+    keepWCAlive: HTMLAudioElement;
+    protected abstract id: PROVIDER_ID;
+    protected abstract provider: WalletProvider;
+    abstract connect(onDisconnect: () => void): Promise<Wallet>;
+    abstract disconnect(): Promise<void>;
+    abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
+    abstract signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    abstract signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+    protected constructor({ algosdk, token, server, port }: InitAlgodClient);
+    healthCheck(): Promise<{}>;
+    getAccountInfo(address: string): Promise<AccountInfo>;
+    getAssets(address: string): Promise<Asset[]>;
+    waitForConfirmation(txId: string, timeout?: number): Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: import("../types").Txn;
+        };
+        txId: string;
+    }>;
+    decodeTransaction: (txn: string, isSigned: boolean) => _algosdk.Transaction;
+    logEncodedTransaction(txn: string, isSigned: boolean): void;
+    groupTransactionsBySender(transactions: TransactionsArray): Record<string, any>;
+    sendRawTransactions(transactions: Uint8Array[]): Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: import("../types").Txn;
+        };
+        txId: string;
+        id: any;
+    }>;
+    keepWCAliveStart(): void;
+    keepWCAliveStop(): void;
+}
+export default BaseWallet;

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

@@ -0,0 +1,51 @@
+/**
+ * Helpful resources:
+ * https://github.com/blockshake-io/defly-connect
+ */
+import { providers } from "../providers";
+import type { WalletProvider, Wallet } from "../types";
+import { PROVIDER_ID } from "../constants";
+import type { Transaction } from "algosdk";
+import BaseWallet from "./base";
+import type { InitAlgodClient } from "./base";
+import { TransactionsArray } from "../types";
+import type { DeflyWalletConnect } from "@blockshake/defly-connect";
+export interface DeflyTransaction {
+    txn: Transaction;
+    /**
+     * Optional list of addresses that must sign the transactions.
+     * Wallet skips to sign this txn if signers is empty array.
+     * If undefined, wallet tries to sign it.
+     */
+    signers?: string[];
+}
+declare type InitWallet = {
+    id: PROVIDER_ID;
+    client: DeflyWalletConnect;
+    providers: typeof providers;
+};
+declare class DeflyWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    static init(): Promise<DeflyWalletClient>;
+    connect(onDisconnect: () => void): Promise<Wallet>;
+    reconnect(onDisconnect: () => void): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    disconnect(): Promise<void>;
+    formatTransactionsArray(transactions: TransactionsArray): DeflyTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+declare const _default: Promise<void | DeflyWalletClient>;
+export default _default;

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

@@ -0,0 +1,52 @@
+/**
+ * Helpful resources:
+ * https://docs.exodus.com/api-reference/algorand-provider-api/
+ */
+import BaseWallet from "./base";
+import type { InitAlgodClient } from "./base";
+import { PROVIDER_ID } from "../constants";
+import { providers } from "../providers";
+import type { WalletProvider } from "../types";
+import { TransactionsArray } from "../types";
+declare type Bytes = Readonly<Uint8Array>;
+declare type Exodus = {
+    isConnected: boolean;
+    address: string | null;
+    connect: () => Promise<{
+        address: string;
+    }>;
+    disconnect: () => void;
+    signAndSendTransaction(transactions: Bytes[]): Promise<{
+        txId: string;
+    }>;
+    signTransaction(transactions: Bytes[]): Promise<Bytes[]>;
+};
+declare type InitWallet = {
+    client: Exodus;
+    id: PROVIDER_ID;
+    providers: typeof providers;
+};
+declare class ExodusClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    static init(): Promise<ExodusClient>;
+    connect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    }>;
+    reconnect(onDisconnect: () => void): Promise<null>;
+    disconnect(): Promise<void>;
+    signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+declare const _default: Promise<void | ExodusClient>;
+export default _default;

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

@@ -0,0 +1,300 @@
+import { PROVIDER_ID } from "../constants";
+export declare const clients: {
+    "Pera Wallet": Promise<void | {
+        "__#1@#client": import("@perawallet/connect/dist/PeraWalletConnect").default;
+        id: PROVIDER_ID;
+        provider: import("..").WalletProvider;
+        connect(onDisconnect: () => void): Promise<import("..").Wallet>;
+        reconnect(onDisconnect: () => void): Promise<{
+            accounts: {
+                name: string;
+                address: string;
+                providerId: PROVIDER_ID;
+            }[];
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        } | null>;
+        disconnect(): Promise<void>;
+        formatTransactionsArray(transactions: import("..").TransactionsArray): import("./perawallet").PeraTransaction[];
+        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
+        algodClient: import("algosdk").Algodv2;
+        algosdk: typeof import("algosdk/dist/types/src/main");
+        keepWCAlive: HTMLAudioElement;
+        healthCheck(): Promise<{}>;
+        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
+        getAssets(address: string): Promise<import("..").Asset[]>;
+        waitForConfirmation(txId: string, timeout?: number): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+        }>;
+        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
+        logEncodedTransaction(txn: string, isSigned: boolean): void;
+        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
+        sendRawTransactions(transactions: Uint8Array[]): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+            id: any;
+        }>;
+        keepWCAliveStart(): void;
+        keepWCAliveStop(): void;
+    }>;
+    "MyAlgo Wallet": Promise<void | {
+        "__#2@#client": import("@randlabs/myalgo-connect").default;
+        id: PROVIDER_ID;
+        provider: import("..").WalletProvider;
+        connect(): Promise<{
+            accounts: {
+                providerId: PROVIDER_ID;
+                address: string;
+                name: string;
+            }[];
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        }>;
+        reconnect(): Promise<null>;
+        disconnect(): Promise<void>;
+        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
+        algodClient: import("algosdk").Algodv2;
+        algosdk: typeof import("algosdk/dist/types/src/main");
+        keepWCAlive: HTMLAudioElement;
+        healthCheck(): Promise<{}>;
+        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
+        getAssets(address: string): Promise<import("..").Asset[]>;
+        waitForConfirmation(txId: string, timeout?: number): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+        }>;
+        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
+        logEncodedTransaction(txn: string, isSigned: boolean): void;
+        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
+        sendRawTransactions(transactions: Uint8Array[]): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+            id: any;
+        }>;
+        keepWCAliveStart(): void;
+        keepWCAliveStop(): void;
+    }>;
+    "Algo Signer": Promise<void | {
+        "__#3@#client": {
+            connect: () => Promise<Record<string, never>>;
+            accounts: (ledger: {
+                ledger: "MainNet" | "TestNet" | "BetaNet" | "devmodenet";
+            }) => Promise<{
+                address: string;
+            }[]>;
+            signTxn: (transactions: {
+                txn: string;
+                signers?: [] | undefined;
+                multisig?: string | undefined;
+            }[]) => Promise<{
+                txID: string;
+                blob: string;
+            }[]>;
+            encoding: {
+                msgpackToBase64(transaction: Uint8Array): string;
+                byteArrayToString(transaction: Uint8Array): string;
+            };
+        };
+        id: PROVIDER_ID;
+        provider: import("..").WalletProvider;
+        connect(): Promise<{
+            accounts: {
+                name: string;
+                address: string;
+                providerId: PROVIDER_ID;
+            }[];
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        }>;
+        reconnect(onDisconnect: () => void): Promise<null>;
+        disconnect(): Promise<void>;
+        formatTransactionsArray(transactions: import("..").TransactionsArray): {
+            txn: string;
+            signers?: [] | undefined;
+            multisig?: string | undefined;
+        }[];
+        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
+        algodClient: import("algosdk").Algodv2;
+        algosdk: typeof import("algosdk/dist/types/src/main");
+        keepWCAlive: HTMLAudioElement;
+        healthCheck(): Promise<{}>;
+        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
+        getAssets(address: string): Promise<import("..").Asset[]>;
+        waitForConfirmation(txId: string, timeout?: number): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+        }>;
+        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
+        logEncodedTransaction(txn: string, isSigned: boolean): void;
+        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
+        sendRawTransactions(transactions: Uint8Array[]): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+            id: any;
+        }>;
+        keepWCAliveStart(): void;
+        keepWCAliveStop(): void;
+    }>;
+    Defly: Promise<void | {
+        "__#4@#client": import("@blockshake/defly-connect/dist/DeflyWalletConnect").default;
+        id: PROVIDER_ID;
+        provider: import("..").WalletProvider;
+        connect(onDisconnect: () => void): Promise<import("..").Wallet>;
+        reconnect(onDisconnect: () => void): Promise<{
+            accounts: {
+                name: string;
+                address: string;
+                providerId: PROVIDER_ID;
+            }[];
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        } | null>;
+        disconnect(): Promise<void>;
+        formatTransactionsArray(transactions: import("..").TransactionsArray): import("./defly").DeflyTransaction[];
+        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
+        algodClient: import("algosdk").Algodv2;
+        algosdk: typeof import("algosdk/dist/types/src/main");
+        keepWCAlive: HTMLAudioElement;
+        healthCheck(): Promise<{}>;
+        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
+        getAssets(address: string): Promise<import("..").Asset[]>;
+        waitForConfirmation(txId: string, timeout?: number): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+        }>;
+        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
+        logEncodedTransaction(txn: string, isSigned: boolean): void;
+        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
+        sendRawTransactions(transactions: Uint8Array[]): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+            id: any;
+        }>;
+        keepWCAliveStart(): void;
+        keepWCAliveStop(): void;
+    }>;
+    Exodus: Promise<void | {
+        "__#5@#client": {
+            isConnected: boolean;
+            address: string | null;
+            connect: () => Promise<{
+                address: string;
+            }>;
+            disconnect: () => void;
+            signAndSendTransaction(transactions: Readonly<Uint8Array>[]): Promise<{
+                txId: string;
+            }>;
+            signTransaction(transactions: Readonly<Uint8Array>[]): Promise<Readonly<Uint8Array>[]>;
+        };
+        id: PROVIDER_ID;
+        provider: import("..").WalletProvider;
+        connect(): Promise<{
+            accounts: {
+                name: string;
+                address: string;
+                providerId: PROVIDER_ID;
+            }[];
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        }>;
+        reconnect(onDisconnect: () => void): Promise<null>;
+        disconnect(): Promise<void>;
+        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
+        algodClient: import("algosdk").Algodv2;
+        algosdk: typeof import("algosdk/dist/types/src/main");
+        keepWCAlive: HTMLAudioElement;
+        healthCheck(): Promise<{}>;
+        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
+        getAssets(address: string): Promise<import("..").Asset[]>;
+        waitForConfirmation(txId: string, timeout?: number): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+        }>;
+        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
+        logEncodedTransaction(txn: string, isSigned: boolean): void;
+        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
+        sendRawTransactions(transactions: Uint8Array[]): Promise<{
+            "confirmed-round": number;
+            "global-state-delta": Record<string, unknown>[];
+            "pool-error": string;
+            txn: {
+                sig: Uint8Array;
+                txn: import("..").Txn;
+            };
+            txId: string;
+            id: any;
+        }>;
+        keepWCAliveStart(): void;
+        keepWCAliveStop(): void;
+    }>;
+};