dequanto 0.1.22 → 0.1.24

package/lib/esm/rpc/RpcBase.d.ts

@@ -1,32 +0,0 @@
-import { TTransport } from './transports/ITransport';
-import { RpcSubscription } from './RpcSubscription';
-export declare abstract class RpcBase {
-    protected transportInfo?: TTransport.Options.Any;
-    protected _transport: TTransport.Transport;
-    fns: {
-        [name: string]: (...params: any) => Promise<any>;
-    };
-    constructor(transportInfo?: TTransport.Options.Any);
-    request<TResult = any>(req: TRpc.IRpcAction): Promise<TResult>;
-    batch(arr: TRpc.IRpcAction[]): Promise<any[]>;
-    extend(rpcInfos: {
-        name: string;
-        call: string;
-        params?: any[];
-        output?: any;
-    }[]): void;
-    protected subscribe<TReturn = any>(req: TRpc.IRpcAction): Promise<RpcSubscription<TReturn>>;
-    private _wrapBody;
-    private _unwrapBody;
-    private _deserialize;
-    protected abstract returnSchemas: any;
-}
-export declare namespace TRpc {
-    interface IRpc {
-        request<TResult = any>(req: IRpcAction): Promise<TResult>;
-    }
-    interface IRpcAction {
-        method: string;
-        params?: any[];
-    }
-}

package/lib/esm/rpc/RpcContract.d.ts

@@ -1,31 +0,0 @@
-import { RpcTypes } from './Rpc';
-import { TAbiItem } from '../types/TAbi';
-import { TAddress } from '../models/TAddress';
-import { TEth } from '../models/TEth';
-import { DataLike } from '../utils/types';
-import type { Web3Client } from '../clients/Web3Client';
-type TRpcContract = {
-    address?: TAddress;
-    abi?: TAbiItem[];
-};
-type TRpcContractCallBase = {
-    address?: TAddress;
-    abi?: string | TAbiItem | TAbiItem[];
-    method?: string;
-    params?: any[];
-    data?: TEth.Hex;
-    value?: bigint;
-    from?: TAddress;
-    blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash> | Date;
-};
-export type TRpcContractCall = (TRpcContractCallBase & Pick<TRpcContractCallBase, 'method' | 'params'>) | (TRpcContractCallBase & Pick<TRpcContractCallBase, 'data'>);
-export declare class RpcContract {
-    client: Web3Client;
-    private defaults?;
-    constructor(client: Web3Client, defaults?: TRpcContract);
-    request(req: TRpcContractCall): Promise<any>;
-    batch(req: TRpcContractCall[]): Promise<any[]>;
-    private getCallRequestsRaw;
-    private getCallRequestRaw;
-}
-export {};

package/lib/esm/rpc/RpcError.d.ts

@@ -1,14 +0,0 @@
-import { TTransport } from './transports/ITransport';
-import { TEth } from '../models/TEth';
-export declare class RpcError extends Error {
-    code: number;
-    data: TEth.Hex;
-    constructor(json: {
-        code: number;
-        message: string;
-        data?: {
-            message?: any;
-            data?: any;
-        };
-    }, ctx?: string | TTransport.Request);
-}

package/lib/esm/rpc/RpcFunction.d.ts

@@ -1,15 +0,0 @@
-import type { RpcBase } from './RpcBase';
-type TParamSerializer = Function;
-type TReturnDeserializer = string | string[] | Function;
-export declare class RpcFunction {
-    private rpc;
-    private methodInfo;
-    constructor(rpc: RpcBase, methodInfo: {
-        call: string;
-        params?: TParamSerializer[];
-        output?: TReturnDeserializer;
-        schemas?: any;
-    });
-    caller(): (...params: any[]) => Promise<any>;
-}
-export {};

package/lib/esm/rpc/RpcHandler.d.ts

@@ -1,2 +0,0 @@
-export declare class RpcHandler {
-}

package/lib/esm/rpc/RpcModelMiddleware.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/esm/rpc/RpcSubscription.d.ts

@@ -1,16 +0,0 @@
-import { SubjectStream } from '../class/SubjectStream';
-import { TEth } from '../models/TEth';
-import { TTransport } from './transports/ITransport';
-export declare class RpcSubscription<T> extends SubjectStream<T> implements TTransport.Subscription<T> {
-    id: number;
-    transport: TTransport.Transport;
-    private _emitter;
-    constructor(id: number, transport: TTransport.Transport, mapper?: (value: any) => T);
-    map(mapper: (x: T) => any): RpcSubscription<T>;
-    unsubscribe(cb?: Function): Promise<boolean>;
-    static createMapping<T>(subscription: TTransport.Subscription<any>, transport: TTransport.Transport, mapper: (x: any) => any): RpcSubscription<T>;
-}
-export type RpcLogFilterOptions = {
-    address?: TEth.Address | TEth.Address[];
-    topics?: TEth.Hex[];
-};

package/lib/esm/rpc/transports/DeferredTransport.d.ts

@@ -1,14 +0,0 @@
-import { TTransport } from './ITransport';
-export declare class DeferredTransport implements TTransport.Transport {
-    private deferred;
-    private factory;
-    constructor(deferred: Promise<TTransport.Options.Any>, factory: (info: TTransport.Options.Any) => TTransport.Transport);
-    request(req: TTransport.Request): any;
-    request(req: TTransport.Request[]): any;
-    subscribe<TResult = any>(req: TTransport.Request): Promise<TTransport.Subscription<TResult>>;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<TTransport.Subscription<any>>;
-    private getInner;
-}

package/lib/esm/rpc/transports/HttpTransport.d.ts

@@ -1,13 +0,0 @@
-import { RpcSubscription } from '../RpcSubscription';
-import { TTransport } from './ITransport';
-export declare class HttpTransport implements TTransport.Transport {
-    private options;
-    id: string;
-    constructor(options: TTransport.Options.Http);
-    request(req: TTransport.Request | TTransport.Request[]): Promise<any>;
-    subscribe(req: TTransport.Request): Promise<RpcSubscription<any>>;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<TTransport.Subscription<any>>;
-}

package/lib/esm/rpc/transports/ITransport.d.ts

@@ -1,68 +0,0 @@
-import type { IWeb3EndpointOptions } from '../../clients/interfaces/IWeb3EndpointOptions';
-import type { TEth } from '../../models/TEth';
-import type { ClientOptions } from 'ws';
-export declare namespace TTransport {
-    type Transport = {
-        id?: string;
-        request(req: Request[]): Promise<Response[]>;
-        request(req: Request): Promise<Response>;
-        subscribe<TResult = any>(req: Request): Promise<Subscription<TResult>>;
-        unsubscribe(req: Request & {
-            method: 'eth_unsubscribe';
-            params: [number];
-        }): Promise<Subscription<any>>;
-    };
-    type Request = {
-        id: number;
-        jsonrpc: `${number}`;
-        method: string;
-        params: any[];
-    };
-    type Response = {
-        id: number;
-        error?: {
-            code: number;
-            reason?: string;
-            message: string;
-            data?: {
-                message: string;
-                data: TEth.Hex;
-            };
-        };
-        result?: any;
-    };
-    interface Subscription<T> {
-        id: number;
-        unsubscribe(cb?: Function): void | Promise<boolean>;
-        subscribe(cb: (x: T) => void, onError?: (x: Error | any) => void, once?: any): any;
-    }
-    namespace Options {
-        type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper;
-        type Http = {
-            url: string;
-        } & Omit<Parameters<typeof fetch>[1], 'headers'> & {
-            headers?: Record<string, string | ((req: any) => Promise<string>)>;
-        };
-        type Ws = {
-            url: string;
-            clientConfig?: ClientOptions;
-        };
-        type Wrapped = {
-            transport: Transport;
-        };
-        type Web3Wrapper = {
-            web3: IWeb3EndpointOptions['web3'];
-        };
-    }
-}
-export declare class RequestError extends Error {
-    name: string;
-    data?: any;
-    status?: number;
-    url: string;
-    constructor({ data, status, url, }: {
-        data?: any;
-        status?: number;
-        url: string;
-    });
-}

package/lib/esm/rpc/transports/MessageBasedTransport.d.ts

@@ -1,28 +0,0 @@
-import { TTransport } from './ITransport';
-import { class_Dfr, class_EventEmitter } from 'atma-utils';
-import { RpcSubscription } from '../RpcSubscription';
-export declare abstract class MessageBasedTransport extends class_EventEmitter implements TTransport.Transport {
-    protected optionsBase?: {
-        url: any;
-    };
-    protected requests: Map<string, class_Dfr<TTransport.Response | TTransport.Response[]>>;
-    protected subscriptions: Map<number, {
-        method: string;
-        params: any[];
-        subscription: RpcSubscription<any>;
-    }>;
-    protected subscriptionCache: Map<string, RpcSubscription<any>>;
-    protected abstract send(message: string): Promise<void>;
-    constructor(optionsBase?: {
-        url: any;
-    });
-    request(req: TTransport.Request): Promise<TTransport.Response>;
-    request(req: TTransport.Request[]): Promise<TTransport.Response[]>;
-    request(req: TTransport.Request | TTransport.Request[]): any;
-    subscribe<TResult = any>(req: TTransport.Request): any;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<RpcSubscription<any>>;
-    protected onMessage(message: string): void;
-}

package/lib/esm/rpc/transports/RpcTransport.d.ts

@@ -1,7 +0,0 @@
-import { TTransport } from './ITransport';
-export declare namespace RpcTransport {
-    type TFactory = new (opts: TTransport.Options.Any) => TTransport.Transport;
-    export function create(mix: TTransport.Options.Any | TTransport.Transport): TTransport.Transport;
-    export function register(protocol: string, Factory: TFactory): void;
-    export {};
-}

package/lib/esm/rpc/transports/WsTransport.d.ts

@@ -1,15 +0,0 @@
-import { TTransport } from './ITransport';
-import { RpcSubscription } from '../RpcSubscription';
-export declare class WsTransport implements TTransport.Transport {
-    private options;
-    private ws;
-    id: string;
-    constructor(options: TTransport.Options.Ws);
-    request(req: TTransport.Request): any;
-    request(req: TTransport.Request[]): any;
-    subscribe<TResult = any>(req: TTransport.Request): Promise<RpcSubscription<TResult>>;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<RpcSubscription<any>>;
-}

package/lib/esm/rpc/transports/WsTransportIsomorphic.d.ts

@@ -1,5 +0,0 @@
-declare let ws: typeof import("ws");
-export declare namespace WebSocketProvider {
-    function get(): Promise<typeof ws>;
-}
-export {};

package/lib/esm/rpc/transports/compatibility/EIP1193Transport.d.ts

@@ -1,15 +0,0 @@
-import { TTransport } from '../ITransport';
-import { RpcSubscription } from '../../RpcSubscription';
-export interface IEip1193Provider {
-    sendAsync: any;
-}
-export declare class EIP1193Transport implements TTransport.Transport {
-    private provider;
-    constructor(provider: IEip1193Provider);
-    request(req: TTransport.Request | TTransport.Request[]): Promise<any>;
-    subscribe(req: TTransport.Request): Promise<TTransport.Subscription<any>>;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<RpcSubscription<any>>;
-}

package/lib/esm/rpc/transports/compatibility/Web3Transport.d.ts

@@ -1,18 +0,0 @@
-import { TTransport } from '../ITransport';
-import { RpcSubscription } from '../../RpcSubscription';
-interface Web3 {
-    currentProvider: any;
-    eth: any;
-}
-export declare class Web3Transport implements TTransport.Transport {
-    private mix;
-    private provider;
-    constructor(mix: Web3);
-    request(req: TTransport.Request | TTransport.Request[]): Promise<any>;
-    subscribe(req: TTransport.Request): Promise<TTransport.Subscription<any>>;
-    unsubscribe(req: TTransport.Request & {
-        method: 'eth_unsubscribe';
-        params: [number];
-    }): Promise<RpcSubscription<any>>;
-}
-export {};

package/lib/esm/safe/$gnosis.d.ts

@@ -1,2 +0,0 @@
-export declare namespace $gnosis {
-}

package/lib/esm/safe/GnosisSafeFactory.d.ts

@@ -1,34 +0,0 @@
-import { EoAccount } from "../models/TAccount";
-import { Web3Client } from '../clients/Web3Client';
-import { TAddress } from '../models/TAddress';
-import { GnosisSafeHandler } from './GnosisSafeHandler';
-import { config } from '../config/Config';
-import { TEth } from '../models/TEth';
-import { TAbiItem } from '../types/TAbi';
-export declare const PREDETERMINED_SALT_NONCE = "0xb1073742015cbcf5a3a4d9d1ae33ecf619439710b89475f92e2abd2117e90f90";
-export declare abstract class GnosisSafeFactory {
-    static create(owner: EoAccount, client: Web3Client, params: {
-        owners: TAddress[];
-        threshold?: number;
-        saltNonce?: bigint | TEth.Hex;
-        contracts?: typeof config.safe.contracts;
-    }): Promise<GnosisSafeHandler>;
-}
-export interface ContractNetworkConfig {
-    /** multiSendAddress - Address of the MultiSend contract deployed on a specific network */
-    multiSendAddress: string;
-    /** multiSendAbi - Abi of the MultiSend contract deployed on a specific network */
-    multiSendAbi?: TAbiItem | TAbiItem[];
-    /** safeMasterCopyAddress - Address of the Gnosis Safe Master Copy contract deployed on a specific network */
-    safeMasterCopyAddress: string;
-    /** safeMasterCopyAbi - Abi of the Gnosis Safe Master Copy contract deployed on a specific network */
-    safeMasterCopyAbi?: TAbiItem | TAbiItem[];
-    /** safeProxyFactoryAddress - Address of the Gnosis Safe Proxy Factory contract deployed on a specific network */
-    safeProxyFactoryAddress: string;
-    /** safeProxyFactoryAbi - Abi of the Gnosis Safe Proxy Factory contract deployed on a specific network */
-    safeProxyFactoryAbi?: TAbiItem | TAbiItem[];
-}
-export interface ContractNetworksConfig {
-    /** id - Network id */
-    [id: string]: ContractNetworkConfig;
-}

package/lib/esm/safe/GnosisSafeHandler.d.ts

@@ -1,65 +0,0 @@
-import { EoAccount, SafeAccount } from "../models/TAccount";
-import { Web3Client } from '../clients/Web3Client';
-import { TAddress } from '../models/TAddress';
-import { TxWriter } from '../txs/TxWriter';
-import { SafeServiceTypes } from './types/SafeServiceTypes';
-import { ISafeServiceTransport } from './transport/ISafeServiceTransport';
-import { TxDataBuilder } from '../txs/TxDataBuilder';
-import { TEth } from '../models/TEth';
-import { config } from '../config/Config';
-export declare class GnosisSafeHandler {
-    safeAddress: TAddress;
-    owners: EoAccount[];
-    client: Web3Client;
-    transport: ISafeServiceTransport;
-    constructor(config: {
-        safeAddress: TAddress;
-        owners: EoAccount[];
-        client: Web3Client;
-        transport?: ISafeServiceTransport;
-    });
-    getTx(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigTransactionResponse>;
-    getTxConfirmations(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigConfirmationListResponse>;
-    confirmTx(safeTxHash: string, owner?: EoAccount): Promise<SafeServiceTypes.SignatureResponse>;
-    submitTransaction(safeTxHash: string, options?: {
-        threshold?: number;
-    }): Promise<TxWriter>;
-    execute(writer: TxWriter, safeTxParams?: {
-        operation?: 0 | 1;
-    }): Promise<TxWriter>;
-    executeTxData(txData: TEth.TxLike, owner: EoAccount, safeTxParams?: {
-        operation?: 0 | 1;
-    }): Promise<TxWriter>;
-    createTxHash(builder: TxDataBuilder, value?: bigint, safeTxParams?: {
-        operation?: 0 | 1;
-    }): Promise<{
-        safeInfo: {
-            nonce: number;
-            threshold: number;
-        };
-        safeTxData: SafeServiceTypes.SafeTransactionData;
-        safeTxHash: any;
-    }>;
-    createTxSignature(safeTxHash: string, owner: EoAccount): Promise<{
-        signature: {
-            signer: `0x${string}`;
-            data: `0x${string}`;
-        };
-    }>;
-    createTransaction(writer: TxWriter, value: bigint, safeTxParams?: {
-        operation?: 0 | 1;
-    }): Promise<{
-        threshold: number;
-        safeTxData: SafeServiceTypes.SafeTransactionData;
-        safeTxHash: any;
-    }>;
-    private getTransactionHash;
-    static parseSafeTx(buffer: TEth.Hex, value?: any): {
-        name: any;
-        args: any[];
-    };
-    static getInstance(senderMix: string | EoAccount, safeAccount: SafeAccount, client: Web3Client, options: {
-        transport?: ISafeServiceTransport;
-        contracts?: typeof config.safe.contracts;
-    }): Promise<GnosisSafeHandler>;
-}

package/lib/esm/safe/GnosisSafeService.d.ts

@@ -1,18 +0,0 @@
-import { IBlockChainExplorer } from '../explorer/IBlockChainExplorer';
-import { Web3Client } from '../clients/Web3Client';
-import { TEth } from '../models/TEth';
-export declare class GnosisSafeService {
-    client: Web3Client;
-    explorer: IBlockChainExplorer;
-    constructor(client: Web3Client, explorer: IBlockChainExplorer);
-    decodeSafeTx(dataHex: TEth.Hex, options?: {
-        decodeContractCall: boolean;
-    }): Promise<{
-        method: string;
-        arguments: any[];
-        value: number | bigint;
-        address: `0x${string}`;
-    }>;
-    private decodeOperation;
-    private decodeMultiSend;
-}

package/lib/esm/safe/SafeTx.d.ts

@@ -1,21 +0,0 @@
-import { Web3Client } from '../clients/Web3Client';
-import { SafeAccount } from '../models/TAccount';
-import { TEth } from '../models/TEth';
-import { TxWriter } from '../txs/TxWriter';
-import { config } from '../config/Config';
-import { ISafeServiceTransport } from './transport/ISafeServiceTransport';
-export declare class SafeTx {
-    safeAccount: SafeAccount;
-    client: Web3Client;
-    options?: {
-        safeTransport?: ISafeServiceTransport;
-        contracts?: typeof config.safe.contracts;
-    };
-    constructor(safeAccount: SafeAccount, client: Web3Client, options?: {
-        safeTransport?: ISafeServiceTransport;
-        contracts?: typeof config.safe.contracts;
-    });
-    execute(data: TEth.TxLike): Promise<TxWriter>;
-    executeBatch(...batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[]): Promise<TxWriter>;
-    private send;
-}

package/lib/esm/safe/transport/FileServiceTransport.d.ts

@@ -1,25 +0,0 @@
-import { Web3Client } from '../../clients/Web3Client';
-import { EoAccount } from '../../models/TAccount';
-import { TAddress } from '../../models/TAddress';
-import { ISafeServiceTransport } from './ISafeServiceTransport';
-import { SafeServiceTypes } from '../types/SafeServiceTypes';
-export declare class FileServiceTransport implements ISafeServiceTransport {
-    client: Web3Client;
-    owner: EoAccount;
-    path: string;
-    constructor(client: Web3Client, owner: EoAccount, path: string);
-    getTx(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigTransactionResponse>;
-    getTxConfirmations(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigConfirmationListResponse>;
-    confirmTx(safeTxHash: string, sig: {
-        signature: string;
-        owner: TAddress;
-    }): Promise<SafeServiceTypes.SignatureResponse>;
-    getSafeInfo(safeAddress: TAddress): Promise<{
-        nonce: any;
-        threshold: any;
-    }>;
-    estimateSafeTransaction(safeAddress: TAddress, safeTxEstimation: any): Promise<SafeServiceTypes.SafeMultisigTransactionEstimateResponse>;
-    proposeTransaction(args: SafeServiceTypes.ProposeTransactionProps): Promise<void>;
-    private get;
-    private save;
-}

package/lib/esm/safe/transport/ISafeServiceTransport.d.ts

@@ -1,16 +0,0 @@
-import { TAddress } from '../../models/TAddress';
-import { SafeServiceTypes } from '../types/SafeServiceTypes';
-export interface ISafeServiceTransport {
-    getTx(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigTransactionResponse>;
-    getTxConfirmations(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigConfirmationListResponse>;
-    confirmTx(safeTxHash: string, sig: {
-        signature: string;
-        owner: TAddress;
-    }): Promise<SafeServiceTypes.SignatureResponse>;
-    getSafeInfo(safeAddress: TAddress): Promise<{
-        nonce: number;
-        threshold: number;
-    }>;
-    estimateSafeTransaction(safeAddress: TAddress, safeTxEstimation: any): Promise<SafeServiceTypes.SafeMultisigTransactionEstimateResponse>;
-    proposeTransaction(args: SafeServiceTypes.ProposeTransactionProps): Promise<void>;
-}

package/lib/esm/safe/transport/InMemoryServiceTransport.d.ts

@@ -1,25 +0,0 @@
-import { Web3Client } from '../../clients/Web3Client';
-import type { EoAccount } from '../../models/TAccount';
-import type { TAddress } from '../../models/TAddress';
-import type { ISafeServiceTransport } from './ISafeServiceTransport';
-import { SafeServiceTypes } from '../types/SafeServiceTypes';
-export declare class InMemoryServiceTransport implements ISafeServiceTransport {
-    client: Web3Client;
-    owner: EoAccount;
-    txs: {
-        [hash: string]: SafeServiceTypes.SafeMultisigTransactionResponse;
-    };
-    constructor(client: Web3Client, owner: EoAccount);
-    getTx(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigTransactionResponse>;
-    getTxConfirmations(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigConfirmationListResponse>;
-    confirmTx(safeTxHash: string, sig: {
-        signature: string;
-        owner: TAddress;
-    }): Promise<SafeServiceTypes.SignatureResponse>;
-    getSafeInfo(safeAddress: TAddress): Promise<{
-        nonce: any;
-        threshold: any;
-    }>;
-    estimateSafeTransaction(safeAddress: TAddress, safeTxEstimation: any): Promise<SafeServiceTypes.SafeMultisigTransactionEstimateResponse>;
-    proposeTransaction(args: SafeServiceTypes.ProposeTransactionProps): Promise<void>;
-}

package/lib/esm/safe/transport/SafeServiceTransport.d.ts

@@ -1,21 +0,0 @@
-import { Web3Client } from '../../clients/Web3Client';
-import { EoAccount } from '../../models/TAccount';
-import { TAddress } from '../../models/TAddress';
-import { ISafeServiceTransport } from './ISafeServiceTransport';
-import { SafeServiceTypes } from '../types/SafeServiceTypes';
-export declare class SafeServiceTransport implements ISafeServiceTransport {
-    client: Web3Client;
-    owners: EoAccount[];
-    constructor(client: Web3Client, owners: EoAccount[]);
-    getTx(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigTransactionResponse>;
-    getTxConfirmations(safeTxHash: string): Promise<SafeServiceTypes.SafeMultisigConfirmationListResponse>;
-    confirmTx(safeTxHash: string, sig: {
-        signature: string;
-        owner: TAddress;
-    }): Promise<SafeServiceTypes.SignatureResponse>;
-    getSafeInfo(safeAddress: TAddress): Promise<SafeServiceTypes.SafeInfoResponse>;
-    estimateSafeTransaction(safeAddress: TAddress, safeTxEstimation: any): Promise<SafeServiceTypes.SafeMultisigTransactionEstimateResponse>;
-    proposeTransaction(args: SafeServiceTypes.ProposeTransactionProps): Promise<void>;
-    private getService;
-    private getServiceApiEndpoint;
-}