@stellar/typescript-wallet-sdk 1.1.0-alpha.1 → 1.1.0

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

@@ -1,18 +1,13 @@
 import { AxiosInstance } from "axios";
-import { Auth } from "../Auth";
-import { Interactive } from "../interactive";
-import { TomlInfo } from "../toml";
-import { Watcher } from "../Watcher";
 import { Config } from "walletSdk";
-import { AnchorTransaction, AnchorServiceInfo } from "./Types";
-type GetTransactionsParams = {
-    authToken: string;
-    assetCode: string;
-    noOlderThan?: string;
-    limit?: number;
-    kind?: string;
-    pagingId?: string;
-    lang?: string;
+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;
@@ -20,68 +15,10 @@ export declare class Anchor {
     private homeDomain;
     private httpClient;
     private toml;
-    constructor({ cfg, homeDomain, httpClient, language, }: {
-        cfg: Config;
-        homeDomain: string;
-        httpClient: AxiosInstance;
-        language: string;
-    });
-    getInfo(shouldRefresh?: boolean): Promise<TomlInfo>;
-    auth(): Promise<Auth>;
-    interactive(): Interactive;
-    watcher(): Watcher;
+    constructor(params: AnchorParams);
+    sep1(shouldRefresh?: boolean): Promise<TomlInfo>;
+    sep10(): Promise<Sep10>;
+    sep24(): Sep24;
     getServicesInfo(lang?: string): Promise<AnchorServiceInfo>;
-    /**
-     * 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, }: {
-        authToken: string;
-        id?: string;
-        stellarTransactionId?: string;
-        externalTransactionId?: string;
-        lang?: string;
-    }): 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(params: GetTransactionsParams): Promise<AnchorTransaction[]>;
-    /**
-     * Get all successfully finished (either completed or refunded) account transactions for specified
-     * asset. Optional field implementation depends on anchor.
-     *
-     * @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 filtered transactions that achieved a final state (completed or refunded)
-     * @throws [AssetNotSupportedError] if asset is not supported by the anchor
-     * @throws [InvalidTransactionsResponseError] if Anchor returns an invalid response
-     * @throws [ServerRequestFailedError] if server request fails
-     */
-    getHistory(params: GetTransactionsParams): Promise<AnchorTransaction[]>;
 }
 export {};

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

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

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

@@ -1,11 +1,20 @@
-import { Keypair } from "stellar-sdk";
-import { WalletSigner } from "./WalletSigner";
-export declare class Auth {
+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(cfg: any, webAuthEndpoint: any, httpClient: any);
-    authenticate(accountKp: Keypair, walletSigner?: WalletSigner, memoId?: string, clientDomain?: string): Promise<any>;
+    constructor(params: Sep10Params);
+    authenticate({ accountKp, walletSigner, memoId, clientDomain, }: AuthenticateParams): Promise<AuthToken>;
     private challenge;
     private sign;
     private getToken;

package/lib/walletSdk/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

@@ -1,8 +1,53 @@
-import { SigningKeypair } from "./Account";
+/// <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

@@ -1,7 +1,16 @@
-import { AccountService } from "./AccountService";
+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/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/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/index.d.ts

@@ -1,36 +1,38 @@
+import { AxiosInstance } from "axios";
 import { Networks, Server } from "stellar-sdk";
-import { AxiosInstance, AxiosRequestConfig } from "axios";
 import { Anchor } from "./Anchor";
-import { WalletSigner } from "./Auth/WalletSigner";
-import { Stellar } from "./horizon/Stellar";
-import { Recovery } from "./recovery/Recovery";
-export declare class Config {
-    app: ApplicationConfiguration;
-    stellar: StellarConfiguration;
-    constructor(stellarCfg: any, appCfg: any);
-}
+import { WalletSigner } from "./Auth";
+import { Stellar } from "./Horizon";
+import { Recovery } from "./Recovery";
+import { ConfigParams, StellarConfigurationParams, WalletAnchor, WalletParams, WalletRecovery } from "./Types";
 export declare class Wallet {
     private cfg;
     private language;
     static TestNet: () => Wallet;
     static MainNet: () => Wallet;
-    constructor(stellarConfiguration: StellarConfiguration, applicationConfiguration?: ApplicationConfiguration, language?: string);
-    anchor(homeDomain: string, httpClientConfig?: AxiosRequestConfig, language?: string): Anchor;
+    constructor({ stellarConfiguration, applicationConfiguration, language, }: WalletParams);
+    anchor({ homeDomain, language }: WalletAnchor): Anchor;
     stellar(): Stellar;
-    recover(servers: any, httpClientConfig?: AxiosRequestConfig): Recovery;
-    getClient(httpClientConfig?: AxiosRequestConfig): AxiosInstance;
+    recovery({ servers }: WalletRecovery): Recovery;
+}
+export declare class Config {
+    stellar: StellarConfiguration;
+    app: ApplicationConfiguration;
+    constructor({ stellarConfiguration, applicationConfiguration, }: ConfigParams);
 }
 export declare class StellarConfiguration {
     server: Server;
     network: Networks;
     horizonUrl: string;
     baseFee: number;
+    defaultTimeout: number;
     static TestNet: () => StellarConfiguration;
     static MainNet: () => StellarConfiguration;
-    constructor(network: any, horizonUrl: any, baseFee?: number);
+    constructor({ network, horizonUrl, baseFee, defaultTimeout, }: StellarConfigurationParams);
 }
+export declare const DefaultClient: AxiosInstance;
 export declare class ApplicationConfiguration {
     defaultSigner: WalletSigner;
     defaultClient: AxiosInstance;
-    constructor(defaultSigner?: WalletSigner);
+    constructor(defaultSigner?: WalletSigner, defaultClient?: AxiosInstance);
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0",
   "engines": {
     "node": ">=18"
   },
@@ -17,9 +17,14 @@
     "@types/lodash": "^4.14.194",
     "@types/sinon": "^10.0.15",
     "babel-jest": "^29.4.1",
+    "crypto-browserify": "^3.12.0",
     "eslint": "^8.33.0",
+    "husky": "^8.0.0",
     "jest": "^29.4.1",
+    "prettier": "^2.0.5",
+    "pretty-quick": "^2.0.1",
     "sinon": "^15.1.0",
+    "stream-browserify": "^3.0.0",
     "ts-jest": "^29.0.5",
     "ts-loader": "^9.4.2",
     "tslib": "^2.5.0",
@@ -30,6 +35,7 @@
   "dependencies": {
     "axios": "^1.4.0",
     "https-browserify": "^1.0.0",
+    "jws": "^4.0.0",
     "lodash": "^4.17.21",
     "query-string": "^7.1.3",
     "stellar-sdk": "^10.4.1",

package/prettier.config.js

@@ -0,0 +1 @@
+module.exports = require("@stellar/prettier-config");

package/src/index.ts

@@ -1,6 +1,46 @@
+/**
+ * Types
+ */
+import * as Types from "./walletSdk/Types";
+export { Types };
+
+/**
+ * Classes
+ */
+export {
+  Wallet,
+  Config,
+  StellarConfiguration,
+  ApplicationConfiguration,
+} from "./walletSdk";
+export { Anchor } from "./walletSdk/Anchor";
+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";
+
+/**
+ * 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";
-
 // TODO - figure out why Keypair used in parent codebase throws error
 export { walletSdk, Keypair };
 export default { walletSdk };