@stellar/typescript-wallet-sdk 1.1.0-alpha.2 → 1.1.1

package/lib/index.d.ts

@@ -1,12 +1,31 @@
-import * as walletSdk from "./walletSdk";
-import { Keypair } from "stellar-sdk";
+/**
+ * Types
+ */
+import * as Types from "./walletSdk/Types";
+export { Types };
+/**
+ * Classes
+ */
+export { Wallet, Config, StellarConfiguration, ApplicationConfiguration, } from "./walletSdk";
 export { Anchor } from "./walletSdk/Anchor";
-export * as AnchorTypes from "./walletSdk/Anchor/Types";
-export * as Exception from "./walletSdk/exception";
-export { Interactive, InteractiveResponse, InteractiveResponseType } from "./walletSdk/interactive";
-export { TomlInfo, parseToml } from "./walletSdk/toml";
+export { Sep24 } from "./walletSdk/Anchor/Sep24";
+export { IssuedAssetId, NativeAssetId, FiatAssetId } from "./walletSdk/Asset";
+export { Sep10, WalletSigner, DefaultSigner } from "./walletSdk/Auth";
+export { PublicKeypair, SigningKeypair, AccountService, Stellar, TransactionBuilder, } from "./walletSdk/Horizon";
+export { Recovery } from "./walletSdk/Recovery";
 export { Watcher } from "./walletSdk/Watcher";
-export * as WatcherTypes from "./walletSdk/Watcher/Types";
+/**
+ * Utils
+ */
+import * as Utils from "./walletSdk/Utils";
+export { Utils };
+/**
+ * Exceptions
+ */
+import * as Exceptions from "./walletSdk/Exceptions";
+export { Exceptions };
+import * as walletSdk from "./walletSdk";
+import { Keypair } from "stellar-sdk";
 export { walletSdk, Keypair };
 declare const _default: {
     walletSdk: typeof walletSdk;

package/lib/walletSdk/Anchor/Sep24.d.ts

@@ -0,0 +1,48 @@
+import { AxiosInstance } from "axios";
+import { Anchor } from "../Anchor";
+import { Sep24PostParams, Sep24PostResponse, AnchorTransaction, GetTransactionParams, GetTransactionsParams, AnchorServiceInfo } from "../Types";
+import { Watcher } from "../Watcher";
+type Sep24Params = {
+    anchor: Anchor;
+    httpClient: AxiosInstance;
+};
+export declare class Sep24 {
+    private anchor;
+    private httpClient;
+    constructor(params: Sep24Params);
+    deposit({ assetCode, authToken, lang, extraFields, destinationMemo, destinationAccount, }: Sep24PostParams): Promise<Sep24PostResponse>;
+    withdraw({ assetCode, authToken, lang, extraFields, withdrawalAccount, }: Sep24PostParams): Promise<Sep24PostResponse>;
+    private flow;
+    getServicesInfo(): Promise<AnchorServiceInfo>;
+    watcher(): Watcher;
+    /**
+     * Get single transaction's current status and details. One of the [id], [stellarTransactionId],
+     * [externalTransactionId] must be provided.
+     *
+     * @param authToken auth token of the account authenticated with the anchor
+     * @param id transaction ID
+     * @param stellarTransactionId stellar transaction ID
+     * @param externalTransactionId external transaction ID
+     * @return transaction object
+     * @throws [MissingTransactionIdError] if none of the id params is provided
+     * @throws [InvalidTransactionResponseError] if Anchor returns an invalid transaction
+     * @throws [ServerRequestFailedError] if server request fails
+     */
+    getTransactionBy({ authToken, id, stellarTransactionId, externalTransactionId, lang, }: GetTransactionParams): Promise<AnchorTransaction>;
+    /**
+     * Get account's transactions specified by asset and other params.
+     *
+     * @param authToken auth token of the account authenticated with the anchor
+     * @param assetCode target asset to query for
+     * @param noOlderThan response should contain transactions starting on or after this date & time
+     * @param limit response should contain at most 'limit' transactions
+     * @param kind kind of transaction that is desired. E.g.: 'deposit', 'withdrawal'
+     * @param pagingId response should contain transactions starting prior to this ID (exclusive)
+     * @param lang desired language (localization), it can also accept locale in the format 'en-US'
+     * @return list of transactions as requested by the client, sorted in time-descending order
+     * @throws [InvalidTransactionsResponseError] if Anchor returns an invalid response
+     * @throws [ServerRequestFailedError] if server request fails
+     */
+    getTransactionsForAsset({ authToken, assetCode, noOlderThan, limit, kind, pagingId, lang, }: GetTransactionsParams): Promise<AnchorTransaction[]>;
+}
+export {};

package/lib/walletSdk/Anchor/index.d.ts

@@ -0,0 +1,24 @@
+import { AxiosInstance } from "axios";
+import { Config } from "walletSdk";
+import { Sep10 } from "../Auth";
+import { Sep24 } from "./Sep24";
+import { AnchorServiceInfo, TomlInfo } from "../Types";
+type AnchorParams = {
+    cfg: Config;
+    homeDomain: string;
+    httpClient: AxiosInstance;
+    language: string;
+};
+export declare class Anchor {
+    language: string;
+    private cfg;
+    private homeDomain;
+    private httpClient;
+    private toml;
+    constructor(params: AnchorParams);
+    sep1(shouldRefresh?: boolean): Promise<TomlInfo>;
+    sep10(): Promise<Sep10>;
+    sep24(): Sep24;
+    getServicesInfo(lang?: string): Promise<AnchorServiceInfo>;
+}
+export {};

package/lib/walletSdk/Asset/index.d.ts

@@ -0,0 +1,27 @@
+declare class AssetId {
+    id: string;
+    scheme: string;
+    get sep38(): string;
+}
+export declare class StellarAssetId extends AssetId {
+    id: string;
+    code: string;
+    issuer: string;
+    scheme: string;
+    toAsset(): any;
+}
+export declare class IssuedAssetId extends StellarAssetId {
+    constructor(code: string, issuer: string);
+    toString(): string;
+}
+export declare class NativeAssetId extends StellarAssetId {
+    id: string;
+    code: string;
+}
+export declare class FiatAssetId extends AssetId {
+    id: string;
+    scheme: string;
+    constructor(code: string);
+    toString(): string;
+}
+export {};

package/lib/walletSdk/Auth/WalletSigner.d.ts

@@ -0,0 +1,7 @@
+import { Transaction } from "stellar-sdk";
+import { SignWithClientAccountParams, SignWithDomainAccountParams } from "../Types";
+export interface WalletSigner {
+    signWithClientAccount({ transaction, accountKp, }: SignWithClientAccountParams): Transaction;
+    signWithDomainAccount({ transactionXDR, networkPassphrase, accountKp, }: SignWithDomainAccountParams): Promise<Transaction>;
+}
+export declare const DefaultSigner: WalletSigner;

package/lib/walletSdk/Auth/index.d.ts

@@ -0,0 +1,21 @@
+import { AxiosInstance } from "axios";
+import { Config } from "walletSdk";
+import { AuthenticateParams, AuthToken } from "../Types";
+export { WalletSigner, DefaultSigner } from "./WalletSigner";
+type Sep10Params = {
+    cfg: Config;
+    webAuthEndpoint: string;
+    homeDomain: string;
+    httpClient: AxiosInstance;
+};
+export declare class Sep10 {
+    private cfg;
+    private webAuthEndpoint;
+    private homeDomain;
+    private httpClient;
+    constructor(params: Sep10Params);
+    authenticate({ accountKp, walletSigner, memoId, clientDomain, }: AuthenticateParams): Promise<AuthToken>;
+    private challenge;
+    private sign;
+    private getToken;
+}

package/lib/walletSdk/Exceptions/index.d.ts

@@ -0,0 +1,56 @@
+import { Networks, Horizon } from "stellar-sdk";
+import { AnchorTransaction, FLOW_TYPE } from "../Types";
+export declare class ServerRequestFailedError extends Error {
+    constructor(e: Error);
+}
+export declare class AssetNotSupportedError extends Error {
+    constructor(type: FLOW_TYPE, assetCode: string);
+}
+export declare class InvalidMemoError extends Error {
+    constructor();
+}
+export declare class ClientDomainWithMemoError extends Error {
+    constructor();
+}
+export declare class MissingTransactionIdError extends Error {
+    constructor();
+}
+export declare class InvalidTransactionResponseError extends Error {
+    constructor(transactionResponse: AnchorTransaction);
+}
+export declare class InvalidTransactionsResponseError extends Error {
+    constructor(transactionsResponse: AnchorTransaction[]);
+}
+export declare class AccountDoesNotExistError extends Error {
+    constructor(network: Networks);
+}
+export declare class TransactionSubmitFailedError extends Error {
+    constructor(response: Horizon.SubmitTransactionResponse);
+}
+export declare class InsufficientStartingBalanceError extends Error {
+    constructor();
+}
+export declare class MissingTokenError extends Error {
+    constructor();
+}
+export declare class InvalidTokenError extends Error {
+    constructor();
+}
+export declare class ExpiredTokenError extends Error {
+    constructor(expiresAt: number);
+}
+export declare class TransactionSubmitWithFeeIncreaseFailedError extends Error {
+    constructor(maxFee: number, e: Error);
+}
+export declare class SignerRequiredError extends Error {
+    constructor();
+}
+export declare class OperationsLimitExceededError extends Error {
+    constructor(maxLimit: number);
+}
+export declare class WithdrawalTxNotPendingUserTransferStartError extends Error {
+    constructor(status: string);
+}
+export declare class WithdrawalTxMissingMemoError extends Error {
+    constructor();
+}

package/lib/walletSdk/{horizon → Horizon}/Account.d.ts

@@ -1,20 +1,17 @@
 import { Keypair, Transaction, FeeBumpTransaction } from "stellar-sdk";
-declare class AccountKeypair {
+export declare class AccountKeypair {
     keypair: Keypair;
     constructor(keypair: Keypair);
     get publicKey(): string;
     toString(): string;
 }
 export declare class PublicKeypair extends AccountKeypair {
-    keypair: Keypair;
     constructor(keypair: Keypair);
-    static fromPublicKey: (str: string) => PublicKeypair;
+    static fromPublicKey: (publicKey: string) => PublicKeypair;
 }
 export declare class SigningKeypair extends AccountKeypair {
-    keypair: Keypair;
     constructor(keypair: Keypair);
-    static fromSecret: (secret: string) => SigningKeypair;
+    static fromSecret: (secretKey: string) => SigningKeypair;
     get secretKey(): string;
     sign(transaction: Transaction | FeeBumpTransaction): Transaction | FeeBumpTransaction;
 }
-export {};

package/lib/walletSdk/Horizon/AccountService.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import { Server, ServerApi } from "stellar-sdk";
+import { Config } from "walletSdk";
+import { SigningKeypair } from "./Account";
+import { HORIZON_ORDER } from "../Types";
+export declare class AccountService {
+    private server;
+    private network;
+    constructor(cfg: Config);
+    /**
+     * Generate new account keypair (public and secret key). This key pair can be
+     * used to create a Stellar account.
+     *
+     * @return public key and secret key
+     */
+    createKeypair(): SigningKeypair;
+    /**
+     * Generate new account keypair (public and secret key) from random bytes. This key pair can be
+     * used to create a Stellar account.
+     *
+     * @return public key and secret key
+     */
+    createKeypairFromRandom(randomBytes: Buffer): SigningKeypair;
+    /**
+     * Get account information from the Stellar network.
+     *
+     * @param accountAddress Stellar address of the account
+     * @param serverInstance optional Horizon server instance when default doesn't work
+     * @return account information
+     */
+    getInfo({ accountAddress, serverInstance, }: {
+        accountAddress: string;
+        serverInstance?: Server;
+    }): Promise<ServerApi.AccountRecord>;
+    /**
+     * Get account operations for the specified Stellar address.
+     *
+     * @param accountAddress Stellar address of the account
+     * @param limit optional how many operations to fetch, maximum is 200, default is 10
+     * @param order optional data order, ascending or descending, defaults to descending
+     * @param cursor optional cursor to specify a starting point
+     * @param includeFailed optional flag to include failed operations, defaults to false
+     * @return a list of operations
+     * @throws [OperationsLimitExceededException] when maximum limit of 200 is exceeded
+     */
+    getHistory({ accountAddress, limit, order, cursor, includeFailed, }: {
+        accountAddress: string;
+        limit?: number;
+        order?: HORIZON_ORDER;
+        cursor?: string;
+        includeFailed?: boolean;
+    }): Promise<ServerApi.CollectionPage<ServerApi.OperationRecord>>;
+}

package/lib/walletSdk/Horizon/Stellar.d.ts

@@ -0,0 +1,16 @@
+import { Server, Transaction, FeeBumpTransaction } from "stellar-sdk";
+import { Config } from "walletSdk";
+import { AccountService } from "./AccountService";
+import { TransactionBuilder } from "./Transaction/TransactionBuilder";
+import { TransactionParams, SubmitWithFeeIncreaseParams, FeeBumpTransactionParams } from "../Types";
+export declare class Stellar {
+    private cfg;
+    server: Server;
+    constructor(cfg: Config);
+    account(): AccountService;
+    transaction({ sourceAddress, baseFee, memo, timebounds, }: TransactionParams): Promise<TransactionBuilder>;
+    makeFeeBump({ feeAddress, transaction, baseFee, }: FeeBumpTransactionParams): FeeBumpTransaction;
+    submitTransaction(signedTransaction: Transaction | FeeBumpTransaction): Promise<boolean>;
+    submitWithFeeIncrease({ sourceAddress, timeout, baseFeeIncrease, buildingFunction, signerFunction, baseFee, memo, maxFee, }: SubmitWithFeeIncreaseParams): Promise<Transaction>;
+    decodeTransaction(xdr: string): Transaction | FeeBumpTransaction;
+}

package/lib/walletSdk/Horizon/Transaction/TransactionBuilder.d.ts

@@ -0,0 +1,20 @@
+import { Account as StellarAccount, Transaction, Server, Memo, xdr } from "stellar-sdk";
+import { Config } from "walletSdk";
+import { AccountKeypair } from "../Account";
+import { IssuedAssetId, StellarAssetId } from "../../Asset";
+import { WithdrawTransaction } from "../../Types";
+export declare class TransactionBuilder {
+    private network;
+    private operations;
+    private builder;
+    sourceAccount: string;
+    constructor(cfg: Config, sourceAccount: StellarAccount, baseFee?: number, memo?: Memo, timebounds?: Server.Timebounds);
+    createAccount(newAccount: AccountKeypair, startingBalance?: number): TransactionBuilder;
+    transfer(destinationAddress: string, assetId: StellarAssetId, amount: string): TransactionBuilder;
+    addOperation(op: xdr.Operation): TransactionBuilder;
+    setMemo(memo: Memo): TransactionBuilder;
+    addAssetSupport(asset: IssuedAssetId, trustLimit?: string): TransactionBuilder;
+    removeAssetSupport(asset: IssuedAssetId): TransactionBuilder;
+    build(): Transaction;
+    transferWithdrawalTransaction(transaction: WithdrawTransaction, assetId: StellarAssetId): TransactionBuilder;
+}

package/lib/walletSdk/Horizon/index.d.ts

@@ -0,0 +1,4 @@
+export { PublicKeypair, SigningKeypair } from "./Account";
+export { AccountService } from "./AccountService";
+export { Stellar } from "./Stellar";
+export { TransactionBuilder } from "./Transaction/TransactionBuilder";

package/lib/walletSdk/Recovery/index.d.ts

@@ -0,0 +1,18 @@
+import { AxiosInstance } from "axios";
+import { Server } from "stellar-sdk";
+import { Config } from "walletSdk";
+import { Stellar } from "../Horizon";
+type RecoveryParams = {
+    cfg: Config;
+    stellar: Stellar;
+    httpClient: AxiosInstance;
+    servers: Server[];
+};
+export declare class Recovery {
+    private cfg;
+    private stellar;
+    private httpClient;
+    private servers;
+    constructor(params: RecoveryParams);
+}
+export {};

package/lib/walletSdk/{Watcher/Types.d.ts → Types/anchor.d.ts}

@@ -1,3 +1,92 @@
+import { MemoType } from "stellar-sdk";
+import { Optional } from "utility-types";
+export interface AnchorServiceInfo {
+    deposit: AssetInfoMap;
+    withdraw: AssetInfoMap;
+    fee: {
+        enabled: boolean;
+    };
+    features: {
+        account_creation: boolean;
+        claimable_balances: boolean;
+    };
+}
+export interface AssetInfoMap {
+    [asset_code: string]: AnchorServiceAsset;
+}
+export interface AnchorServiceAsset {
+    enabled: boolean;
+    min_amount: number;
+    max_amount: number;
+    fee_fixed: number;
+    fee_percent: number;
+}
+export interface BaseTransaction {
+    id: string;
+    kind: string;
+    status: TransactionStatus;
+    more_info_url: string;
+    started_at: string;
+    message?: string;
+}
+export interface ProcessingAnchorTransaction extends BaseTransaction {
+    status_eta?: number;
+    kyc_verified?: boolean;
+    amount_in_asset?: string;
+    amount_in: string;
+    amount_out_asset?: string;
+    amount_out: string;
+    amount_fee_asset?: string;
+    amount_fee: string;
+    completed_at?: string;
+    stellar_transaction_id?: string;
+    external_transaction_id?: string;
+    refunds?: Refunds;
+}
+export interface DepositTransaction extends ProcessingAnchorTransaction {
+    from?: string;
+    to?: string;
+    deposit_memo?: string;
+    deposit_memo_type?: MemoType;
+    claimable_balance_id?: string;
+}
+export interface WithdrawTransaction extends ProcessingAnchorTransaction {
+    from: string;
+    to?: string;
+    withdraw_memo?: string;
+    withdraw_memo_type: MemoType;
+    withdraw_anchor_account: string;
+}
+export interface ErrorTransaction extends Optional<DepositTransaction & WithdrawTransaction> {
+}
+export type AnchorTransaction = DepositTransaction | WithdrawTransaction | ErrorTransaction;
+export interface Refunds {
+    amount_refunded: string;
+    amount_fee: string;
+    payments: Payment[];
+}
+export interface Payment {
+    id: string;
+    id_type: string;
+    amount: string;
+    fee: string;
+}
+export type GetTransactionParams = {
+    authToken: string;
+    id?: string;
+    stellarTransactionId?: string;
+    externalTransactionId?: string;
+    lang?: string;
+};
+export type GetTransactionsParams = {
+    authToken: string;
+    assetCode: string;
+    noOlderThan?: string;
+    limit?: number;
+    kind?: string;
+    pagingId?: string;
+    lang?: string;
+};
 export declare enum TransactionStatus {
     /**
      * There is not yet enough information for this transaction to be initiated. Perhaps the user has
@@ -57,9 +146,3 @@ export declare enum TransactionStatus {
     /** Catch-all for any error not enumerated above. */
     error = "error"
 }
-export type WatcherRefreshFunction = () => void;
-export type WatcherStopFunction = () => void;
-export interface WatcherResponse {
-    refresh: WatcherRefreshFunction;
-    stop: WatcherStopFunction;
-}

package/lib/walletSdk/Types/auth.d.ts

@@ -0,0 +1,35 @@
+import { Transaction } from "stellar-sdk";
+import { WalletSigner } from "../Auth/WalletSigner";
+import { AccountKeypair } from "../Horizon/Account";
+export type AuthenticateParams = {
+    accountKp: AccountKeypair;
+    walletSigner?: WalletSigner;
+    memoId?: string;
+    clientDomain?: string;
+};
+export type AuthToken = string;
+export type ChallengeParams = {
+    accountKp: AccountKeypair;
+    memoId?: string;
+    clientDomain?: string;
+};
+export type XdrEncodedTransaction = string;
+export type NetworkPassphrase = string;
+export type ChallengeResponse = {
+    transaction: XdrEncodedTransaction;
+    network_passphrase: NetworkPassphrase;
+};
+export type SignParams = {
+    accountKp: AccountKeypair;
+    challengeResponse: ChallengeResponse;
+    walletSigner: WalletSigner;
+};
+export type SignWithClientAccountParams = {
+    transaction: Transaction;
+    accountKp: AccountKeypair;
+};
+export type SignWithDomainAccountParams = {
+    transactionXDR: XdrEncodedTransaction;
+    networkPassphrase: NetworkPassphrase;
+    accountKp: AccountKeypair;
+};

package/lib/walletSdk/Types/horizon.d.ts

@@ -0,0 +1,34 @@
+import { Memo, Server, Transaction } from "stellar-sdk";
+import { AccountKeypair } from "../Horizon/Account";
+import { TransactionBuilder } from "../Horizon/Transaction/TransactionBuilder";
+export declare enum NETWORK_URLS {
+    PUBLIC = "https://horizon.stellar.org",
+    TESTNET = "https://horizon-testnet.stellar.org"
+}
+export type TransactionParams = {
+    sourceAddress: AccountKeypair;
+    baseFee: number;
+    memo?: Memo;
+    timebounds?: Server.Timebounds | number;
+};
+export type FeeBumpTransactionParams = {
+    feeAddress: AccountKeypair;
+    transaction: Transaction;
+    baseFee?: number;
+};
+export type SubmitWithFeeIncreaseParams = {
+    sourceAddress: AccountKeypair;
+    timeout: number;
+    baseFeeIncrease: number;
+    buildingFunction: (TransactionBuilder: any) => TransactionBuilder;
+    signerFunction?: (Transaction: any) => Transaction;
+    baseFee?: number;
+    memo?: Memo;
+    maxFee?: number;
+};
+export declare const HORIZON_LIMIT_MAX = 200;
+export declare const HORIZON_LIMIT_DEFAULT = 10;
+export declare enum HORIZON_ORDER {
+    ASC = "asc",
+    DESC = "desc"
+}

package/lib/walletSdk/Types/index.d.ts

@@ -0,0 +1,30 @@
+import { Server, Networks } from "stellar-sdk";
+import { ApplicationConfiguration, StellarConfiguration } from "walletSdk";
+export type WalletParams = {
+    stellarConfiguration: StellarConfiguration;
+    applicationConfiguration?: ApplicationConfiguration;
+    language?: string;
+};
+export type WalletAnchor = {
+    homeDomain: string;
+    language?: string;
+};
+export type WalletRecovery = {
+    servers: Server[];
+};
+export type ConfigParams = {
+    stellarConfiguration: StellarConfiguration;
+    applicationConfiguration?: ApplicationConfiguration;
+};
+export type StellarConfigurationParams = {
+    network: Networks;
+    horizonUrl: string;
+    baseFee?: number;
+    defaultTimeout?: number;
+};
+export * from "./anchor";
+export * from "./auth";
+export * from "./horizon";
+export * from "./sep24";
+export * from "./utils";
+export * from "./watcher";

package/lib/walletSdk/Types/sep24.d.ts

@@ -0,0 +1,30 @@
+import { Memo } from "stellar-sdk";
+import { AuthToken } from "./auth";
+export declare enum FLOW_TYPE {
+    DEPOSIT = "deposit",
+    WITHDRAW = "withdraw"
+}
+export type ExtraFields = {
+    [api_key: string]: string;
+};
+export type Sep24PostParams = {
+    authToken: AuthToken;
+    assetCode: string;
+    lang?: string;
+    extraFields?: ExtraFields;
+    destinationMemo?: Memo;
+    destinationAccount?: string;
+    withdrawalAccount?: string;
+    account?: string;
+};
+export declare enum Sep24ResponseType {
+    authentication_required = "authentication_required",
+    interactive_customer_info_needed = "interactive_customer_info_needed",
+    error = "error"
+}
+export interface Sep24PostResponse {
+    type: Sep24ResponseType.authentication_required | Sep24ResponseType.interactive_customer_info_needed | Sep24ResponseType.error;
+    id?: string;
+    url?: string;
+    error?: string;
+}

package/lib/walletSdk/{toml/index.d.ts → Types/utils.d.ts}

@@ -47,13 +47,13 @@ export type TomlInfo = {
         codeTemplate: string;
         issuer: string;
         status: string;
-        displayDecimals: string;
+        displayDecimals: number;
         name: string;
         desc: string;
         conditions: string;
         image: string;
-        fixedNumber: string;
-        maxNumber: string;
+        fixedNumber: number;
+        maxNumber: number;
         isUnlimited: boolean;
         isAssetAnchored: boolean;
         anchorAssetType: string;
@@ -63,7 +63,7 @@ export type TomlInfo = {
         collateralAddresses: Array<string>;
         collateralAddressMessages: Array<string>;
         collateralAddressSignatures: Array<string>;
-        regulated: string;
+        regulated: boolean;
         approvalServer: string;
         approvalCriteria: string;
     }>;
@@ -75,4 +75,3 @@ export type TomlInfo = {
         history: string;
     }>;
 };
-export declare const parseToml: (toml: any) => TomlInfo;

package/lib/walletSdk/Types/watcher.d.ts

@@ -0,0 +1,30 @@
+import { AnchorTransaction } from "./anchor";
+export type WatchTransactionsParams = {
+    authToken: string;
+    assetCode: string;
+    onMessage: (transaction: AnchorTransaction) => void;
+    onError: (error: AnchorTransaction | Error) => void;
+    watchlist?: string[];
+    timeout?: number;
+    isRetry?: boolean;
+    lang?: string;
+    kind?: string;
+    noOlderThan?: string;
+};
+export type WatchTransactionParams = {
+    authToken: string;
+    assetCode: string;
+    id: string;
+    onMessage: (transaction: AnchorTransaction) => void;
+    onSuccess: (transaction: AnchorTransaction) => void;
+    onError: (error: AnchorTransaction | Error) => void;
+    timeout?: number;
+    isRetry?: boolean;
+    lang?: string;
+};
+export type WatcherRefreshFunction = () => void;
+export type WatcherStopFunction = () => void;
+export interface WatcherResponse {
+    refresh: WatcherRefreshFunction;
+    stop: WatcherStopFunction;
+}

package/lib/walletSdk/{util → Utils}/camelToSnakeCase.d.ts

@@ -1,2 +1,2 @@
 export declare const camelToSnakeCaseKey: (key: string) => string;
-export declare const camelToSnakeCaseObject: (obj: any) => {};
+export declare const camelToSnakeCaseObject: (obj: any) => any;