@luffalab/luffa-tron-sdk/src/types.ts

luffa tron ts sdk

import type tronWebModule from 'tronWeb';
import type { TronWeb } from 'tronWeb';
type TronWebSDK = typeof tronWebModule;
export enum Network {
  MAINNET = "mainnet",
  TESTNET = "testnet",
	ETH = 'eth',
	BSC = 'bsc',
}
export type IInitData = {
	colorMode?: 'light' | 'dark';
	network: Network | string;
	fullnode?: string;
	indexer?: string;
	walletUrl?: string;
	prover?: string;
	callbackWalletName?: string;
	miniprogram?: Boolean;
	windowWidth?: number;
};

export type ChainData = {
	targetNet: 'endless' | 'eds' | 'eth' | 'eth_sepolia' | 'bsc' | 'bsc_testnet' | 'tron' | 'tron_nile';
}

export enum UserResponseStatus {
	APPROVED = 'Approved',
	REJECTED = 'Rejected'
}

export interface UserApproval<TResponseArgs> {
	status: UserResponseStatus.APPROVED;
	args: TResponseArgs;
}

export interface UserRejection {
	status: UserResponseStatus.REJECTED;
	message?: string;
}

export type UserResponse<TResponseArgs> = UserApproval<TResponseArgs> | UserRejection;

export interface AccountInfo {
	account: string;
	address: string;
	authKey: string;
	ansName?: string;
}

export interface NetworkInfo {
	name: Network | string;
	chainId: number;
	url?: string;
}

export type EndlessSignMessageInput = {
	address?: boolean;
	application?: boolean;
	chainId?: boolean;
	message: string;
	nonce?: string;
};

export type EndlessSignMessageOutput = {
	address?: string;
	application?: string;
	chainId?: number;
	fullMessage: string;
	publicKey: string;
	message: string;
	nonce: string;
	prefix: 'Endless';
	signature: '';
};

export interface EndlessSignAndSubmitTransactionInput {
	gasUnitPrice?: number; // defaults to estimated gas unit price
	maxGasAmount?: number; // defaults to estimated max gas amount
	payload: ''; // the transaction payload
	options?: '';
}

export enum EndlessSendTransactionType {
	SIGNATURE_ONLY = 'signatureOnly',
	SIGN_AND_SUBMIT = 'signAndSubmit'
}

export enum EndlessWalletTransactionType {
	SIMPLE = 'simple',
	MULTI_AGENT = 'multiAgent'
}
interface TronRequestArguments {
	readonly method: string;
	readonly params?: unknown[] | object;
}
interface ProviderRpcError extends Error {
	code: number;
	message: string;
	data?: unknown;
}
type TronEvent = 'connect' | 'disconnect' | 'chainChanged' | 'accountsChanged';
export type TronConnectCallback = (data: { chainId: string }) => void;
export type TronChainChangedCallback = TronConnectCallback;
export type TronDisconnectCallback = (error: ProviderRpcError) => void;
export type TronAccountsChangedCallback = (data: [string?]) => void;
export interface Tron {
	request(args: { method: 'eth_requestAccounts' }): Promise<[string]>;
	request(args: TronRequestArguments): Promise<unknown>;

	on(event: 'connect', cb: TronConnectCallback): void;
	on(event: 'disconnect', cb: TronDisconnectCallback): void;
	on(event: 'chainChanged', cb: TronChainChangedCallback): void;
	on(event: 'accountsChanged', cb: TronAccountsChangedCallback): void;

	removeListener(event: TronEvent, cb: unknown): void;
	tronWeb: TronWeb | false;
	isTronLink: boolean;
}

declare global {
	const tronWeb: TronWeb;
	const TronWeb: TronWebSDK;
	const wx: any

	interface Window {
		wx: any;
		webkit: any;
		endlessWallet?: {
			sendResponse: (response: any) => void;
		};
		_endlessWallet?: {
			sendMessage: (data: any) => void;
		};
		WeixinJSBridge: {
			invoke(api: string, data: any, callback: (res: any) => void): void;
			on(api: string, callback: (res: any) => void): void;
		},
		tronWallet?: {
			sendResponse: (response: any) => void;
		},
		_tronWallet?: {
			sendMessage: (data: any) => void;
		},
		tron: Tron;
		tronWeb: TronWeb;
		TronWeb: TronWebSDK;
	}
}