everscale-inpage-provider - v0.6.6
    Preparing search index...

    Type Alias ProviderApi<Addr>

    type ProviderApi<Addr = Address> = {
        requestPermissions: {
            input: { permissions: UniqueArray<Permission[]> };
            output: Partial<Permissions<Addr>>;
        };
        changeAccount: { output: Partial<Permissions<Addr>> };
        disconnect: Record<string, never>;
        subscribe: {
            input: {
                address: Addr;
                subscriptions: Partial<ContractUpdatesSubscription>;
            };
            output: ContractUpdatesSubscription;
        };
        unsubscribe: { input: { address: Addr } };
        unsubscribeAll: Record<string, never>;
        getProviderState: {
            output: {
                version: string;
                numericVersion: number;
                selectedConnection: string;
                networkId: number;
                supportedPermissions: UniqueArray<Permission[]>;
                permissions: Partial<Permissions<Addr>>;
                subscriptions: { [address: string]: ContractUpdatesSubscription };
            };
        };
        getFullContractState: {
            input: { address: Addr };
            output: { state: FullContractState | undefined };
        };
        computeStorageFee: {
            input: {
                state: FullContractState;
                masterchain?: boolean;
                timestamp?: number;
            };
            output: {
                storageFee: string;
                storageFeeDebt?: string;
                accountStatus: AccountStatus;
                freezeDueLimit: string;
                deleteDueLimit: string;
            };
        };
        getAccountsByCodeHash: {
            input: { codeHash: string; continuation?: string; limit?: number };
            output: { accounts: Addr[]; continuation: string | undefined };
        };
        getTransactions: {
            input: { address: Addr; continuation?: TransactionId; limit?: number };
            output: {
                transactions: Transaction<Addr>[];
                continuation: TransactionId | undefined;
                info?: TransactionsBatchInfo;
            };
        };
        getTransaction: {
            input: { hash: string };
            output: { transaction: Transaction<Addr> | undefined };
        };
        findTransaction: {
            input: { inMessageHash?: string };
            output: { transaction: Transaction<Addr> | undefined };
        };
        runLocal: {
            input: {
                address: Addr;
                cachedState?: FullContractState;
                responsible?: boolean;
                functionCall: FunctionCall<Addr>;
                withSignatureId?: boolean | number;
                withSignatureContext?: SignatureContext;
                libraries?: { [K: string]: string };
            };
            output: { output: TokensObject<Addr>
            | undefined; code: number };
        };
        executeLocal: {
            input: {
                address: Addr;
                cachedState?: FullContractState;
                stateInit?: string;
                payload?: string
                | FunctionCall<Addr>;
                messageHeader:
                    | { type: "external"; publicKey: string; withoutSignature?: boolean }
                    | {
                        type: "internal";
                        sender: Addr;
                        amount: string;
                        bounce: boolean;
                        bounced?: boolean;
                    };
                executorParams?: {
                    disableSignatureCheck?: boolean;
                    overrideBalance?: string
                    | number;
                };
            };
            output: {
                transaction: Transaction<Addr>;
                newState: FullContractState | undefined;
                output: TokensObject<Addr> | undefined;
            };
        };
        getExpectedAddress: {
            input: {
                tvc: string;
                abi: string;
                workchain?: number;
                publicKey?: string;
                initParams: TokensObject<Addr>;
            };
            output: { address: Addr; stateInit: string; hash: string };
        };
        getContractFields: {
            input: {
                address: Addr;
                abi: string;
                cachedState?: FullContractState;
                allowPartial: boolean;
            };
            output: {
                fields?: TokensObject<Addr>;
                state: FullContractState | undefined;
            };
        };
        unpackInitData: {
            input: { abi: string; data: string };
            output: { publicKey: string | undefined; initParams: TokensObject<Addr> };
        };
        getBocHash: { input: { boc: string }; output: { hash: string } };
        packIntoCell: {
            input: {
                abiVersion?: AbiVersion;
                structure: AbiParam[];
                data: TokensObject<Addr>;
            };
            output: { boc: string; hash: string };
        };
        unpackFromCell: {
            input: {
                abiVersion?: AbiVersion;
                structure: AbiParam[];
                boc: string;
                allowPartial: boolean;
            };
            output: { data: TokensObject<Addr> };
        };
        extractPublicKey: { input: { boc: string }; output: { publicKey: string } };
        codeToTvc: {
            input: { code: string };
            output: { tvc: string; hash: string };
        };
        mergeTvc: {
            input: { code: string; data: string };
            output: { tvc: string; hash: string };
        };
        splitTvc: {
            input: { tvc: string };
            output: { data: string | undefined; code: string | undefined };
        };
        setCodeSalt: {
            input: { code: string; salt: string };
            output: { code: string; hash: string };
        };
        getCodeSalt: {
            input: { code: string };
            output: { salt: string | undefined };
        };
        encodeInternalInput: { input: FunctionCall<Addr>; output: { boc: string } };
        decodeInput: {
            input: {
                body: string;
                abi: string;
                method: string | string[];
                internal: boolean;
            };
            output: { method: string; input: TokensObject<Addr> }
            | null;
        };
        decodeOutput: {
            input: { body: string; abi: string; method: string
            | string[] };
            output: { method: string; output: TokensObject<Addr> } | null;
        };
        decodeEvent: {
            input: { body: string; abi: string; event: string
            | string[] };
            output: { event: string; data: TokensObject<Addr> } | null;
        };
        decodeTransaction: {
            input: {
                transaction: Transaction<Addr>;
                abi: string;
                method: string | string[];
            };
            output: | {
                method: string;
                input: TokensObject<Addr>;
                output: TokensObject<Addr>;
            }
            | null;
        };
        decodeTransactionEvents: {
            input: { transaction: Transaction<Addr>; abi: string };
            output: { events: { event: string; data: TokensObject<Addr> }[] };
        };
        verifySignature: {
            input: {
                publicKey: string;
                dataHash: string;
                signature: string;
                withSignatureId?: boolean
                | number;
                withSignatureContext?: SignatureContext;
            };
            output: { isValid: boolean };
        };
        sendUnsignedExternalMessage: {
            input: {
                recipient: Addr;
                stateInit?: string;
                payload?: string
                | FunctionCall<Addr>;
                local?: boolean;
                executorParams?: {
                    disableSignatureCheck?: boolean;
                    overrideBalance?: string | number;
                };
            };
            output: {
                transaction: Transaction<Addr>;
                output: TokensObject<Addr> | undefined;
            };
        };
        addAsset: {
            input: {
                account: Addr;
                type: AssetType;
                params: AssetTypeParams<AssetType, Addr>;
            };
            output: { newAsset: boolean };
        };
        signData: {
            input: {
                publicKey: string;
                data: string;
                withSignatureId?: boolean
                | number;
                withSignatureContext?: SignatureContext;
            };
            output: {
                dataHash: string;
                signature: string;
                signatureHex: string;
                signatureParts: { high: string; low: string };
            };
        };
        signDataRaw: {
            input: {
                publicKey: string;
                data: string;
                withSignatureId?: boolean
                | number;
                withSignatureContext?: SignatureContext;
            };
            output: {
                signature: string;
                signatureHex: string;
                signatureParts: { high: string; low: string };
            };
        };
        encryptData: {
            input: {
                publicKey: string;
                recipientPublicKeys: string[];
                algorithm: EncryptionAlgorithm;
                data: string;
            };
            output: { encryptedData: EncryptedData[] };
        };
        decryptData: {
            input: { encryptedData: EncryptedData };
            output: { data: string };
        };
        estimateFees: {
            input: {
                sender: Addr;
                recipient: Addr;
                amount: string;
                payload?: FunctionCall<Addr>;
                stateInit?: string;
            };
            output: { fees: string };
        };
        sendMessage: {
            input: {
                sender: Addr;
                recipient: Addr;
                amount: string;
                bounce: boolean;
                payload?: FunctionCall<Addr>;
                stateInit?: string;
                ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
                ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
            };
            output: { transaction: Transaction<Addr> };
        };
        sendMessageDelayed: {
            input: {
                sender: Addr;
                recipient: Addr;
                amount: string;
                bounce: boolean;
                payload?: FunctionCall<Addr>;
                stateInit?: string;
                ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
                ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
            };
            output: { message: DelayedMessage<Addr> };
        };
        sendExternalMessage: {
            input: {
                publicKey: string;
                recipient: Addr;
                stateInit?: string;
                payload: FunctionCall<Addr>;
                local?: boolean;
                executorParams?: {
                    disableSignatureCheck?: boolean;
                    overrideBalance?: string | number;
                };
            };
            output: {
                transaction: Transaction<Addr>;
                output: TokensObject<Addr> | undefined;
            };
        };
        sendExternalMessageDelayed: {
            input: {
                publicKey: string;
                recipient: Addr;
                stateInit?: string;
                payload: FunctionCall<Addr>;
            };
            output: { message: DelayedMessage<Addr> };
        };
        addNetwork: {
            input: { network: AddNetwork; switchNetwork?: boolean };
            output: { network: Network | null };
        };
        changeNetwork: {
            input: { networkId: number };
            output: { network: Network | null };
        };
        runGetter: {
            input: {
                address: Addr;
                cachedState?: FullContractState;
                getterCall: GetterCall<Addr>;
                withSignatureId?: boolean | number;
                withSignatureContext?: SignatureContext;
                libraries?: { [K: string]: string };
            };
            output: { output: TokensObject<Addr>
            | undefined; code: number };
        };
    }

    Type Parameters

    Index

    Properties

    requestPermissions changeAccount disconnect subscribe unsubscribe unsubscribeAll getProviderState getFullContractState computeStorageFee getAccountsByCodeHash getTransactions getTransaction findTransaction runLocal executeLocal getExpectedAddress getContractFields unpackInitData getBocHash packIntoCell unpackFromCell extractPublicKey codeToTvc mergeTvc splitTvc setCodeSalt getCodeSalt encodeInternalInput decodeInput decodeOutput decodeEvent decodeTransaction decodeTransactionEvents verifySignature sendUnsignedExternalMessage addAsset signData signDataRaw encryptData decryptData estimateFees sendMessage sendMessageDelayed sendExternalMessage sendExternalMessageDelayed addNetwork changeNetwork runGetter

    Properties

    requestPermissions: {
        input: { permissions: UniqueArray<Permission[]> };
        output: Partial<Permissions<Addr>>;
    }

    Requests new permissions for current origin. Shows an approval window to the user. Will overwrite already existing permissions

    Required permissions: none

    changeAccount: { output: Partial<Permissions<Addr>> }

    Updates accountInteraction permission value

    Requires permissions: accountInteraction

    disconnect: Record<string, never>

    Removes all permissions for current origin and stops all subscriptions

    Required permissions: none

    subscribe: {
        input: {
            address: Addr;
            subscriptions: Partial<ContractUpdatesSubscription>;
        };
        output: ContractUpdatesSubscription;
    }

    Subscribes to contract updates. Can also be used to update subscriptions

    Required permissions: basic

    unsubscribe: { input: { address: Addr } }

    Fully unsubscribe from specific contract updates

    Required permissions: none

    unsubscribeAll: Record<string, never>

    Fully unsubscribe from all contracts

    Required permissions: none

    getProviderState: {
        output: {
            version: string;
            numericVersion: number;
            selectedConnection: string;
            networkId: number;
            supportedPermissions: UniqueArray<Permission[]>;
            permissions: Partial<Permissions<Addr>>;
            subscriptions: { [address: string]: ContractUpdatesSubscription };
        };
    }

    Returns provider api state

    Required permissions: none

    getFullContractState: {
        input: { address: Addr };
        output: { state: FullContractState | undefined };
    }

    Requests contract data

    Required permissions: basic

    computeStorageFee: {
        input: {
            state: FullContractState;
            masterchain?: boolean;
            timestamp?: number;
        };
        output: {
            storageFee: string;
            storageFeeDebt?: string;
            accountStatus: AccountStatus;
            freezeDueLimit: string;
            deleteDueLimit: string;
        };
    }

    Compute storage fee

    Required permissions: basic

    getAccountsByCodeHash: {
        input: { codeHash: string; continuation?: string; limit?: number };
        output: { accounts: Addr[]; continuation: string | undefined };
    }

    Requests accounts with specified code hash

    Required permissions: basic

    getTransactions: {
        input: { address: Addr; continuation?: TransactionId; limit?: number };
        output: {
            transactions: Transaction<Addr>[];
            continuation: TransactionId | undefined;
            info?: TransactionsBatchInfo;
        };
    }

    Requests contract transactions

    Required permissions: basic

    getTransaction: {
        input: { hash: string };
        output: { transaction: Transaction<Addr> | undefined };
    }

    Fetches transaction by the exact hash

    Required permissions: basic

    findTransaction: {
        input: { inMessageHash?: string };
        output: { transaction: Transaction<Addr> | undefined };
    }

    Searches transaction by filters

    NOTE: at least one filter must be specified

    Required permissions: basic

    runLocal: {
        input: {
            address: Addr;
            cachedState?: FullContractState;
            responsible?: boolean;
            functionCall: FunctionCall<Addr>;
            withSignatureId?: boolean | number;
            withSignatureContext?: SignatureContext;
            libraries?: { [K: string]: string };
        };
        output: { output: TokensObject<Addr>
        | undefined; code: number };
    }

    Executes only a compute phase locally

    Required permissions: basic

    executeLocal: {
        input: {
            address: Addr;
            cachedState?: FullContractState;
            stateInit?: string;
            payload?: string | FunctionCall<Addr>;
            messageHeader:
                | { type: "external"; publicKey: string; withoutSignature?: boolean }
                | {
                    type: "internal";
                    sender: Addr;
                    amount: string;
                    bounce: boolean;
                    bounced?: boolean;
                };
            executorParams?: {
                disableSignatureCheck?: boolean;
                overrideBalance?: string
                | number;
            };
        };
        output: {
            transaction: Transaction<Addr>;
            newState: FullContractState | undefined;
            output: TokensObject<Addr> | undefined;
        };
    }

    Executes all transaction phases locally, producing a new state

    Required permissions: basic

    getExpectedAddress: {
        input: {
            tvc: string;
            abi: string;
            workchain?: number;
            publicKey?: string;
            initParams: TokensObject<Addr>;
        };
        output: { address: Addr; stateInit: string; hash: string };
    }

    Calculates contract address from code and init params

    Required permissions: basic

    getContractFields: {
        input: {
            address: Addr;
            abi: string;
            cachedState?: FullContractState;
            allowPartial: boolean;
        };
        output: {
            fields?: TokensObject<Addr>;
            state: FullContractState | undefined;
        };
    }

    Unpacks all fields from the contract state using the specified ABI

    Required permissions: basic

    unpackInitData: {
        input: { abi: string; data: string };
        output: { publicKey: string | undefined; initParams: TokensObject<Addr> };
    }

    Decodes initial contract data using the specified ABI

    Required permissions: basic

    getBocHash: { input: { boc: string }; output: { hash: string } }

    Computes hash of base64 encoded BOC

    Required permissions: basic

    packIntoCell: {
        input: {
            abiVersion?: AbiVersion;
            structure: AbiParam[];
            data: TokensObject<Addr>;
        };
        output: { boc: string; hash: string };
    }

    Creates base64 encoded BOC

    Required permissions: basic

    unpackFromCell: {
        input: {
            abiVersion?: AbiVersion;
            structure: AbiParam[];
            boc: string;
            allowPartial: boolean;
        };
        output: { data: TokensObject<Addr> };
    }

    Decodes base64 encoded BOC

    Required permissions: basic

    extractPublicKey: { input: { boc: string }; output: { publicKey: string } }

    Extracts public key from raw account state

    NOTE: can only be used on contracts which are deployed and has pubkey header

    Required permissions: basic

    codeToTvc: { input: { code: string }; output: { tvc: string; hash: string } }

    Converts base64 encoded contract code into tvc with default init data

    Required permissions: basic

    mergeTvc: {
        input: { code: string; data: string };
        output: { tvc: string; hash: string };
    }

    Merges base64 encoded contract code and state into a tvc

    Required permissions: basic

    splitTvc: {
        input: { tvc: string };
        output: { data: string | undefined; code: string | undefined };
    }

    Splits base64 encoded state init into code and data

    Required permissions: basic

    setCodeSalt: {
        input: { code: string; salt: string };
        output: { code: string; hash: string };
    }

    Inserts salt into code

    Required permissions: basic

    getCodeSalt: { input: { code: string }; output: { salt: string | undefined } }

    Retrieves salt from code. Returns undefined if code doesn't contain salt

    Required permissions: basic

    encodeInternalInput: { input: FunctionCall<Addr>; output: { boc: string } }

    Creates internal message body

    Required permissions: basic

    decodeInput: {
        input: {
            body: string;
            abi: string;
            method: string | string[];
            internal: boolean;
        };
        output: { method: string; input: TokensObject<Addr> }
        | null;
    }

    Decodes body of incoming message

    Required permissions: basic

    decodeOutput: {
        input: { body: string; abi: string; method: string | string[] };
        output: { method: string; output: TokensObject<Addr> } | null;
    }

    Decodes body of outgoing message

    Required permissions: basic

    decodeEvent: {
        input: { body: string; abi: string; event: string | string[] };
        output: { event: string; data: TokensObject<Addr> } | null;
    }

    Decodes body of event message

    Required permissions: basic

    decodeTransaction: {
        input: {
            transaction: Transaction<Addr>;
            abi: string;
            method: string | string[];
        };
        output: | {
            method: string;
            input: TokensObject<Addr>;
            output: TokensObject<Addr>;
        }
        | null;
    }

    Decodes function call

    Required permissions: basic

    decodeTransactionEvents: {
        input: { transaction: Transaction<Addr>; abi: string };
        output: { events: { event: string; data: TokensObject<Addr> }[] };
    }

    Decodes transaction events

    Required permissions: basic

    verifySignature: {
        input: {
            publicKey: string;
            dataHash: string;
            signature: string;
            withSignatureId?: boolean | number;
            withSignatureContext?: SignatureContext;
        };
        output: { isValid: boolean };
    }

    Checks if a specific data hash was signed with the specified key

    Requires permissions: basic

    sendUnsignedExternalMessage: {
        input: {
            recipient: Addr;
            stateInit?: string;
            payload?: string | FunctionCall<Addr>;
            local?: boolean;
            executorParams?: {
                disableSignatureCheck?: boolean;
                overrideBalance?: string | number;
            };
        };
        output: {
            transaction: Transaction<Addr>;
            output: TokensObject<Addr> | undefined;
        };
    }

    Sends an unsigned external message to the contract

    Required permissions: basic

    addAsset: {
        input: {
            account: Addr;
            type: AssetType;
            params: AssetTypeParams<AssetType, Addr>;
        };
        output: { newAsset: boolean };
    }

    Adds asset to the selected account

    Requires permissions: accountInteraction

    signData: {
        input: {
            publicKey: string;
            data: string;
            withSignatureId?: boolean | number;
            withSignatureContext?: SignatureContext;
        };
        output: {
            dataHash: string;
            signature: string;
            signatureHex: string;
            signatureParts: { high: string; low: string };
        };
    }

    Signs arbitrary data.

    NOTE: hashes data before signing. Use signDataRaw to sign without hash.

    Requires permissions: accountInteraction

    signDataRaw: {
        input: {
            publicKey: string;
            data: string;
            withSignatureId?: boolean | number;
            withSignatureContext?: SignatureContext;
        };
        output: {
            signature: string;
            signatureHex: string;
            signatureParts: { high: string; low: string };
        };
    }

    Signs arbitrary data without hashing it

    Requires permissions: accountInteraction

    encryptData: {
        input: {
            publicKey: string;
            recipientPublicKeys: string[];
            algorithm: EncryptionAlgorithm;
            data: string;
        };
        output: { encryptedData: EncryptedData[] };
    }

    Encrypts arbitrary data with specified algorithm for each specified recipient

    Requires permissions: accountInteraction

    decryptData: {
        input: { encryptedData: EncryptedData };
        output: { data: string };
    }

    Decrypts encrypted data

    Requires permissions: accountInteraction

    estimateFees: {
        input: {
            sender: Addr;
            recipient: Addr;
            amount: string;
            payload?: FunctionCall<Addr>;
            stateInit?: string;
        };
        output: { fees: string };
    }

    Calculates transaction fees

    Required permissions: accountInteraction

    sendMessage: {
        input: {
            sender: Addr;
            recipient: Addr;
            amount: string;
            bounce: boolean;
            payload?: FunctionCall<Addr>;
            stateInit?: string;
            ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
            ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
        };
        output: { transaction: Transaction<Addr> };
    }

    Sends an internal message from the user account. Shows an approval window to the user.

    Required permissions: accountInteraction

    sendMessageDelayed: {
        input: {
            sender: Addr;
            recipient: Addr;
            amount: string;
            bounce: boolean;
            payload?: FunctionCall<Addr>;
            stateInit?: string;
            ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
            ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Addr>[];
        };
        output: { message: DelayedMessage<Addr> };
    }

    Sends an internal message from the user account without waiting for the transaction. Shows an approval window to the user.

    messageStatusUpdated

    Required permissions: accountInteraction

    sendExternalMessage: {
        input: {
            publicKey: string;
            recipient: Addr;
            stateInit?: string;
            payload: FunctionCall<Addr>;
            local?: boolean;
            executorParams?: {
                disableSignatureCheck?: boolean;
                overrideBalance?: string | number;
            };
        };
        output: {
            transaction: Transaction<Addr>;
            output: TokensObject<Addr> | undefined;
        };
    }

    Sends an external message to the contract Shows and approval window to the user

    Required permissions: accountInteraction

    sendExternalMessageDelayed: {
        input: {
            publicKey: string;
            recipient: Addr;
            stateInit?: string;
            payload: FunctionCall<Addr>;
        };
        output: { message: DelayedMessage<Addr> };
    }

    Sends an external message to the contract without waiting for the transaction. Shows and approval window to the user

    messageStatusUpdated

    Required permissions: accountInteraction

    addNetwork: {
        input: { network: AddNetwork; switchNetwork?: boolean };
        output: { network: Network | null };
    }

    Request user to add a new network. Shows an approval window to the user.

    Required permissions: basic

    changeNetwork: {
        input: { networkId: number };
        output: { network: Network | null };
    }

    Request user to change selected network. Shows an approval window to the user.

    Required permissions: basic

    runGetter: {
        input: {
            address: Addr;
            cachedState?: FullContractState;
            getterCall: GetterCall<Addr>;
            withSignatureId?: boolean | number;
            withSignatureContext?: SignatureContext;
            libraries?: { [K: string]: string };
        };
        output: { output: TokensObject<Addr>
        | undefined; code: number };
    }

    Execute getter of the contract

    Required permissions: basic

    Settings

    Member Visibility

    On This Page

    Properties