solid-algo-wallets/dist/index.d.ts

Integrate multiple Algorand wallets with a SolidJS web application client

import * as solid_js from 'solid-js';
import { JSX, Accessor } from 'solid-js';
import * as algosdk from 'algosdk';
import { EncodedTransaction, Transaction, Algodv2 } from 'algosdk';

type AccountInfo = {
    address: string;
    amount: number;
    assets: AssetBalance[];
    'min-balance': number;
};
type AssetBalance = {
    amount: number;
    'asset-id': number;
    'is-frozen': boolean;
};
interface AssetData {
    id: number;
    amount: number;
    frozen: boolean;
    decimals: number;
    name?: string;
    unitName?: string;
    url?: string;
    total: number;
}
type ConfirmedTxn = {
    'confirmed-round': number;
    'global-state-delta': Record<string, unknown>[];
    'pool-error': string;
    txn: {
        sig: Uint8Array;
        txn: EncodedTransaction;
    };
};
type WalletAccount = {
    address: string;
    name: string;
};
type WalletInterface = {
    name: string;
    icon: () => JSX.Element;
    image: () => JSX.Element;
    accounts: Accessor<WalletAccount[]>;
    connect: (onDisconnect: () => void) => Promise<WalletAccount[]>;
    disconnect: (onDisconnect: () => void) => void;
    reconnect: (onDisconnect: () => void) => Promise<WalletAccount[]>;
    transactionSigner?: (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
    dispose?: () => void;
};
type NetworkConfig = {
    algodToken: string;
    algodServer: string;
    algodPort: number;
    blockExplorer?: string;
};
type NetworkName = 'MainNet' | 'TestNet' | 'BetaNet' | 'LocalNet';
type NetworkConfigs = {
    [K in NetworkName]: NetworkConfig;
};

declare const _default$1: {
    activeWallet: solid_js.Accessor<WalletInterface | undefined>;
    setActiveWallet: solid_js.Setter<WalletInterface | undefined>;
    walletName: solid_js.Accessor<string>;
    setWalletName: solid_js.Setter<string>;
    address: solid_js.Accessor<string>;
    setAddress: solid_js.Setter<string>;
    connectWallet: (wallet: WalletInterface) => Promise<void>;
    reconnectWallet: () => Promise<void>;
    disconnectWallet: () => Promise<void>;
    walletInterfaces: WalletInterface[];
    transactionSigner: (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
};

declare const _default: {
    algodClient: solid_js.Accessor<Algodv2>;
    activeNetwork: solid_js.Accessor<NetworkName>;
    setActiveNetwork: solid_js.Setter<NetworkName>;
    getAddrUrl: (addr: string) => string;
    getAppUrl: (appId: number) => string;
    getAsaUrl: (index: number) => string;
    getTxUrl: (txId: string) => string;
    getAccountInfo: (address: string) => Promise<AccountInfo>;
    getAssetData: (assetData: AssetData) => Promise<AssetData>;
    confirmTransaction: (txId: string, timeout?: number) => Promise<{
        'confirmed-round': number;
        'global-state-delta': Record<string, unknown>[];
        'pool-error': string;
        txn: {
            sig: Uint8Array;
            txn: algosdk.EncodedTransaction;
        };
        txId: string;
    }>;
    networkConfigs: NetworkConfigs;
    networkNames: NetworkName[];
};

export { type AccountInfo, type AssetBalance, type AssetData, type ConfirmedTxn, type NetworkConfig, type NetworkConfigs, type NetworkName, _default as UseNetwork, _default$1 as UseSolidAlgoWallets, type WalletAccount, type WalletInterface };