@stellar/typescript-wallet-sdk 1.0.0-alpha.2 → 1.0.0

package/lib/index.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Types
+ */
+import * as Types from "./walletSdk/Types";
+export { Types };
+/**
+ * Classes
+ */
+export { Wallet, Config, StellarConfiguration, ApplicationConfiguration, } from "./walletSdk";
+export { Anchor } from "./walletSdk/Anchor";
+export { Sep10, WalletSigner, DefaultSigner } from "./walletSdk/Auth";
+export { PublicKeypair, SigningKeypair, AccountService, Stellar, } from "./walletSdk/Horizon";
+export { Sep24 } from "./walletSdk/Anchor/Sep24";
+export { Recovery } from "./walletSdk/Recovery";
+export { Watcher } from "./walletSdk/Watcher";
+/**
+ * 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 };

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

@@ -0,0 +1,41 @@
+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);
+}

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

@@ -0,0 +1,148 @@
+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
+     * not yet entered necessary info in an interactive flow
+     */
+    incomplete = "incomplete",
+    /**
+     * The user has not yet initiated their transfer to the anchor. This is the next necessary step in
+     * any deposit or withdrawal flow after transitioning from `incomplete`
+     */
+    pending_user_transfer_start = "pending_user_transfer_start",
+    /**
+     * The Stellar payment has been successfully received by the anchor and the off-chain funds are
+     * available for the customer to pick up. Only used for withdrawal transactions.
+     */
+    pending_user_transfer_complete = "pending_user_transfer_complete",
+    /**
+     * Pending External deposit/withdrawal has been submitted to external network, but is not yet
+     * confirmed. This is the status when waiting on Bitcoin or other external crypto network to
+     * complete a transaction, or when waiting on a bank transfer.
+     */
+    pending_external = "pending_external",
+    /**
+     * Deposit/withdrawal is being processed internally by anchor. This can also be used when the
+     * anchor must verify KYC information prior to deposit/withdrawal.
+     */
+    pending_anchor = "pending_anchor",
+    /**
+     * Deposit/withdrawal operation has been submitted to Stellar network, but is not yet confirmed.
+     */
+    pending_stellar = "pending_stellar",
+    /** The user must add a trustline for the asset for the deposit to complete. */
+    pending_trust = "pending_trust",
+    /**
+     * The user must take additional action before the deposit / withdrawal can complete, for example
+     * an email or 2fa confirmation of a withdrawal.
+     */
+    pending_user = "pending_user",
+    /** Deposit/withdrawal fully completed */
+    completed = "completed",
+    /** The deposit/withdrawal is fully refunded */
+    refunded = "refunded",
+    /**
+     * Funds were never received by the anchor and the transaction is considered abandoned by the
+     * user. Anchors are responsible for determining when transactions are considered expired.
+     */
+    expired = "expired",
+    /**
+     * Could not complete deposit because no satisfactory asset/XLM market was available to create the
+     * account
+     */
+    no_market = "no_market",
+    /** Deposit/withdrawal size less than min_amount. */
+    too_small = "too_small",
+    /** Deposit/withdrawal size exceeded max_amount. */
+    too_large = "too_large",
+    /** Catch-all for any error not enumerated above. */
+    error = "error"
+}

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,12 @@
+import { Memo, Server } from "stellar-sdk";
+import { AccountKeypair } from "../Horizon/Account";
+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;
+};

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/Types/utils.d.ts

@@ -0,0 +1,77 @@
+export type TomlInfo = {
+    version: string;
+    networkPassphrase: string;
+    federationServer: string;
+    authServer: string;
+    transferServer: string;
+    transferServerSep24: string;
+    kycServer: string;
+    webAuthEndpoint: string;
+    signingKey: string;
+    horizonUrl: string;
+    accounts: Array<string>;
+    uriRequestSigningKey: string;
+    directPaymentServer: string;
+    anchorQuoteServer: string;
+    documentation: {
+        orgName: string;
+        orgDba: string;
+        orgUrl: string;
+        orgLogo: string;
+        orgDescription: string;
+        orgPhysicalAddress: string;
+        orgPhysicalAddressAttestation: string;
+        orgPhoneNumber: string;
+        orgPhoneNumberAttestation: string;
+        orgKeybase: string;
+        orgTwitter: string;
+        orgGithub: string;
+        orgOfficialEmail: string;
+        orgSupportEmail: string;
+        orgLicensingAuthority: string;
+        orgLicenseType: string;
+        orgLicenseNumber: string;
+    };
+    principals: Array<{
+        name: string;
+        email: string;
+        keybase: string;
+        telegram: string;
+        twitter: string;
+        github: string;
+        idPhotoHash: string;
+        verificationPhotoHash: string;
+    }>;
+    currencies: Array<{
+        code: string;
+        codeTemplate: string;
+        issuer: string;
+        status: string;
+        displayDecimals: number;
+        name: string;
+        desc: string;
+        conditions: string;
+        image: string;
+        fixedNumber: number;
+        maxNumber: number;
+        isUnlimited: boolean;
+        isAssetAnchored: boolean;
+        anchorAssetType: string;
+        anchorAsset: string;
+        attestationOfReserve: string;
+        redemptionInstructions: string;
+        collateralAddresses: Array<string>;
+        collateralAddressMessages: Array<string>;
+        collateralAddressSignatures: Array<string>;
+        regulated: boolean;
+        approvalServer: string;
+        approvalCriteria: string;
+    }>;
+    validators: Array<{
+        alias: string;
+        displayName: string;
+        publicKey: string;
+        host: string;
+        history: string;
+    }>;
+};

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/Utils/camelToSnakeCase.d.ts

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

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

@@ -0,0 +1,3 @@
+export * from "./camelToSnakeCase";
+export * from "./toml";
+export * from "./url";

package/lib/walletSdk/Utils/toml.d.ts

@@ -0,0 +1,3 @@
+import { StellarTomlResolver } from "stellar-sdk";
+import { TomlInfo } from "../Types";
+export declare const parseToml: (toml: StellarTomlResolver.StellarToml) => TomlInfo;

package/lib/walletSdk/Utils/url.d.ts

@@ -0,0 +1 @@
+export declare const getUrlDomain: (url: string) => any;

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

@@ -0,0 +1,65 @@
+export declare enum TransactionStatus {
+    /**
+     * There is not yet enough information for this transaction to be initiated. Perhaps the user has
+     * not yet entered necessary info in an interactive flow
+     */
+    incomplete = "incomplete",
+    /**
+     * The user has not yet initiated their transfer to the anchor. This is the next necessary step in
+     * any deposit or withdrawal flow after transitioning from `incomplete`
+     */
+    pending_user_transfer_start = "pending_user_transfer_start",
+    /**
+     * The Stellar payment has been successfully received by the anchor and the off-chain funds are
+     * available for the customer to pick up. Only used for withdrawal transactions.
+     */
+    pending_user_transfer_complete = "pending_user_transfer_complete",
+    /**
+     * Pending External deposit/withdrawal has been submitted to external network, but is not yet
+     * confirmed. This is the status when waiting on Bitcoin or other external crypto network to
+     * complete a transaction, or when waiting on a bank transfer.
+     */
+    pending_external = "pending_external",
+    /**
+     * Deposit/withdrawal is being processed internally by anchor. This can also be used when the
+     * anchor must verify KYC information prior to deposit/withdrawal.
+     */
+    pending_anchor = "pending_anchor",
+    /**
+     * Deposit/withdrawal operation has been submitted to Stellar network, but is not yet confirmed.
+     */
+    pending_stellar = "pending_stellar",
+    /** The user must add a trustline for the asset for the deposit to complete. */
+    pending_trust = "pending_trust",
+    /**
+     * The user must take additional action before the deposit / withdrawal can complete, for example
+     * an email or 2fa confirmation of a withdrawal.
+     */
+    pending_user = "pending_user",
+    /** Deposit/withdrawal fully completed */
+    completed = "completed",
+    /** The deposit/withdrawal is fully refunded */
+    refunded = "refunded",
+    /**
+     * Funds were never received by the anchor and the transaction is considered abandoned by the
+     * user. Anchors are responsible for determining when transactions are considered expired.
+     */
+    expired = "expired",
+    /**
+     * Could not complete deposit because no satisfactory asset/XLM market was available to create the
+     * account
+     */
+    no_market = "no_market",
+    /** Deposit/withdrawal size less than min_amount. */
+    too_small = "too_small",
+    /** Deposit/withdrawal size exceeded max_amount. */
+    too_large = "too_large",
+    /** 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/Watcher/index.d.ts

@@ -0,0 +1,33 @@
+import { Anchor } from "../Anchor";
+import { WatchTransactionParams, WatchTransactionsParams, WatcherResponse } from "../Types";
+export declare class Watcher {
+    private anchor;
+    private _oneTransactionWatcher;
+    private _allTransactionsWatcher?;
+    private _watchOneTransactionRegistry;
+    private _watchAllTransactionsRegistry;
+    private _transactionsRegistry;
+    private _transactionsIgnoredRegistry;
+    constructor(anchor: Anchor);
+    /**
+     * Watch all transactions returned from a transfer server. When new or
+     * updated transactions come in, run an `onMessage` callback.
+     *
+     * On initial load, it'll return ALL pending transactions via onMessage.
+     * Subsequent messages will be any one of these events:
+     *  - Any new transaction appears
+     *  - Any of the initial pending transactions change any state
+     *
+     * You may also provide an array of transaction ids, `watchlist`, and this
+     * watcher will always react to transactions whose ids are in the watchlist.
+     */
+    watchAllTransactions({ authToken, assetCode, onMessage, onError, watchlist, timeout, isRetry, lang, kind, noOlderThan, }: WatchTransactionsParams): WatcherResponse;
+    /**
+     * Watch a transaction until it stops pending. Takes three callbacks:
+     * * onMessage - When the transaction comes back as pending_ or incomplete.
+     * * onSuccess - When the transaction comes back as completed / refunded / expired.
+     * * onError - When there's a runtime error, or the transaction comes back as
+     * no_market / too_small / too_large / error.
+     */
+    watchOneTransaction({ authToken, assetCode, id, onMessage, onSuccess, onError, timeout, isRetry, lang, }: WatchTransactionParams): WatcherResponse;
+}

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

@@ -1,16 +1,24 @@
-import { Auth } from "../Auth";
-import { Interactive } from "../interactive";
-import { TomlInfo } from "../toml";
+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 cfg;
-    constructor(cfg: any, homeDomain: string, httpClient: any);
-    getInfo(): Promise<TomlInfo>;
-    auth(): Promise<Auth>;
-    interactive(): Interactive;
-    getServicesInfo(): Promise<any>;
-    getTransaction(): void;
-    getTransactionForAsset(): void;
-    getHistory(): void;
+    private toml;
+    constructor(params: AnchorParams);
+    sep1(shouldRefresh?: boolean): Promise<TomlInfo>;
+    sep10(): Promise<Sep10>;
+    sep24(): Sep24;
+    getServicesInfo(lang?: string): Promise<AnchorServiceInfo>;
 }
+export {};

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

@@ -1,3 +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;