salt-sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,881 @@
+import { BigNumber } from 'ethers';
+import { BigNumberish } from 'ethers';
+import { ContractReceipt } from 'ethers';
+import { providers } from 'ethers';
+import { Signer } from 'ethers';
+
+declare type AccountPolicy = {
+    id: string;
+    /**
+     * Type of the policy
+     * @example 'POLICY_TRANSACTION_LIMIT_TOKEN_DENOMINATED'
+     */
+    type: PolicyType;
+    /**
+     * The precise parameters of the policy, specific to the policy type.
+     * @todo Document the parameters for each policy type.
+     */
+    params: unknown;
+    /**
+     * Chain ID of the policy. All policies are associated with a single chain.
+     * @example '11155111'
+     */
+    chain: string;
+    /**
+     * ID of the account the policy belongs to
+     * @example '6824aa9c27c0fa91b32800a4'
+     */
+    accountId: string;
+    /**
+     * ID of the organisation the policy belongs to
+     * @example '679240f8d14559b720d3ba54'
+     */
+    organisationId: string;
+    /**
+     * Policy creator's name for the policy, a short summary of the policy.
+     * @example 'Limit Amount per Transfer'
+     */
+    name: string;
+    /**
+     * Policy creator's longer description of the policy
+     * @example 'Limit the size of transfers on Ethereum Sepolia'
+     */
+    description: string;
+};
+
+/**
+ * Response type for getAccounts API call
+ */
+declare type AccountsResponse = SaltAccount[];
+
+declare type Address = string;
+
+/**
+ * Throw an error if the Signer is not connected to the appropriate orchestration
+ * network.
+ *
+ * @param signer
+ * @param orchestrationChain
+ */
+export declare function assertCorrectChain(signer: Signer, orchestrationChainId: SupportedChainId): Promise<void>;
+
+export declare function assertHasAuthToken(token: string | null): asserts token is string;
+
+export declare function assertValidAddress(address: string, fieldName?: string): asserts address is Address;
+
+export declare function assertValidAuthToken(token: string | null): asserts token is string;
+
+/**
+ * Assert that the chain is valid, and a decimal
+ * @param chain - The chain to assert
+ * @throws InvalidChain - If the chain is invalid
+ */
+export declare function assertValidChain(chain: number): asserts chain is SupportedChainId;
+
+export declare function assertValidEnvironment(environment: string): asserts environment is PreconfiguredEnvironment;
+
+export declare function assertValidParams(params: ConstructorParams): asserts params is ConstructorParams;
+
+export declare function assertValidProvider(provider?: providers.Provider): asserts provider is providers.Provider;
+
+export declare function assertValidSigner(signer?: Signer): asserts signer is Signer;
+
+export declare function assertValidUrl(url: string, fieldName?: string): asserts url is string;
+
+export declare function assertValidUrlNoTrailingSlash(url: string, fieldName?: string): asserts url is string;
+
+export declare function assertValidValue(value: BigNumberish): asserts value is string;
+
+/**
+ * A subset of TransactionParams providing a minimal interface
+ * for building a token transfer transaction
+ */
+declare interface BaseTransferParams {
+    /**
+     * Salt account ID for the transaction
+     * @example '1234567890'
+     */
+    accountId: TransactionParams['accountId'];
+    /**
+     * Recipient address for the transaction
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    to: TransactionParams['to'];
+    /**
+     * Amount of token to send. This is a string representation of the amount of the token being sent.
+     * @example '1'
+     */
+    value: string;
+    /**
+     * Decimals of the token being sent.
+     * @example 18
+     */
+    decimals: number;
+    /**
+     * Ethers signer for the transaction.
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    signer: TransactionParams['signer'];
+    /**
+     * Chain ID of the network (integer)
+     * @example 11155111
+     */
+    chainId: TransactionParams['chainId'];
+    /**
+     * Sending provider of the transaction. If not provided, it will attempt to select a provider depending on the chainId
+     * @example new providers.JsonRpcProvider('https://rpc.ankr.com/eth')
+     */
+    sendingProvider?: TransactionParams['sendingProvider'];
+}
+
+declare interface BroadcastTxResponse {
+    /**
+     * instance of transaction receipt object
+     * @example
+     */
+    receipt?: Receipt;
+    /**
+     * hex representation of the transactionId, this is not the nonce, it uniquely identifies every proposed transaction
+     * @example '0x1'
+     */
+    txId: string;
+    /**
+     * address of the signer
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    signer: string;
+    /**
+     * address of the salt account's smart contract
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    accountAddress: string;
+    /**
+     * error
+     * @example
+     */
+    error?: any;
+}
+
+declare interface CombineTxResponse {
+    /**
+     * true when the combination of the signatures is succesful
+     * @example true
+     */
+    success: boolean;
+    /**
+     * hex representation of the transactionId, this is not the nonce, it uniquely identifies every proposed transaction
+     * @example '0x1'
+     */
+    txId: string;
+    /**
+     * address of the signer
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    signer: string;
+    /**
+     * address of the salt account's smart contract
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    accountAddress: string;
+    /**
+     * error
+     * @example
+     */
+    error?: any;
+}
+
+export declare type ConstructorParams = {
+    /**
+     * The authentication token for the Salt SDK. See {@link authenticate} for the full authentication flow,
+     * or {@link setAuthToken} to set a pre-existing token after calling the constructor.
+     * @defaultValue null
+     */
+    authToken?: string;
+    /**
+     * Environment to use. This will be optional in the future, but right now
+     * it is required. Use 'TESTNET'
+     * @todo Make this optional in the future
+     */
+    environment: Environment;
+};
+
+declare type Environment = 'MAINNET' | 'TESTNET' | EnvironmentConfig;
+
+declare type EnvironmentConfig = {
+    chainId: SupportedChainId;
+    websocketUrl: string;
+    saltDomain: string;
+    apiUrl: string;
+};
+
+declare interface ERC20TransferParams extends BaseTransferParams {
+    type: TransferType.ERC20;
+    tokenAddress: string;
+}
+
+declare enum EVENTS {
+    POLICY_BREACH = "policyBreach",
+    TRANSACTION_SIGN = "transactionSigningComplete",
+    TRANSACTION_COMBINE = "transactionCombiningComplete",
+    TRANSACTION_BROADCAST = "transactionBroadcastingComplete"
+}
+
+/**
+ * Gas price information from Ethereum RPC, containing current network fee data
+ * for transaction cost estimation and execution
+ */
+declare type GasPrice = {
+    /**
+     * The base fee per gas from the most recent block (EIP-1559)
+     * This is the minimum fee required for transaction inclusion
+     */
+    lastBaseFeePerGas: BigNumber;
+    /**
+     * The maximum total fee per gas willing to pay (base fee + priority fee)
+     * This caps the total transaction cost in case of network congestion
+     */
+    maxFeePerGas: BigNumber;
+    /**
+     * The maximum priority fee (tip) per gas to incentivize miners/validators
+     * This is added to the base fee to prioritize transaction inclusion
+     */
+    maxPriorityFeePerGas: BigNumber;
+    /**
+     * Legacy gas price for pre-EIP-1559 transactions
+     * Used for Type 0 and Type 1 transactions on networks that support them
+     */
+    gasPrice: BigNumber;
+};
+
+export declare class InsufficientGas extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidAddress extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidAuthToken extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidChain extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidEnvironment extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidParams extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidProvider extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidSigner extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidUrl extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class InvalidValue extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+declare type Member = {
+    name: string;
+    /**
+     * The public key of the member
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    address: string;
+    /**
+     * The text description of the member's role, set by the user that invited
+     * this member.
+     * @example 'DeFI Team Lead'
+     */
+    role: string;
+    /**
+     * The access level of the member.
+     * 1: Owner
+     * 2: Member
+     * 3: Agent
+     * 4: Member with no permissions
+     * @example 1
+     */
+    accessLevel: MemberAccessLevel;
+    /**
+     * The current status of the member
+     * @example 'Invited'
+     */
+    status: MemberStatus;
+};
+
+declare type MemberAccessLevel = 1 | 2 | 3 | 4;
+
+declare type MemberStatus = 'Active' | 'Invited' | 'Suspended' | 'Inactive';
+
+declare interface NativeTransferParams extends BaseTransferParams {
+    type: TransferType.Native;
+}
+
+declare type Organisation = {
+    /**
+     * Unique identifier of the organisation creator
+     * @example '6824aa9c27c0fa91b32800a4'
+     */
+    user_id: string;
+    /**
+     * The display name of the Organisation
+     * @example 'My Organisation'
+     */
+    name: string;
+    /**
+     * The members of the Organisation
+     * @example [{
+     *  name: 'John Doe',
+     *  address: '0x1234567890123456789012345678901234567890',
+     *  role: 'Admin',
+     *  accessLevel: 1,
+     *  status: 'Active',
+     * }]
+     */
+    members: Member[];
+    /**
+     * The last time the Organisation was updated
+     * @example '2021-01-01T00:00:00.000Z'
+     */
+    lastUpdated?: string;
+    /**
+     * The Terms and Conditions revision that has been accepted by the Organisation creator
+     * @example 1
+     */
+    termsAcceptedVersion?: number;
+};
+
+declare type OrganisationsResponse = Organisation[];
+
+declare interface PolicyBreachResponse {
+    /**
+     * address of the transaction proposer
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    proposerAddress: string;
+    /**
+     * array of rejected policies
+     * @example '[{}]'
+     */
+    rejectedPolicies: any;
+}
+
+declare type PolicyType = 'POLICY_ALLOWED_RECIPIENTS' | 'POLICY_DENIED_RECIPIENTS' | 'POLICY_TRANSACTION_LIMIT_TOKEN_DENOMINATED' | 'POLICY_NOMINATED_APPROVERS' | 'POLICY_DENIED_PROPOSERS';
+
+declare type PreconfiguredEnvironment = 'MAINNET' | 'TESTNET';
+
+declare const process_2: {
+    readonly env: {
+        readonly debug: false;
+    };
+};
+export { process_2 as process }
+
+declare type ProposeTxResponse = SubmitTransactionResult;
+
+declare interface Receipt {
+    /**
+     * transaction hash for the transaction
+     * @example '0xca8e42cca3cbb373ef1215a30b6a862f93758c8df5c0ce28390a39a80b867c36'
+     */
+    transactionHash: string;
+    /**
+     * status of the broadcasted transaction, 1 for success, 0 for failure
+     * @example 1
+     */
+    status: number;
+    /**
+     * block hash of the block in which the transaction was included
+     * @example '0xf47694b502f090d36a6d2281b016fceb260f6321a624dc780c178f1a126ea58f'
+     */
+    blockHash: string;
+    /**
+     * gas used by the transaction
+     * @example '22500'
+     */
+    gasUsed: string;
+    /**
+     * gas paid per unit of gas, in wei
+     * @example '777473623'
+     */
+    effectiveGasPrice: string;
+}
+
+/**
+ * The Salt SDK
+ */
+export declare class Salt {
+    /**
+     * The authentication token for the Salt SDK. See {@link authenticate} for the full authentication flow,
+     * or {@link setAuthToken} to set a pre-existing token.
+     * @private
+     * @defaultValue null
+     */
+    private authToken;
+    /**
+     * The environment for the Salt SDK. See {@link EnvironmentConfig} for the full environment config.
+     * @private
+     * @defaultValue Environments.TESTNET
+     */
+    private environment;
+    /**
+     * The socketIO connector for the Salt SDK. See {@link SaltSocket} for the full socketIO connector.
+     * @todo Will be private
+     * @defaultValue null
+     */
+    socketIOConnector: SaltSocket | null;
+    /**
+     * Creates an instance of the Salt SDK
+     * @param params - The constructor parameters
+     */
+    constructor(params?: ConstructorParams);
+    /**
+     * Initiate a SIWE authentication flow to get an authentication token from the Salt API
+     * This will require a signature from the signer, which will be used to authenticate the user.
+     * @param signer - The Ethereum signer to use for the authentication flow
+     * @returns long lived authentication token
+     */
+    authenticate(signer: Signer): Promise<void>;
+    initSocket(): Promise<unknown>;
+    /**
+     * Sets the authentication token for the Salt SDK. You can authenticate with {@link authenticate}, or set a
+     * pre-existing token with this function.
+     * @param authToken - The authentication token to use for this connection
+     */
+    setAuthToken(authToken: string): void;
+    /**
+     * Gets the list of organisations that the user is a member of
+     * @returns The list of organisations
+     */
+    getOrganisations(): Promise<OrganisationsResponse>;
+    /**
+     * Gets the details of a specific account
+     * @param accountId - The ID of the account
+     * @returns The account details
+     */
+    getAccount(accountId: string): Promise<SaltAccount>;
+    /**
+     * Gets the list of accounts that belong to an organisation
+     * @param organisationId - The ID of the organisation
+     * @returns The list of accounts
+     */
+    getAccounts(organisationId: string): Promise<AccountsResponse>;
+    /**
+     * Gets the list of token balances for an account. This list is not exhaustive.
+     * @param accountId - The ID of the account
+     * @returns The list of tokens & balances
+     */
+    getAccountTokens(accountId: string): Promise<TokenBalanceResponse>;
+    /**
+     * Gets the nonce for an account on a specific chain. The nonce is an incrementing number stored
+     * by Salt that is used to prevent replay attacks.
+     * @param accountId - The ID of the account
+     * @param chainId - The ID of the chain
+     * @returns The nonce
+     */
+    getAccountNonce(accountId: string, chainId: number): Promise<number>;
+    /**
+     * Gets the current gas price for a specific chain.
+     * @param chainId - The ID of the chain
+     * @returns The current gas price
+     */
+    getGasPrice(chainId: number): Promise<GasPrice>;
+    /**
+     * creates a new transfer object
+     * @param params
+     */
+    transfer(params: TransferParams): Promise<Transfer>;
+}
+
+/**
+ * A specifc Salt account within an Organisation
+ */
+declare type SaltAccount = {
+    /**
+     * The ID of the account
+     * @example '6824aa9c27c0fa91b32800a4'
+     */
+    id: string;
+    /**
+     * The address of the account on the orchestration chain. This is required for orchestration
+     * but is not the address that you will send or receive tokens from. See {@link publicKey} for that.
+     * @example '0x7890123456789012345678901234567890123456'
+     */
+    address: string;
+    /**
+     * Public key of the account. This is the address that you will send or receive tokens from.
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    publicKey: string;
+    /**
+     * The public key of the account creator
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    creatorAddress: string;
+    /**
+     * The name of the account
+     * @example 'Staking'
+     */
+    name: string;
+    /**
+     * Signers for the account
+     * @example ['0x1234567890123456789012345678901234567890', '0x2345678901234567890123456789012345678901', '0x3456789012345678901234567890123456789012']
+     */
+    signers: string[];
+    /**
+     * Policies for the account
+     */
+    policies: AccountPolicy[];
+};
+
+declare class SaltSocket {
+    /**
+     * The socketIO connector for the Salt SDK. Required for the async communication during transaction signing and setup
+     * @defaultValue null
+     */
+    private socket;
+    private websocketUrl;
+    private authToken;
+    constructor(authToken: string, websocketUrl: string);
+    init(): Promise<unknown>;
+    /**
+     * join account's websocket events channel
+     * @param accountAddress
+     * @returns
+     */
+    joinAccountChannel: (accountAddress: string) => void;
+    /**
+     * disconnect socket from server
+     */
+    disconnect: () => void;
+    /**
+     * subsribe to POLICY_BREACH event
+     * @param callback
+     * @returns
+     */
+    subscribeToPolicyBreachEvent: (callback: (data: PolicyBreachResponse) => void) => void;
+    /**
+     * subsribe to TRANSACTION_SIGN event
+     * @param callback
+     * @returns
+     */
+    subscribeToTransactionSignEvent: (callback: (data: SignTxResponse) => void) => void;
+    /**
+     * SUBSCRIBE TO TRANSACTION_COMBINE event
+     * @param callback
+     * @returns
+     */
+    subscribeToTransactionCombineEvent: (callback: (data: CombineTxResponse) => void) => void;
+    /**
+     * subscribe to TRANSACTION_BROADCAST event
+     * @param callback
+     * @returns
+     */
+    subscribeToTransactionBroadcastEvent: (callback: (data: BroadcastTxResponse) => void) => void;
+    /**
+     * unsubscribe from socket any of EVENTS' events
+     * @param event
+     * @param callback
+     * @returns
+     */
+    unsubscribe: (event: EVENTS) => void;
+}
+
+declare interface SignTxResponse {
+    /**
+     * ethers.js transaction receipt object
+     * @example '
+     */
+    receipt?: ContractReceipt;
+    /**
+     * hex representation of the transactionId, this is not the nonce, it uniquely identifies every proposed transaction
+     * @example '0x1'
+     */
+    txId: string;
+    /**
+     * address of the signer
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    signer: string;
+    /**
+     * address of the salt account's smart contract
+     * @example '0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97'
+     */
+    accountAddress: string;
+    /**
+     * error
+     * @example
+     */
+    error?: any;
+    /**
+     * resource lock of the robos, if true it means another signer is currently using the robos.
+     * @example true
+     */
+    locked?: boolean;
+}
+
+declare type StateTransitionHandler = (data: TransitionData) => void | Promise<void>;
+
+declare interface SubmitTransactionResult {
+    submittedTx: TransactionParams;
+    txId: string;
+    txInfo: string;
+    receipt: ContractReceipt;
+}
+
+declare type SupportedChainId = 11155111 | 421614 | 80002 | 50312 | 1 | 42161;
+
+/**
+ * Balance of a token for a specified account
+ */
+declare type TokenBalance = {
+    /**
+     * The address of the token
+     * @example '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
+     */
+    address: string;
+    /**
+     * The symbol of the token
+     * @example 'WETH'
+     */
+    symbol: string;
+    /**
+     * The name of the token
+     * @example 'Wrapped Ether'
+     */
+    name: string;
+    /**
+     * The logo of the token
+     * @example 'https://assets.coingecko.com/coins/images/279/large/ethereum.png'
+     */
+    logo: string;
+    /**
+     * Precision of the token
+     * @example 18
+     */
+    decimals: number;
+    /**
+     * The balance of the token in human-readable format (decimal adjusted)
+     * @example '0.13191'
+     */
+    balance: string;
+    /**
+     * The price of the token
+     * @example 1800
+     */
+    price: number | string;
+    /**
+     * The chain ID of the token
+     * @example '11155111'
+     */
+    chainId: string;
+};
+
+/**
+ * Response type for getAccountTokens API call
+ */
+declare type TokenBalanceResponse = TokenBalance[];
+
+export declare interface TransactionParams {
+    /**
+     * ID of the Salt account to use for the transaction
+     * @example '1234567890'
+     */
+    accountId: string;
+    /**
+     * Recipient address for the transaction
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    to: string;
+    /**
+     * Amount of token to send. This is a string, eventually parsed with ethers.utils.parseEther
+     */
+    value: string;
+    /**
+     * Chain ID of the network (integer)
+     * @example 11155111
+     */
+    chainId: number;
+    /**
+     * Nonce of the transaction. If not provided, it will be fetched from the Salt API
+     * @example 1
+     */
+    nonce?: string | number;
+    /**
+     * Data of the transaction.
+     * @defaultValue '0x'
+     * @example '0x'
+     */
+    data?: string;
+    /**
+     * Current gas price of the chain.
+     * @example '1000000000000000000'
+     */
+    gasPrice?: string | number;
+    /**
+     * Gas fee of the transaction.
+     * @example '40000000'
+     */
+    gas?: string | number;
+    /**
+     * Vault address of the transaction.
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    vaultAddress: string;
+    /**
+     * Signer of the transaction. If not provided, it will be set to the accountId
+     * @todo This should be made optional, and inferred from the accountID
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    signer: Signer;
+    /**
+     * Notes of the transaction. If not provided, it will be set to an empty string
+     * @example 'This is a note'
+     */
+    notes?: string;
+    /**
+     * Return hash of the transaction. If not provided, it will be set to false
+     * @example true
+     * @defaultValue false
+     */
+    returnHash?: boolean;
+    /**
+     * Sending provider of the transaction. If not provided, it will select a provider depending on the chainId
+     * @example new providers.JsonRpcProvider('https://rpc.ankr.com/eth')
+     */
+    sendingProvider?: providers.Provider;
+    /**
+     * Vault public key of the transaction.
+     * @example '0x1234567890123456789012345678901234567890'
+     */
+    vaultPublicKey: string;
+}
+
+declare class Transfer {
+    /**
+     * The authentication token for the Salt SDK. See {@link authenticate} for the full authentication flow,
+     * or {@link setAuthToken} to set a pre-existing token.
+     * @private
+     */
+    private authToken;
+    /**
+     * The environment for the Salt SDK. See {@link EnvironmentConfig} for the full environment config.
+     * @private
+     * @defaultValue Environments.TESTNET
+     */
+    private environment;
+    /**
+     * The socketIO connector for the Salt SDK. See {@link SaltSocket} for the full socketIO connector.
+     */
+    private socketIOConnector;
+    /**
+     * the current state of the transfer. See {@link TRANSFER_STATES} for the complete list of states
+     * @defaultValue TRANSFER_STATES.IDLE
+     */
+    private currentState;
+    /**
+     *  the number of signatures required for this transaction to gather in the TRANSFER_STATES.SIGN state
+     */
+    private requiredSignatures;
+    /**
+     * the transaction parameters see {@link TransactionParams} for the comprehensive type description
+     */
+    private params;
+    /**
+     * the object returned when proposing the transaction to the orchestration network in TRANSFER_STATE.propose state. See {@link SubmitTransactionResult} for the complete   interface descriptions
+     *@defaultValue null
+     */
+    private submitTransactionResult;
+    /**
+     * Signatures gathered in TRANSFER_STATE.SIGN. See {@link SignTxResponse} for the complete interface description
+     * @defaultValue []
+     */
+    private signatures;
+    /**
+     * Response gathered in TRANSFER_STATE.COMBINE. See {@link CombineTxResponse} for the complete interface description
+     * @defaultValue null
+     */
+    private combineResponse;
+    /**
+     * Response gathered in TRANSFER_STATE.BROADCAST. See {@link BroadcastTxResponse} for the complete interface description
+     * @defaultValue null
+     */
+    private broadcastResponse;
+    /**
+     * user defined state transition handlers. See {@link StateTransitionHandler} for the complete type description
+     * @defaultValue new Map()
+     */
+    private transitionHandlers;
+    constructor(socketIOConnector: SaltSocket, environment: EnvironmentConfig, authToken: string, requiredSignatures: number, params: TransactionParams);
+    private isValidTransition;
+    getCurrentState(): TRANSFER_STATES;
+    getBroadcastTxResponse(): BroadcastTxResponse | null;
+    getRequiredSignatures(): number;
+    getSignatures(): SignTxResponse[];
+    getCombineResponse(): CombineTxResponse | null;
+    onTransition(fromState: TRANSFER_STATES, toState: TRANSFER_STATES, handler: StateTransitionHandler): void;
+    transitionTo(data: TransitionData, newState: TRANSFER_STATES): Promise<void>;
+    initListeners(): void;
+    /**
+     * Submits a transaction to the blockchain using the Intu and Salt
+     * @param params - The transaction parameters
+     * @returns true if it was successfully submitted
+     */
+    submitTransaction(): Promise<boolean>;
+}
+
+declare enum TRANSFER_STATES {
+    IDLE = 0,
+    PROPOSE = 1,
+    SIGN = 2,
+    COMBINE = 3,
+    BROADCAST = 4,
+    END = 5
+}
+
+export declare type TransferParams = ERC20TransferParams | NativeTransferParams;
+
+export declare enum TransferType {
+    ERC20 = "ERC20",
+    Native = "Native"
+}
+
+declare type TransitionData = BroadcastTxResponse | CombineTxResponse | SignTxResponse[] | PolicyBreachResponse | ProposeTxResponse | null;
+
+/**
+ * Thrown when parameters provided for a function are invalid.
+ */
+export declare class ValidationError extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export declare class WrongChain extends Error {
+    readonly cause?: Error;
+    constructor(message: string, originalError?: Error);
+}
+
+export { }