@pendulum-chain/api-solang/build/types/index.d.ts

Interface to interact with smart contracts compiled via Solang

import { ApiPromise } from "@polkadot/api";
import { Hash, Weight } from "@polkadot/types/interfaces";
import { AnyJson } from "@polkadot/types-codec/types";
import { Abi } from "@polkadot/api-contract";
import { PanicCode } from "./contractRpc.js";
import { Extrinsic, GenericSigner, KeyPairSigner, SubmitExtrinsicStatus, SubmitExtrinsicResult, signAndSubmitExtrinsic, submitExtrinsic, signExtrinsic } from "./submitExtrinsic.js";
export { PanicCode, Extrinsic, GenericSigner, KeyPairSigner, SubmitExtrinsicStatus, SubmitExtrinsicResult, signExtrinsic, submitExtrinsic, signAndSubmitExtrinsic, };
export type Address = string;
export interface Limits {
    gas: {
        refTime: string | number;
        proofSize: string | number;
    };
    storageDeposit?: string | number;
}
export interface DecodedContractEvent {
    eventIdentifier: string;
    args: {
        name: string;
        value: AnyJson;
    }[];
}
export interface ContractEvent {
    emittingContractAddress: Address;
    data: Uint8Array;
    decoded?: DecodedContractEvent;
}
export interface DeployContractOptions {
    abi: Abi;
    api: ApiPromise;
    signer: KeyPairSigner | GenericSigner;
    constructorArguments: unknown[];
    constructorName?: string;
    limits: Limits;
    skipDryRunning?: boolean;
    modifyExtrinsic?: (extrinsic: Extrinsic) => Extrinsic;
    lookupAbi?: (contractAddress: Address) => Abi | undefined;
}
export type DeployContractResult = {
    type: "success";
    events: ContractEvent[];
    deploymentAddress: Address;
    transactionFee: bigint | undefined;
} | {
    type: "error";
    error: string;
} | {
    type: "reverted";
    description: string;
} | {
    type: "panic";
    errorCode: PanicCode;
    explanation: string;
};
export interface CreateExecuteMessageExtrinsicOptions {
    abi: Abi;
    api: ApiPromise;
    contractDeploymentAddress: Address;
    callerAddress: Address;
    messageName: string;
    messageArguments: unknown[];
    limits: Limits;
    gasLimitTolerancePercentage?: number;
    skipDryRunning?: boolean;
}
export type CreateExecuteMessageExtrinsicResult = {
    execution: {
        type: "onlyRpc";
    } | {
        type: "extrinsic";
        extrinsic: Extrinsic;
    };
    result?: ReadMessageResult;
};
export interface ExecuteMessageOptions extends CreateExecuteMessageExtrinsicOptions {
    getSigner: () => Promise<KeyPairSigner | GenericSigner>;
    modifyExtrinsic?: (extrinsic: Extrinsic) => Extrinsic;
    lookupAbi?: (contractAddress: Address) => Abi | undefined;
}
export type ExecuteMessageResult = {
    execution: {
        type: "onlyRpc";
    } | {
        type: "extrinsic";
        contractEvents: ContractEvent[];
        transactionFee: bigint | undefined;
        txHash: Hash;
        txIndex?: number | undefined;
    };
    result?: ReadMessageResult;
};
export interface ReadMessageOptions {
    abi: Abi;
    api: ApiPromise;
    contractDeploymentAddress: Address;
    callerAddress: Address;
    messageName: string;
    messageArguments: unknown[];
    limits: Limits;
}
export type GasMetrics = {
    gasRequired: Weight;
    gasConsumed: Weight;
};
export type ReadMessageResult = {
    type: "success";
    gasMetrics: GasMetrics;
    value: any;
} | {
    type: "error";
    gasMetrics: GasMetrics;
    error: string;
} | {
    type: "reverted";
    gasMetrics: GasMetrics;
    description: string;
} | {
    type: "panic";
    gasMetrics: GasMetrics;
    errorCode: PanicCode;
    explanation: string;
};
export declare function deployContract({ signer, api, abi, constructorArguments, constructorName, limits, skipDryRunning, modifyExtrinsic, lookupAbi, }: DeployContractOptions): Promise<DeployContractResult>;
export declare function executeMessage(options: ExecuteMessageOptions): Promise<ExecuteMessageResult>;
export declare function createExecuteMessageExtrinsic({ abi, api, contractDeploymentAddress, messageArguments, messageName, limits, callerAddress, gasLimitTolerancePercentage, skipDryRunning, }: CreateExecuteMessageExtrinsicOptions): Promise<CreateExecuteMessageExtrinsicResult>;
export declare function submitExecuteMessageExtrinsic(extrinsic: Extrinsic, lookupAbi?: (contractAddress: Address) => Abi | undefined): Promise<{
    contractEvents: ContractEvent[];
    transactionFee: bigint | undefined;
    status: SubmitExtrinsicStatus;
}>;
export declare function readMessage({ abi, api, contractDeploymentAddress, callerAddress, messageName, messageArguments, limits, }: ReadMessageOptions): Promise<ReadMessageResult>;