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

package/src/walletSdk/index.ts

@@ -1,12 +1,19 @@
-import StellarSdk, { Networks, Server } from "stellar-sdk";
 import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+import { Networks, Server } from "stellar-sdk";
 
 import { Anchor } from "./Anchor";
-import { WalletSigner, DefaultSigner } from "./Auth/WalletSigner";
-import { Stellar } from "./horizon/Stellar";
-import { NETWORK_URLS } from "./horizon/constants";
-import { Recovery } from "./recovery/Recovery";
-import { getUrlDomain } from "./util/url";
+import { DefaultSigner, WalletSigner } from "./Auth";
+import { Stellar } from "./Horizon";
+import { Recovery } from "./Recovery";
+import {
+  ConfigParams,
+  StellarConfigurationParams,
+  WalletAnchor,
+  WalletParams,
+  WalletRecovery,
+  NETWORK_URLS,
+} from "./Types";
+import { getUrlDomain } from "./Utils";
 
 /* tslint:disable-next-line:no-var-requires */
 const version = require("../../package.json").version;
@@ -15,49 +22,40 @@ const walletHeaders = {
   "X-Client-Version": version,
 };
 
-export class Config {
-  app: ApplicationConfiguration;
-  stellar: StellarConfiguration;
-  constructor(stellarCfg, appCfg) {
-    this.stellar = stellarCfg;
-    this.app = appCfg;
-  }
-}
-
 export class Wallet {
   private cfg: Config;
   private language: string;
 
   static TestNet = (): Wallet => {
-    return new Wallet(StellarConfiguration.TestNet());
+    return new Wallet({
+      stellarConfiguration: StellarConfiguration.TestNet(),
+    });
   };
 
   static MainNet = (): Wallet => {
-    return new Wallet(StellarConfiguration.MainNet());
+    return new Wallet({
+      stellarConfiguration: StellarConfiguration.MainNet(),
+    });
   };
 
-  constructor(
-    stellarConfiguration: StellarConfiguration,
-    applicationConfiguration: ApplicationConfiguration = new ApplicationConfiguration(),
+  constructor({
+    stellarConfiguration,
+    applicationConfiguration = new ApplicationConfiguration(),
     // Defaults wallet language to "en", this will reflect in all Anchor API calls
-    language: string = "en"
-  ) {
-    this.cfg = new Config(stellarConfiguration, applicationConfiguration);
+    language = "en",
+  }: WalletParams) {
+    this.cfg = new Config({ stellarConfiguration, applicationConfiguration });
     this.language = language;
   }
 
-  anchor(
-    homeDomain: string,
-    httpClientConfig: AxiosRequestConfig = {},
-    language: string = this.language
-  ) {
+  anchor({ homeDomain, language = this.language }: WalletAnchor): Anchor {
     const url =
       homeDomain.indexOf("://") !== -1 ? homeDomain : `https://${homeDomain}`;
 
     return new Anchor({
       cfg: this.cfg,
       homeDomain: getUrlDomain(url),
-      httpClient: this.getClient(httpClientConfig),
+      httpClient: this.cfg.app.defaultClient,
       language,
     });
   }
@@ -66,23 +64,26 @@ export class Wallet {
     return new Stellar(this.cfg);
   }
 
-  recover(servers, httpClientConfig: AxiosRequestConfig = {}) {
-    return new Recovery(
-      this.cfg,
-      this.stellar(),
-      this.getClient(httpClientConfig),
-      servers
-    );
+  recovery({ servers }: WalletRecovery): Recovery {
+    return new Recovery({
+      cfg: this.cfg,
+      stellar: this.stellar(),
+      httpClient: this.cfg.app.defaultClient,
+      servers,
+    });
   }
+}
 
-  getClient(httpClientConfig: AxiosRequestConfig = {}) {
-    return axios.create({
-      headers: {
-        ...walletHeaders,
-        ...httpClientConfig.headers,
-      },
-      ...httpClientConfig,
-    });
+export class Config {
+  stellar: StellarConfiguration;
+  app: ApplicationConfiguration;
+
+  constructor({
+    stellarConfiguration,
+    applicationConfiguration,
+  }: ConfigParams) {
+    this.stellar = stellarConfiguration;
+    this.app = applicationConfiguration;
   }
 }
 
@@ -91,32 +92,48 @@ export class StellarConfiguration {
   network: Networks;
   horizonUrl: string;
   baseFee: number;
+  defaultTimeout: number;
 
   static TestNet = (): StellarConfiguration => {
-    return new StellarConfiguration(Networks.TESTNET, NETWORK_URLS.TESTNET);
+    return new StellarConfiguration({
+      network: Networks.TESTNET,
+      horizonUrl: NETWORK_URLS.TESTNET,
+    });
   };
 
   static MainNet = (): StellarConfiguration => {
-    return new StellarConfiguration(Networks.PUBLIC, NETWORK_URLS.PUBLIC);
+    return new StellarConfiguration({
+      network: Networks.PUBLIC,
+      horizonUrl: NETWORK_URLS.PUBLIC,
+    });
   };
 
-  constructor(network, horizonUrl, baseFee = 100) {
+  constructor({
+    network,
+    horizonUrl,
+    baseFee = 100,
+    defaultTimeout = 180,
+  }: StellarConfigurationParams) {
     this.network = network;
-    this.baseFee = baseFee;
     this.horizonUrl = horizonUrl;
+    this.baseFee = baseFee;
+    this.defaultTimeout = defaultTimeout;
     this.server = new Server(horizonUrl);
   }
 }
 
+export const DefaultClient = axios.create({
+  headers: {
+    ...walletHeaders,
+  },
+});
+
 export class ApplicationConfiguration {
   defaultSigner: WalletSigner;
   defaultClient: AxiosInstance;
-  constructor(defaultSigner: WalletSigner = DefaultSigner) {
-    this.defaultSigner = defaultSigner;
-    this.defaultClient = axios.create({
-      headers: {
-        ...walletHeaders,
-      },
-    });
+
+  constructor(defaultSigner?: WalletSigner, defaultClient?: AxiosInstance) {
+    this.defaultSigner = defaultSigner || DefaultSigner;
+    this.defaultClient = defaultClient || DefaultClient;
   }
 }

package/test/account.test.ts

@@ -1,35 +1,39 @@
-import StellarSdk, {
-  Keypair,
-  TransactionBuilder,
-  Transaction,
-  FeeBumpTransaction,
-  Networks,
-} from "stellar-sdk";
-import { PublicKeypair } from "../src/walletSdk/horizon/Account";
+import crypto from "crypto";
+import { TransactionBuilder, Networks } from "stellar-sdk";
 
-import sdk from "../src";
-const { walletSdk } = sdk;
+import { Wallet } from "../src";
+import { PublicKeypair } from "../src/walletSdk/Horizon/Account";
 
+let wal;
+let account;
 describe("Account", () => {
-  it("should init keypair and sign", () => {
-    const wal = walletSdk.Wallet.TestNet();
-    const account = wal.stellar().account();
+  beforeEach(() => {
+    wal = Wallet.TestNet();
+    account = wal.stellar().account();
+  });
+  it("should create keypair and sign", () => {
     const kp = account.createKeypair();
     expect(kp.publicKey).toBeTruthy();
     expect(kp.secretKey).toBeTruthy();
 
     const tx = TransactionBuilder.fromXDR(
       "AAAAAgAAAADk/TqnRl6sFK79yasH46qlX/dFxQ8R023aHRxAkUmE8wAAAGQAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAADk/TqnRl6sFK79yasH46qlX/dFxQ8R023aHRxAkUmE8wAAAAAAAAAABfXhAAAAAAAAAAAA",
-      Networks.TESTNET
+      Networks.TESTNET,
     );
     kp.sign(tx);
     expect(tx.signatures.length).toBe(1);
     tx.sign(kp.keypair);
     expect(tx.signatures.length).toBe(2);
   });
+  it("should create keypair from random", () => {
+    const rand = crypto.randomBytes(32);
+    const kp = account.createKeypairFromRandom(rand);
+    expect(kp.publicKey).toBeTruthy();
+    expect(kp.secretKey).toBeTruthy();
+  });
   it("can init from string", () => {
     const kp = PublicKeypair.fromPublicKey(
-      "GCPECGTX5RZWBJNH7Q3FNN4742R7OKMSP6G4ECCUX7Q5IGDCYYG2I447"
+      "GCPECGTX5RZWBJNH7Q3FNN4742R7OKMSP6G4ECCUX7Q5IGDCYYG2I447",
     );
     expect(kp.publicKey).toBeTruthy();
   });

package/test/accountService.test.ts

@@ -0,0 +1,109 @@
+import axios from "axios";
+import { Horizon } from "stellar-sdk";
+
+import { AccountService, SigningKeypair, Wallet } from "../src";
+import { HORIZON_ORDER } from "../src/walletSdk/Types";
+import { IssuedAssetId } from "../src/walletSdk/Asset";
+
+let accountService: AccountService;
+let accountAddress: string;
+
+describe("Horizon", () => {
+  // Creates testing stellar account with USDC trustline
+  // in case it doesn't exist just yet
+  beforeAll(async () => {
+    const wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+    accountService = stellar.account();
+
+    const fundingAccountKp = SigningKeypair.fromSecret(
+      "SDJTZXPFPWRK4GHECLQBDFRDCNEZFA4PIZA475WQEGKTL4Y2QLS77DGD",
+    );
+
+    // make sure funding account exists
+    try {
+      await stellar.server.loadAccount(fundingAccountKp.publicKey);
+    } catch (e) {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + fundingAccountKp.publicKey,
+      );
+    }
+
+    const testingAccountKp = SigningKeypair.fromSecret(
+      "SAXW2HC7JH5IJSIRFQ22JTMT6T3VONKGMYSIBLHNEJCV7AXLIGAXNESD",
+    );
+
+    // make sure testing account exists
+    accountAddress = testingAccountKp.publicKey;
+    try {
+      await stellar.server.loadAccount(accountAddress);
+    } catch (e) {
+      const txBuilder1 = await stellar.transaction({
+        sourceAddress: fundingAccountKp,
+        baseFee: 100,
+      });
+      const createAccTx = txBuilder1.createAccount(testingAccountKp, 2).build();
+      createAccTx.sign(fundingAccountKp.keypair);
+
+      let failed = false;
+      try {
+        await stellar.submitTransaction(createAccTx);
+        await stellar.server.loadAccount(accountAddress);
+      } catch (e) {
+        failed = true;
+      }
+
+      const txBuilder2 = await stellar.transaction({
+        sourceAddress: testingAccountKp,
+        baseFee: 100,
+      });
+      const asset = new IssuedAssetId(
+        "USDC",
+        "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+      );
+      const addUsdcTx = txBuilder2.addAssetSupport(asset).build();
+      addUsdcTx.sign(testingAccountKp.keypair);
+
+      // make sure testing account has USDC trustline
+      try {
+        await stellar.submitTransaction(addUsdcTx);
+      } catch (e) {
+        failed = true;
+      }
+
+      expect(failed).toBeFalsy();
+    }
+  }, 30000);
+
+  it("should return stellar account details", async () => {
+    const response = await accountService.getInfo({ accountAddress });
+
+    expect(response.account_id).toBe(accountAddress);
+    expect(response.balances).toBeInstanceOf(Array);
+    expect(
+      response.balances.some(
+        (balance) =>
+          (balance as Horizon.BalanceLineAsset).asset_code === "USDC",
+      ),
+    ).toBeTruthy();
+  });
+
+  it("should return stellar account operations", async () => {
+    const response = await accountService.getHistory({
+      accountAddress,
+      order: HORIZON_ORDER.ASC,
+    });
+
+    expect(response.records).toBeInstanceOf(Array);
+    expect(response.records[0]).toBeInstanceOf(Object);
+    expect(response.records[0]).toHaveProperty("id");
+    expect(response.records[0]).toHaveProperty("type");
+    expect(response.records[0]).toHaveProperty("created_at");
+    expect(
+      response.records.some(({ type }) => type === "create_account"),
+    ).toBeTruthy();
+    expect(
+      response.records.some(({ type }) => type === "change_trust"),
+    ).toBeTruthy();
+  });
+});