@luffalab/luffa-endless-sdk/dist/miniprogram/index.d.mts

luffa endless ts sdk

import { Signature, InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from '@endlesslab/endless-ts-sdk';

declare enum Network {
    MAINNET = "mainnet",
    TESTNET = "testnet",
    ETH = "eth",
    BSC = "bsc"
}
type IInitData = {
    colorMode?: 'light' | 'dark';
    network: Network | string;
    fullnode?: string;
    indexer?: string;
    walletUrl?: string;
    prover?: string;
    miniprogram?: Boolean;
    windowWidth?: number;
};
declare enum UserResponseStatus {
    APPROVED = "Approved",
    REJECTED = "Rejected"
}
interface UserApproval<TResponseArgs> {
    status: UserResponseStatus.APPROVED;
    args: TResponseArgs;
}
interface UserRejection {
    status: UserResponseStatus.REJECTED;
    message?: string;
}
type UserResponse<TResponseArgs> = UserApproval<TResponseArgs> | UserRejection;
interface AccountInfo {
    account: string;
    address: string;
    authKey: string;
    ansName?: string;
}
interface NetworkInfo {
    name: Network | string;
    chainId: number;
    url?: string;
}
type EndlessSignMessageInput = {
    address?: boolean;
    application?: boolean;
    chainId?: boolean;
    message: string;
    nonce?: string;
};
type EndlessSignMessageOutput = {
    address?: string;
    application?: string;
    chainId?: number;
    fullMessage: string;
    publicKey: string;
    message: string;
    nonce: string;
    prefix: 'Endless';
    signature: Signature;
};
interface EndlessSignAndSubmitTransactionInput {
    gasUnitPrice?: number;
    maxGasAmount?: number;
    payload: InputGenerateTransactionPayloadData;
    options?: InputGenerateTransactionOptions;
}
declare enum EndlessSendTransactionType {
    SIGNATURE_ONLY = "signatureOnly",
    SIGN_AND_SUBMIT = "signAndSubmit"
}
declare enum EndlessWalletTransactionType {
    SIMPLE = "simple",
    MULTI_AGENT = "multiAgent"
}
declare global {
    interface Window {
        wx: any;
        webkit: any;
        WeixinJSBridge: {
            invoke(api: string, data: any, callback: (res: any) => void): void;
            on(api: string, callback: (res: any) => void): void;
        };
        endlessWallet?: {
            sendResponse: (response: any) => void;
        };
        _endlessWallet?: {
            sendMessage: (data: any) => void;
        };
    }
}

interface IRequestData {
    method: MethodName;
    data?: unknown;
    initData?: IInitData;
}
declare enum EndLessSDKEvent {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    ACCOUNT_CHANGE = "accountChange",
    NETWORK_CHANGE = "networkChange"
}
type EndLessSDKEventType = (typeof EndLessSDKEvent)[keyof typeof EndLessSDKEvent];
interface EndLessSDKEventsMap {
    [EndLessSDKEvent.CONNECT]: AccountInfo;
    [EndLessSDKEvent.DISCONNECT]: void;
    [EndLessSDKEvent.ACCOUNT_CHANGE]: AccountInfo;
    [EndLessSDKEvent.GETACCOUNT]: AccountInfo[];
    [EndLessSDKEvent.GETACCOUNT]: AccountInfo[];
    [EndLessSDKEvent.NETWORK_CHANGE]: NetworkInfo;
}
type EndLessSDKEventPayload<T extends EndLessSDKEventType> = T extends keyof EndLessSDKEventsMap ? EndLessSDKEventsMap[T] : undefined;

declare const isLuffa: () => boolean;
declare const isLuffaMiniProgramWebview: () => boolean;
declare const isLuffaMiniProgram: () => any;

interface Metadata {
    title: string;
    url: string;
    origin: string;
    icon: string;
    gameId: string;
    userId: string;
    walletAddress: string;
}

declare enum MethodName {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    NETWORK_CHANGE = "switchNetwork",
    SIGN_MESSAGE = "signMessage",
    SEND_TRANSACTION = "sendTransaction",
    SIGN_AND_SUBMIT_TRANSACTION = "signAndSubmitTransaction",
    SIGN_BUILD_TRANSACTION = "signBuildTransaction",
    ACCOUNT_CHANGE = "accountChange"
}
declare class EndlessLuffaSdk {
    static readonly version: string;
    private static _instance;
    private message;
    private _metadata;
    private _initData;
    private _endless;
    private _endlessConfig;
    private accountAddress;
    static getIninData: () => IInitData;
    static getAccountAddress: () => string | null;
    static setAccountAddress: (accountAddress: string | null) => void;
    constructor(initData: IInitData);
    private initConfig;
    private initWalletEvent;
    changeNetwork(initData: IInitData): void;
    private getMetadata;
    request: (data: IRequestData, callback?: (data: unknown) => void) => void;
    getAccount: () => Promise<UserResponse<AccountInfo>>;
    connect: (callback?: (data: AccountInfo) => void) => Promise<UserResponse<AccountInfo>>;
    disconnect: (callback?: (data: unknown) => void) => Promise<void>;
    signMessage: (data: EndlessSignMessageInput, callback?: (data: unknown) => void) => Promise<UserResponse<EndlessSignMessageOutput>>;
    on: <K extends EndLessSDKEventType>(methodName: K, callback: (payload: EndLessSDKEventPayload<K>) => void) => void;
    off: <K extends EndLessSDKEventType>(methodName: K, callback?: (payload: EndLessSDKEventPayload<K>) => void) => void;
    signAndSubmitTransaction: (data: EndlessSignAndSubmitTransactionInput) => Promise<UserResponse<{
        hash: string;
    }>>;
    signTransaction: (transactionHex: string, transactionType?: EndlessWalletTransactionType) => Promise<UserResponse<{
        data: string;
    }>>;
    onAccountChange: (callback: (data: AccountInfo) => void) => void;
    onNetworkChange: (callback: (data: NetworkInfo) => void) => void;
}

export { type AccountInfo, EndLessSDKEvent, EndlessLuffaSdk, EndlessSendTransactionType, type EndlessSignAndSubmitTransactionInput, EndlessWalletTransactionType, type Metadata, MethodName, type UserResponse, UserResponseStatus, isLuffa, isLuffaMiniProgram, isLuffaMiniProgramWebview };