@txnlab/use-wallet 0.0.1

package/dist/esm/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/esm/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;
+    }>;
+};

package/dist/esm/clients/myalgowallet.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Helpful resources:
+ * https://github.com/randlabs/myalgo-connect
+ */
+import BaseWallet from "./base";
+import type MyAlgoConnect from "@randlabs/myalgo-connect";
+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 InitWallet = {
+    id: PROVIDER_ID;
+    client: MyAlgoConnect;
+    providers: typeof providers;
+};
+declare class MyAlgoWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    static init(): Promise<MyAlgoWalletClient>;
+    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: TransactionsArray): Promise<Uint8Array[]>;
+}
+declare const _default: Promise<void | MyAlgoWalletClient>;
+export default _default;

package/dist/esm/clients/perawallet.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Helpful resources:
+ * https://github.com/perawallet/connect
+ */
+import { providers } from "../providers";
+import type { PeraWalletConnect } from "@perawallet/connect";
+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";
+export interface PeraTransaction {
+    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: PeraWalletConnect;
+    providers: typeof providers;
+};
+declare class PeraWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    static init(): Promise<PeraWalletClient>;
+    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): PeraTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+declare const _default: Promise<void | PeraWalletClient>;
+export default _default;

package/dist/esm/constants/constants.d.ts

@@ -0,0 +1,10 @@
+export declare enum PROVIDER_ID {
+    PERA_WALLET = "Pera Wallet",
+    MYALGO_WALLET = "MyAlgo Wallet",
+    ALGO_SIGNER = "Algo Signer",
+    DEFLY = "Defly",
+    EXODUS = "Exodus"
+}
+export declare const NODE_SERVER = "https://node.algoexplorerapi.io";
+export declare const NODE_TOKEN = "";
+export declare const NODE_PORT = "";

package/dist/esm/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./constants";

package/dist/esm/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useWallet } from "./useWallet";
+export { default as useConnectWallet } from "./useConnectWallet";

package/dist/esm/hooks/useConnectWallet.d.ts

@@ -0,0 +1,22 @@
+import type { PROVIDER_ID } from "../types";
+export default function useConnectWallet(): {
+    providers: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isActive: boolean;
+        isConnected: boolean;
+        isWalletConnect: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActive: () => Promise<void>;
+    }[];
+    activeAccount: import("../types").Account | null;
+    accounts: import("../types").Account[];
+    connect: (id: PROVIDER_ID) => Promise<void>;
+    reconnect: (id: PROVIDER_ID) => Promise<void>;
+    disconnect: (id: PROVIDER_ID) => Promise<void>;
+    setActive: (id: PROVIDER_ID) => Promise<void>;
+    reconnectProviders: () => Promise<void>;
+};

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

@@ -0,0 +1,10 @@
+import { PROVIDER_ID } from "../types";
+export { PROVIDER_ID };
+export default function useWallet(): {
+    accounts: import("../types").Account[];
+    activeAccount: import("../types").Account | null;
+    signTransactions: (transactions: Array<Uint8Array>) => Promise<Uint8Array[]>;
+    sendTransactions: (transactions: Uint8Array[]) => Promise<import("../types").ConfirmedTxn & {
+        id: string;
+    }>;
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { useWallet, useConnectWallet } from "./hooks";
+export * from "./constants";
+export * from "./types";