@tezos-x/octez.js 0.9.0

package/dist/types/signer/errors.d.ts

@@ -0,0 +1,8 @@
+import { TezosToolkitConfigError } from '@tezos-x/octez.js-core';
+/**
+ *  @category Error
+ *  @description Error that indicates no signer has been configured in the TezosToolkit instance
+ */
+export declare class UnconfiguredSignerError extends TezosToolkitConfigError {
+    constructor();
+}

package/dist/types/signer/noop.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from '@tezos-x/octez.js-core';
+/**
+ * @description Default signer implementation which does nothing and produce invalid signature
+ * @throw {@link UnconfiguredSignerError}
+ */
+export declare class NoopSigner implements Signer {
+    publicKey(): Promise<string>;
+    publicKeyHash(): Promise<string>;
+    secretKey(): Promise<string>;
+    sign(_bytes: string, _watermark?: Uint8Array): Promise<any>;
+}

package/dist/types/subscribe/create-observable-from-subscription.d.ts

@@ -0,0 +1,4 @@
+import { BlockResponse } from '@tezos-x/octez.js-rpc';
+import { Observable } from 'rxjs';
+import { OperationContent, Subscription } from './interface';
+export declare function createObservableFromSubscription<T extends BlockResponse | string | OperationContent>(sub: Subscription<T>): Observable<T>;

package/dist/types/subscribe/errors.d.ts

@@ -0,0 +1,18 @@
+import { ParameterValidationError } from '@tezos-x/octez.js-core';
+import { FilterExpression } from '../octez';
+/**
+ *  @category Error
+ *  @description Error that indicates an unsupported event being passed or used
+ */
+export declare class UnsupportedEventError extends ParameterValidationError {
+    readonly type: string;
+    constructor(type: string);
+}
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid filter expression being passed or used
+ */
+export declare class InvalidFilterExpressionError extends ParameterValidationError {
+    readonly invalidExpression: FilterExpression;
+    constructor(invalidExpression: FilterExpression);
+}

package/dist/types/subscribe/filters.d.ts

@@ -0,0 +1,6 @@
+import { OpFilter, FilterExpression, Filter, OperationContent } from './interface';
+import { InternalOperationResult } from '@tezos-x/octez.js-rpc';
+export declare const eventFilter: (result: InternalOperationResult, address?: string, tag?: string, excludeFailedOperations?: boolean) => boolean;
+export declare const evaluateOpFilter: (op: OperationContent, filter: OpFilter) => boolean | undefined;
+export declare const evaluateExpression: (op: OperationContent, exp: FilterExpression) => boolean;
+export declare const evaluateFilter: (op: OperationContent, filter: Filter) => boolean;

package/dist/types/subscribe/interface.d.ts

@@ -0,0 +1,48 @@
+import { BlockResponse, InternalOperationResult, OperationEntry } from '@tezos-x/octez.js-rpc';
+export type FilterExpression = {
+    or?: ExpressionOrOpFilter[];
+    and?: ExpressionOrOpFilter[];
+};
+export interface OpHashFilter {
+    opHash: string;
+}
+export interface SourceFilter {
+    source: string;
+}
+export interface KindFilter {
+    kind: string;
+}
+export interface DestinationFilter {
+    destination: string;
+}
+export interface EventFilter {
+    address?: string;
+    tag?: string;
+    excludeFailedOperations?: boolean;
+}
+export interface EventSubscription extends InternalOperationResult {
+    opHash: string;
+    blockHash: string;
+    level: number;
+}
+export type OpFilter = OpHashFilter | SourceFilter | KindFilter | DestinationFilter | EventFilter;
+export type ExpressionOrOpFilter = OpFilter | FilterExpression;
+export type Filter = ExpressionOrOpFilter | ExpressionOrOpFilter[];
+export type OperationContent = OperationEntry['contents'][0] & {
+    hash: string;
+};
+export interface SubscribeProvider {
+    subscribe(filter: 'head'): Subscription<string>;
+    subscribeBlock(filter: 'head'): Subscription<BlockResponse>;
+    subscribeOperation(filter: Filter): Subscription<OperationContent>;
+    subscribeEvent(filter?: EventFilter): Subscription<InternalOperationResult>;
+}
+export interface Subscription<T> {
+    on(type: 'error', cb: (error: Error) => void): void;
+    on(type: 'data', cb: (data: T) => void): void;
+    on(type: 'close', cb: () => void): void;
+    off(type: 'error', cb: (error: Error) => void): void;
+    off(type: 'data', cb: (data: T) => void): void;
+    off(type: 'close', cb: () => void): void;
+    close(): void;
+}

package/dist/types/subscribe/observable-subscription.d.ts

@@ -0,0 +1,21 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { Subscription } from './interface';
+export { UnsupportedEventError } from './errors';
+export declare class ObservableSubscription<T> implements Subscription<T> {
+    private shouldRetry;
+    private operatorFunction;
+    private errorListeners;
+    private messageListeners;
+    private closeListeners;
+    private completed$;
+    constructor(obs: Observable<T>, shouldRetry?: boolean, operatorFunction?: OperatorFunction<T, T>);
+    private call;
+    private remove;
+    on(type: 'error', cb: (error: Error) => void): void;
+    on(type: 'data', cb: (data: T) => void): void;
+    on(type: 'close', cb: () => void): void;
+    off(type: 'error', cb: (error: Error) => void): void;
+    off(type: 'data', cb: (data: T) => void): void;
+    off(type: 'close', cb: () => void): void;
+    close(): void;
+}

package/dist/types/subscribe/polling-subcribe-provider.d.ts

@@ -0,0 +1,23 @@
+import { BlockResponse, InternalOperationResult } from '@tezos-x/octez.js-rpc';
+import { OperatorFunction } from 'rxjs';
+import { Context } from '../context';
+import { Filter, EventFilter, SubscribeProvider, Subscription, OperationContent } from './interface';
+export interface PollingSubscribeProviderConfig {
+    pollingIntervalMilliseconds?: number;
+    shouldObservableSubscriptionRetry: boolean;
+    observableSubscriptionRetryFunction: OperatorFunction<any, any>;
+}
+export declare const defaultConfigStreamer: PollingSubscribeProviderConfig;
+export declare class PollingSubscribeProvider implements SubscribeProvider {
+    private context;
+    private _config$;
+    private timer$;
+    private newBlock$;
+    constructor(context: Context, config?: Partial<PollingSubscribeProviderConfig>);
+    get config(): PollingSubscribeProviderConfig;
+    private getConfirmationPollingInterval;
+    subscribeBlock(_filter: 'head'): Subscription<BlockResponse>;
+    subscribe(_filter: 'head'): Subscription<string>;
+    subscribeOperation(filter: Filter): Subscription<OperationContent>;
+    subscribeEvent(eventFilter?: EventFilter): Subscription<InternalOperationResult>;
+}

package/dist/types/tz/interface.d.ts

@@ -0,0 +1,20 @@
+import BigNumber from 'bignumber.js';
+import { Operation } from '../operations/operations';
+export interface TzProvider {
+    /**
+     *
+     * @param address Tezos address you want to get the spendable balance for (eg tz1...)
+     */
+    getBalance(address: string): Promise<BigNumber>;
+    /**
+     *
+     * @param address Tezos address you want to get the spendable balance for (eg tz1...)
+     */
+    getSpendable(address: string): Promise<BigNumber>;
+    /**
+     *
+     * @param address Tezos address you want to get the delegate for (eg tz1...)
+     */
+    getDelegate(address: string): Promise<string | null>;
+    activate(pkh: string, secret: string): Promise<Operation>;
+}

package/dist/types/tz/rpc-tz-provider.d.ts

@@ -0,0 +1,13 @@
+import BigNumber from 'bignumber.js';
+import { Context } from '../context';
+import { Operation } from '../operations/operations';
+import { TzProvider } from './interface';
+import { Provider } from '../provider';
+export declare class RpcTzProvider extends Provider implements TzProvider {
+    constructor(context: Context);
+    private prepare;
+    getBalance(address: string): Promise<BigNumber>;
+    getSpendable(address: string): Promise<BigNumber>;
+    getDelegate(address: string): Promise<string | null>;
+    activate(pkh: string, secret: string): Promise<Operation>;
+}

package/dist/types/version.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION: {
+    commitHash: string;
+    version: string;
+};

package/dist/types/wallet/batch-operation.d.ts

@@ -0,0 +1,13 @@
+import { BlockResponse, OperationContentsAndResultReveal, OpKind } from '@tezos-x/octez.js-rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { WalletOperation, OperationStatus } from './operation';
+export declare const WALLET_BATCH_KINDS: OpKind[];
+export declare class BatchWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    getOriginatedContractAddresses: () => Promise<string[]>;
+    status(): Promise<OperationStatus>;
+}

package/dist/types/wallet/delegation-operation.d.ts

@@ -0,0 +1,12 @@
+import { BlockResponse, OperationContentsAndResultDelegation, OperationContentsAndResultReveal } from '@tezos-x/octez.js-rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { WalletOperation, OperationStatus } from './operation';
+export declare class DelegationWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    delegationOperation(): Promise<OperationContentsAndResultDelegation | undefined>;
+    status(): Promise<OperationStatus>;
+}

package/dist/types/wallet/errors.d.ts

@@ -0,0 +1,16 @@
+import { TezosToolkitConfigError, NetworkError } from '@tezos-x/octez.js-core';
+/**
+ *  @category Error
+ *  @description Error that indicates undefined confirmation has not been specified or configured
+ */
+export declare class ConfirmationUndefinedError extends TezosToolkitConfigError {
+    constructor();
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a generic failure when trying to fetch an observable
+ */
+export declare class ObservableError extends NetworkError {
+    readonly message: string;
+    constructor(message: string);
+}

package/dist/types/wallet/increase-paid-storage-operation.d.ts

@@ -0,0 +1,12 @@
+import { WalletOperation, OperationStatus } from './operation';
+import { Context } from '../context';
+import { Observable } from 'rxjs';
+import { BlockResponse, OperationContentsAndResultReveal, OperationContentsAndResultIncreasePaidStorage } from '@tezos-x/octez.js-rpc';
+export declare class IncreasePaidStorageWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    increasePaidStorageOperation(): Promise<OperationContentsAndResultIncreasePaidStorage | undefined>;
+    status(): Promise<OperationStatus>;
+}

package/dist/types/wallet/index.d.ts

@@ -0,0 +1,9 @@
+export * from './wallet';
+export * from './operation';
+export * from './transaction-operation';
+export * from './origination-operation';
+export * from './delegation-operation';
+export * from './transfer-ticket-operation';
+export * from './register-global-constant-operation';
+export * from './interface';
+export * from './legacy';

package/dist/types/wallet/interface.d.ts

@@ -0,0 +1,66 @@
+import { DelegateParams, FailingNoopParams, IncreasePaidStorageParams, OriginateParams, TransferParams, StakeParams, UnstakeParams, FinalizeUnstakeParams, TransferTicketParams, RegisterGlobalConstantParams } from '../operations/types';
+export type WalletDefinedFields = 'source';
+export type WalletTransferParams = Omit<TransferParams, WalletDefinedFields>;
+export type WalletStakeParams = Omit<StakeParams, WalletDefinedFields>;
+export type WalletUnstakeParams = Omit<UnstakeParams, WalletDefinedFields>;
+export type WalletFinalizeUnstakeParams = Omit<FinalizeUnstakeParams, WalletDefinedFields>;
+export type WalletOriginateParams<TStorage = any> = Omit<OriginateParams<TStorage>, WalletDefinedFields>;
+export type WalletDelegateParams = Omit<DelegateParams, WalletDefinedFields>;
+export type WalletFailingNoopParams = Omit<FailingNoopParams, WalletDefinedFields>;
+export type WalletIncreasePaidStorageParams = Omit<IncreasePaidStorageParams, WalletDefinedFields>;
+export type WalletTransferTicketParams = Omit<TransferTicketParams, WalletDefinedFields>;
+export type WalletRegisterGlobalConstantParams = Omit<RegisterGlobalConstantParams, WalletDefinedFields>;
+export interface WalletProvider {
+    /**
+     * @description Request the public key hash from the wallet
+     */
+    getPKH: () => Promise<string>;
+    /**
+     * @description Request the public key from the wallet
+     */
+    getPK: () => Promise<string>;
+    /**
+     * @description Transform WalletTransferParams into a format compliant with the underlying wallet
+     */
+    mapTransferParamsToWalletParams: (params: () => Promise<WalletTransferParams>) => Promise<any>;
+    /**
+     * @description Transform WalletTransferTicketParams into a format compliant with the underlying wallet
+     */
+    mapTransferTicketParamsToWalletParams: (params: () => Promise<WalletTransferTicketParams>) => Promise<any>;
+    /**
+     * @description Transform WalletRegisterGlobalConstantParams into a format compliant with the underlying wallet
+     */
+    mapRegisterGlobalConstantParamsToWalletParams: (params: () => Promise<WalletRegisterGlobalConstantParams>) => Promise<any>;
+    /**
+     * @description Transform WalletStakeParams into a format compliant with the underlying wallet
+     */
+    mapStakeParamsToWalletParams: (params: () => Promise<WalletStakeParams>) => Promise<any>;
+    /**
+     * @description Transform WalletUnstakeParams into a format compliant with the underlying wallet
+     */
+    mapUnstakeParamsToWalletParams: (params: () => Promise<WalletUnstakeParams>) => Promise<any>;
+    /**
+     * @description Transform WalletFinalizeUnstakeParams into a format compliant with the underlying wallet
+     */
+    mapFinalizeUnstakeParamsToWalletParams: (params: () => Promise<WalletFinalizeUnstakeParams>) => Promise<any>;
+    /**
+     * @description Transform WalletOriginateParams into a format compliant with the underlying wallet
+     */
+    mapOriginateParamsToWalletParams: (params: () => Promise<WalletOriginateParams>) => Promise<any>;
+    /**
+     * @description Transform WalletDelegateParams into a format compliant with the underlying wallet
+     */
+    mapDelegateParamsToWalletParams: (params: () => Promise<WalletDelegateParams>) => Promise<any>;
+    /**
+     * @description Transform WalletIncreasePaidStorageParams into a format compliant with the underlying wallet
+     */
+    mapIncreasePaidStorageWalletParams: (params: () => Promise<WalletIncreasePaidStorageParams>) => Promise<any>;
+    /**
+     * @description Request the wallet to send an operation batch
+     */
+    sendOperations: (params: any[]) => Promise<string>;
+    /**
+     * @description Request the wallet to sign a payload
+     */
+    sign(bytes: string, watermark?: Uint8Array): Promise<string>;
+}

package/dist/types/wallet/legacy.d.ts

@@ -0,0 +1,21 @@
+import { Context } from '../context';
+import { OpKind } from '../operations/types';
+import { WalletDelegateParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams, WalletRegisterGlobalConstantParams } from './interface';
+import { WalletParamsWithKind } from './wallet';
+export declare class LegacyWalletProvider implements WalletProvider {
+    private context;
+    constructor(context: Context);
+    getPKH(): Promise<string>;
+    getPK(): Promise<string>;
+    mapTransferParamsToWalletParams(params: () => Promise<WalletTransferParams>): Promise<import("../operations/types").withKind<WalletTransferParams, OpKind.TRANSACTION>>;
+    mapStakeParamsToWalletParams(params: () => Promise<WalletStakeParams>): Promise<import("../operations/types").withKind<WalletStakeParams, OpKind.TRANSACTION>>;
+    mapUnstakeParamsToWalletParams(params: () => Promise<WalletUnstakeParams>): Promise<import("../operations/types").withKind<WalletUnstakeParams, OpKind.TRANSACTION>>;
+    mapFinalizeUnstakeParamsToWalletParams(params: () => Promise<WalletFinalizeUnstakeParams>): Promise<import("../operations/types").withKind<WalletFinalizeUnstakeParams, OpKind.TRANSACTION>>;
+    mapOriginateParamsToWalletParams(params: () => Promise<WalletOriginateParams>): Promise<import("../operations/types").withKind<WalletOriginateParams, OpKind.ORIGINATION>>;
+    mapDelegateParamsToWalletParams(params: () => Promise<WalletDelegateParams>): Promise<import("../operations/types").withKind<WalletDelegateParams, OpKind.DELEGATION>>;
+    mapIncreasePaidStorageWalletParams(params: () => Promise<WalletIncreasePaidStorageParams>): Promise<import("../operations/types").withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE>>;
+    mapTransferTicketParamsToWalletParams(params: () => Promise<WalletTransferTicketParams>): Promise<import("../operations/types").withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET>>;
+    mapRegisterGlobalConstantParamsToWalletParams(params: () => Promise<WalletRegisterGlobalConstantParams>): Promise<import("../operations/types").withKind<WalletRegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT>>;
+    sendOperations(params: WalletParamsWithKind[]): Promise<string>;
+    sign(bytes: string, watermark?: Uint8Array): Promise<string>;
+}

package/dist/types/wallet/operation-factory.d.ts

@@ -0,0 +1,32 @@
+import { BlockResponse } from '@tezos-x/octez.js-rpc';
+import { Observable, SchedulerLike } from 'rxjs';
+import { Context } from '../context';
+import { BatchWalletOperation } from './batch-operation';
+import { DelegationWalletOperation } from './delegation-operation';
+import { IncreasePaidStorageWalletOperation } from './increase-paid-storage-operation';
+import { WalletOperation } from './operation';
+import { OriginationWalletOperation } from './origination-operation';
+import { TransactionWalletOperation } from './transaction-operation';
+import { TransferTicketWalletOperation } from './transfer-ticket-operation';
+import { RegisterGlobalConstantWalletOperation } from './register-global-constant-operation';
+export declare function timeoutAfter<T>(timeoutMillisec: number): (source: Observable<T>) => Observable<T>;
+export declare const createNewPollingBasedHeadObservable: (sharedHeadOb: Observable<BlockResponse>, context: Context, _scheduler?: SchedulerLike) => Observable<BlockResponse>;
+export interface OperationFactoryConfig {
+    blockIdentifier?: string;
+}
+export declare class OperationFactory {
+    private context;
+    constructor(context: Context);
+    private sharedHeadObs;
+    private createNewHeadObservable;
+    private createPastBlockWalker;
+    private createHeadObservableFromConfig;
+    createOperation(hash: string, config?: OperationFactoryConfig): Promise<WalletOperation>;
+    createBatchOperation(hash: string, config?: OperationFactoryConfig): Promise<BatchWalletOperation>;
+    createTransactionOperation(hash: string, config?: OperationFactoryConfig): Promise<TransactionWalletOperation>;
+    createTransferTicketOperation(hash: string, config?: OperationFactoryConfig): Promise<TransferTicketWalletOperation>;
+    createDelegationOperation(hash: string, config?: OperationFactoryConfig): Promise<DelegationWalletOperation>;
+    createOriginationOperation(hash: string, config?: OperationFactoryConfig): Promise<OriginationWalletOperation>;
+    createIncreasePaidStorageOperation(hash: string, config?: OperationFactoryConfig): Promise<IncreasePaidStorageWalletOperation>;
+    createRegisterGlobalConstantOperation(hash: string, config?: OperationFactoryConfig): Promise<RegisterGlobalConstantWalletOperation>;
+}

package/dist/types/wallet/operation.d.ts

@@ -0,0 +1,54 @@
+import { BlockResponse, OperationContentsAndResult, OperationResultStatusEnum } from '@tezos-x/octez.js-rpc';
+import { Observable, ReplaySubject } from 'rxjs';
+import { Context } from '../context';
+import { Receipt } from './receipt';
+import { BlockIdentifier } from '../read-provider/interface';
+export type OperationStatus = 'pending' | 'unknown' | OperationResultStatusEnum;
+/**
+ * @description WalletOperation allows to monitor operation inclusion on chains and surface information related to the operation
+ */
+export declare class WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    private _newHead$;
+    protected _operationResult: ReplaySubject<OperationContentsAndResult[]>;
+    protected _includedInBlock: ReplaySubject<BlockResponse>;
+    protected _included: boolean;
+    private lastHead;
+    protected newHead$: Observable<BlockResponse>;
+    private confirmed$;
+    operationResults(): Promise<OperationContentsAndResult[] | undefined>;
+    /**
+     * @description Receipt expose the total amount of tezos token burn and spent on fees
+     * The promise returned by receipt will resolve only once the transaction is included
+     */
+    receipt(): Promise<Receipt>;
+    /**
+     *
+     * @param opHash Operation hash
+     * @param raw Raw operation that was injected
+     * @param context Taquito context allowing access to rpc and signer
+     * @throws {InvalidOperationHashError}
+     */
+    constructor(opHash: string, context: Context, _newHead$: Observable<BlockResponse>);
+    getCurrentConfirmation(): Promise<number | undefined>;
+    isInCurrentBranch(tipBlockIdentifier?: BlockIdentifier): Promise<boolean>;
+    confirmationObservable(confirmations?: number): Observable<{
+        block: BlockResponse;
+        expectedConfirmation: number;
+        currentConfirmation: number;
+        completed: boolean;
+        isInCurrentBranch: () => Promise<boolean>;
+    }>;
+    /**
+     *
+     * @param confirmations [0] Number of confirmation to wait for
+     */
+    confirmation(confirmations?: number): Promise<{
+        block: BlockResponse;
+        expectedConfirmation: number;
+        currentConfirmation: number;
+        completed: boolean;
+        isInCurrentBranch: () => Promise<boolean>;
+    } | undefined>;
+}

package/dist/types/wallet/origination-operation.d.ts

@@ -0,0 +1,14 @@
+import { BlockResponse, OperationContentsAndResultOrigination, OperationContentsAndResultReveal } from '@tezos-x/octez.js-rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { DefaultWalletType } from '../contract/contract';
+import { WalletOperation, OperationStatus } from './operation';
+export declare class OriginationWalletOperation<TWallet extends DefaultWalletType = DefaultWalletType> extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    originationOperation(): Promise<OperationContentsAndResultOrigination | undefined>;
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    status(): Promise<OperationStatus>;
+    contract(): Promise<TWallet>;
+}

package/dist/types/wallet/receipt.d.ts

@@ -0,0 +1,16 @@
+import { OperationContentsAndResult } from '@tezos-x/octez.js-rpc';
+import BigNumber from 'bignumber.js';
+export interface Receipt {
+    totalFee: BigNumber;
+    totalGas: BigNumber;
+    totalMilliGas: BigNumber;
+    totalStorage: BigNumber;
+    totalAllocationBurn: BigNumber;
+    totalOriginationBurn: BigNumber;
+    totalPaidStorageDiff: BigNumber;
+    totalStorageBurn: BigNumber;
+}
+export declare const receiptFromOperation: (op: OperationContentsAndResult[], { ALLOCATION_BURN, ORIGINATION_BURN }?: {
+    ALLOCATION_BURN: number;
+    ORIGINATION_BURN: number;
+}) => Receipt;

package/dist/types/wallet/register-global-constant-operation.d.ts

@@ -0,0 +1,13 @@
+import { BlockResponse, OperationContentsAndResultRegisterGlobalConstant, OperationContentsAndResultReveal } from '@tezos-x/octez.js-rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { WalletOperation, OperationStatus } from './operation';
+export declare class RegisterGlobalConstantWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    registerGlobalConstantOperation(): Promise<OperationContentsAndResultRegisterGlobalConstant | undefined>;
+    status(): Promise<OperationStatus>;
+    globalConstantHash(): Promise<string | undefined>;
+}

package/dist/types/wallet/transaction-operation.d.ts

@@ -0,0 +1,12 @@
+import { WalletOperation, OperationStatus } from './operation';
+import { Context } from '../context';
+import { Observable } from 'rxjs';
+import { BlockResponse, OperationContentsAndResultReveal, OperationContentsAndResultTransaction } from '@tezos-x/octez.js-rpc';
+export declare class TransactionWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    transactionOperation(): Promise<OperationContentsAndResultTransaction | undefined>;
+    status(): Promise<OperationStatus>;
+}

package/dist/types/wallet/transfer-ticket-operation.d.ts

@@ -0,0 +1,12 @@
+import { WalletOperation, OperationStatus } from './operation';
+import { Context } from '../context';
+import { Observable } from 'rxjs';
+import { BlockResponse, OperationContentsAndResultReveal, OperationContentsAndResultTransferTicket } from '@tezos-x/octez.js-rpc';
+export declare class TransferTicketWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    transferTicketOperation(): Promise<OperationContentsAndResultTransferTicket | undefined>;
+    status(): Promise<OperationStatus>;
+}