wowok/dist/cjs/grpc/proto/sui/rpc/v2/transaction.d.ts

Wowok Blockchain TypeScript API

import { MessageType } from "@protobuf-ts/runtime";
import { Duration } from "../../../google/protobuf/duration.js";
import { Object } from "./object.js";
import { Timestamp } from "../../../google/protobuf/timestamp.js";
import { Argument } from "./argument.js";
import { Input } from "./input.js";
import { ObjectReference } from "./object_reference.js";
import { Bcs } from "./bcs.js";
export interface Transaction {
    bcs?: Bcs;
    digest?: string;
    version?: number;
    kind?: TransactionKind;
    sender?: string;
    gasPayment?: GasPayment;
    expiration?: TransactionExpiration;
}
export interface GasPayment {
    objects: ObjectReference[];
    owner?: string;
    price?: bigint;
    budget?: bigint;
}
export interface TransactionExpiration {
    kind?: TransactionExpiration_TransactionExpirationKind;
    epoch?: bigint;
}
export declare enum TransactionExpiration_TransactionExpirationKind {
    TRANSACTION_EXPIRATION_KIND_UNKNOWN = 0,
    NONE = 1,
    EPOCH = 2
}
export interface TransactionKind {
    kind?: TransactionKind_Kind;
    data: {
        oneofKind: "programmableTransaction";
        programmableTransaction: ProgrammableTransaction;
    } | {
        oneofKind: "changeEpoch";
        changeEpoch: ChangeEpoch;
    } | {
        oneofKind: "genesis";
        genesis: GenesisTransaction;
    } | {
        oneofKind: "consensusCommitPrologue";
        consensusCommitPrologue: ConsensusCommitPrologue;
    } | {
        oneofKind: "endOfEpoch";
        endOfEpoch: EndOfEpochTransaction;
    } | {
        oneofKind: "randomnessStateUpdate";
        randomnessStateUpdate: RandomnessStateUpdate;
    } | {
        oneofKind: undefined;
    };
}
export declare enum TransactionKind_Kind {
    KIND_UNKNOWN = 0,
    PROGRAMMABLE_TRANSACTION = 1,
    CHANGE_EPOCH = 2,
    GENESIS = 3,
    CONSENSUS_COMMIT_PROLOGUE_V1 = 4,
    END_OF_EPOCH = 5,
    RANDOMNESS_STATE_UPDATE = 6,
    CONSENSUS_COMMIT_PROLOGUE_V2 = 7,
    CONSENSUS_COMMIT_PROLOGUE_V3 = 8,
    CONSENSUS_COMMIT_PROLOGUE_V4 = 9
}
export interface ProgrammableTransaction {
    inputs: Input[];
    commands: Command[];
}
export interface Command {
    command: {
        oneofKind: "moveCall";
        moveCall: MoveCall;
    } | {
        oneofKind: "transferObjects";
        transferObjects: TransferObjects;
    } | {
        oneofKind: "splitCoins";
        splitCoins: SplitCoins;
    } | {
        oneofKind: "mergeCoins";
        mergeCoins: MergeCoins;
    } | {
        oneofKind: "publish";
        publish: Publish;
    } | {
        oneofKind: "makeMoveVector";
        makeMoveVector: MakeMoveVector;
    } | {
        oneofKind: "upgrade";
        upgrade: Upgrade;
    } | {
        oneofKind: undefined;
    };
}
export interface MoveCall {
    package?: string;
    module?: string;
    function?: string;
    typeArguments: string[];
    arguments: Argument[];
}
export interface TransferObjects {
    objects: Argument[];
    address?: Argument;
}
export interface SplitCoins {
    coin?: Argument;
    amounts: Argument[];
}
export interface MergeCoins {
    coin?: Argument;
    coinsToMerge: Argument[];
}
export interface Publish {
    modules: Uint8Array[];
    dependencies: string[];
}
export interface MakeMoveVector {
    elementType?: string;
    elements: Argument[];
}
export interface Upgrade {
    modules: Uint8Array[];
    dependencies: string[];
    package?: string;
    ticket?: Argument;
}
export interface RandomnessStateUpdate {
    epoch?: bigint;
    randomnessRound?: bigint;
    randomBytes?: Uint8Array;
    randomnessObjectInitialSharedVersion?: bigint;
}
export interface ChangeEpoch {
    epoch?: bigint;
    protocolVersion?: bigint;
    storageCharge?: bigint;
    computationCharge?: bigint;
    storageRebate?: bigint;
    nonRefundableStorageFee?: bigint;
    epochStartTimestamp?: Timestamp;
    systemPackages: SystemPackage[];
}
export interface SystemPackage {
    version?: bigint;
    modules: Uint8Array[];
    dependencies: string[];
}
export interface GenesisTransaction {
    objects: Object[];
}
export interface ConsensusCommitPrologue {
    epoch?: bigint;
    round?: bigint;
    commitTimestamp?: Timestamp;
    consensusCommitDigest?: string;
    subDagIndex?: bigint;
    consensusDeterminedVersionAssignments?: ConsensusDeterminedVersionAssignments;
    additionalStateDigest?: string;
}
export interface VersionAssignment {
    objectId?: string;
    startVersion?: bigint;
    version?: bigint;
}
export interface CanceledTransaction {
    digest?: string;
    versionAssignments: VersionAssignment[];
}
export interface ConsensusDeterminedVersionAssignments {
    version?: number;
    canceledTransactions: CanceledTransaction[];
}
export interface EndOfEpochTransaction {
    transactions: EndOfEpochTransactionKind[];
}
export interface EndOfEpochTransactionKind {
    kind?: EndOfEpochTransactionKind_Kind;
    data: {
        oneofKind: "changeEpoch";
        changeEpoch: ChangeEpoch;
    } | {
        oneofKind: "executionTimeObservations";
        executionTimeObservations: ExecutionTimeObservations;
    } | {
        oneofKind: "bridgeChainId";
        bridgeChainId: string;
    } | {
        oneofKind: "bridgeObjectVersion";
        bridgeObjectVersion: bigint;
    } | {
        oneofKind: undefined;
    };
}
export declare enum EndOfEpochTransactionKind_Kind {
    KIND_UNKNOWN = 0,
    CHANGE_EPOCH = 1,
    RANDOMNESS_STATE_CREATE = 2,
    DENY_LIST_STATE_CREATE = 3,
    BRIDGE_STATE_CREATE = 4,
    BRIDGE_COMMITTEE_INIT = 5,
    STORE_EXECUTION_TIME_OBSERVATIONS = 6,
    ACCUMULATOR_ROOT_CREATE = 7,
    COIN_REGISTRY_CREATE = 8,
    DISPLAY_REGISTRY_CREATE = 9
}
export interface ExecutionTimeObservations {
    version?: number;
    observations: ExecutionTimeObservation[];
}
export interface ExecutionTimeObservation {
    kind?: ExecutionTimeObservation_ExecutionTimeObservationKind;
    moveEntryPoint?: MoveCall;
    validatorObservations: ValidatorExecutionTimeObservation[];
}
export declare enum ExecutionTimeObservation_ExecutionTimeObservationKind {
    EXECUTION_TIME_OBSERVATION_KIND_UNKNOWN = 0,
    MOVE_ENTRY_POINT = 1,
    TRANSFER_OBJECTS = 2,
    SPLIT_COINS = 3,
    MERGE_COINS = 4,
    PUBLISH = 5,
    MAKE_MOVE_VECTOR = 6,
    UPGRADE = 7
}
export interface ValidatorExecutionTimeObservation {
    validator?: Uint8Array;
    duration?: Duration;
}
declare class Transaction$Type extends MessageType<Transaction> {
    constructor();
}
export declare const Transaction: Transaction$Type;
declare class GasPayment$Type extends MessageType<GasPayment> {
    constructor();
}
export declare const GasPayment: GasPayment$Type;
declare class TransactionExpiration$Type extends MessageType<TransactionExpiration> {
    constructor();
}
export declare const TransactionExpiration: TransactionExpiration$Type;
declare class TransactionKind$Type extends MessageType<TransactionKind> {
    constructor();
}
export declare const TransactionKind: TransactionKind$Type;
declare class ProgrammableTransaction$Type extends MessageType<ProgrammableTransaction> {
    constructor();
}
export declare const ProgrammableTransaction: ProgrammableTransaction$Type;
declare class Command$Type extends MessageType<Command> {
    constructor();
}
export declare const Command: Command$Type;
declare class MoveCall$Type extends MessageType<MoveCall> {
    constructor();
}
export declare const MoveCall: MoveCall$Type;
declare class TransferObjects$Type extends MessageType<TransferObjects> {
    constructor();
}
export declare const TransferObjects: TransferObjects$Type;
declare class SplitCoins$Type extends MessageType<SplitCoins> {
    constructor();
}
export declare const SplitCoins: SplitCoins$Type;
declare class MergeCoins$Type extends MessageType<MergeCoins> {
    constructor();
}
export declare const MergeCoins: MergeCoins$Type;
declare class Publish$Type extends MessageType<Publish> {
    constructor();
}
export declare const Publish: Publish$Type;
declare class MakeMoveVector$Type extends MessageType<MakeMoveVector> {
    constructor();
}
export declare const MakeMoveVector: MakeMoveVector$Type;
declare class Upgrade$Type extends MessageType<Upgrade> {
    constructor();
}
export declare const Upgrade: Upgrade$Type;
declare class RandomnessStateUpdate$Type extends MessageType<RandomnessStateUpdate> {
    constructor();
}
export declare const RandomnessStateUpdate: RandomnessStateUpdate$Type;
declare class ChangeEpoch$Type extends MessageType<ChangeEpoch> {
    constructor();
}
export declare const ChangeEpoch: ChangeEpoch$Type;
declare class SystemPackage$Type extends MessageType<SystemPackage> {
    constructor();
}
export declare const SystemPackage: SystemPackage$Type;
declare class GenesisTransaction$Type extends MessageType<GenesisTransaction> {
    constructor();
}
export declare const GenesisTransaction: GenesisTransaction$Type;
declare class ConsensusCommitPrologue$Type extends MessageType<ConsensusCommitPrologue> {
    constructor();
}
export declare const ConsensusCommitPrologue: ConsensusCommitPrologue$Type;
declare class VersionAssignment$Type extends MessageType<VersionAssignment> {
    constructor();
}
export declare const VersionAssignment: VersionAssignment$Type;
declare class CanceledTransaction$Type extends MessageType<CanceledTransaction> {
    constructor();
}
export declare const CanceledTransaction: CanceledTransaction$Type;
declare class ConsensusDeterminedVersionAssignments$Type extends MessageType<ConsensusDeterminedVersionAssignments> {
    constructor();
}
export declare const ConsensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignments$Type;
declare class EndOfEpochTransaction$Type extends MessageType<EndOfEpochTransaction> {
    constructor();
}
export declare const EndOfEpochTransaction: EndOfEpochTransaction$Type;
declare class EndOfEpochTransactionKind$Type extends MessageType<EndOfEpochTransactionKind> {
    constructor();
}
export declare const EndOfEpochTransactionKind: EndOfEpochTransactionKind$Type;
declare class ExecutionTimeObservations$Type extends MessageType<ExecutionTimeObservations> {
    constructor();
}
export declare const ExecutionTimeObservations: ExecutionTimeObservations$Type;
declare class ExecutionTimeObservation$Type extends MessageType<ExecutionTimeObservation> {
    constructor();
}
export declare const ExecutionTimeObservation: ExecutionTimeObservation$Type;
declare class ValidatorExecutionTimeObservation$Type extends MessageType<ValidatorExecutionTimeObservation> {
    constructor();
}
export declare const ValidatorExecutionTimeObservation: ValidatorExecutionTimeObservation$Type;
export {};