@stellar/typescript-wallet-sdk 1.2.0 → 1.3.0

package/test/sep38.test.ts

@@ -0,0 +1,71 @@
+import { Wallet } from "../src";
+
+let wallet;
+let anchor;
+let sep38;
+let accountKp;
+
+describe("SEP-38", () => {
+  beforeAll(() => {
+    wallet = Wallet.TestNet();
+    anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
+    sep38 = anchor.sep38();
+    accountKp = accountKp = wallet.stellar().account().createKeypair();
+  }, 10000);
+
+  it("should get Sep-38 anchor info", async () => {
+    const resp = await sep38.info();
+    expect(resp.assets[0]).toBeTruthy();
+
+    const refreshed = await sep38.info(true);
+    expect(refreshed.assets[0]).toBeTruthy();
+  });
+
+  it("should get Sep-38 prices", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+    sep38 = anchor.sep38(authToken);
+
+    const resp = await sep38.prices({
+      sellAsset: "iso4217:USD",
+      sellAmount: "5",
+      sellDeliveryMethod: "ach_debit",
+    });
+    expect(resp.buy_assets[0].asset).toBeTruthy();
+  });
+
+  it("should get Sep-38 price", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+    sep38 = anchor.sep38(authToken);
+
+    const resp = await sep38.price({
+      sellAsset: "iso4217:USD",
+      buyAsset:
+        "stellar:SRT:GCDNJUBQSX7AJWLJACMJ7I4BC3Z47BQUTMHEICZLE6MU4KQBRYG5JY6B",
+      sellAmount: "5",
+      context: "sep6",
+    });
+    expect(resp.price).toBeTruthy();
+  });
+
+  it("should request and get Sep-38 Quote", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+    sep38 = anchor.sep38(authToken);
+    const postResp = await sep38.requestQuote({
+      sell_asset: "iso4217:USD",
+      buy_asset:
+        "stellar:SRT:GCDNJUBQSX7AJWLJACMJ7I4BC3Z47BQUTMHEICZLE6MU4KQBRYG5JY6B",
+      sell_amount: "5",
+      context: "sep6",
+      sell_delivery_method: "ach_debit",
+    });
+    expect(postResp.id).toBeTruthy();
+
+    const quoteId = postResp.id;
+    const getResp = await sep38.getQuote(quoteId);
+
+    expect(getResp.id).toBeTruthy();
+  });
+});

package/test/sep6.test.ts

@@ -0,0 +1,240 @@
+import { Wallet } from "../src";
+import axios from "axios";
+
+let wallet;
+let anchor;
+let sep6;
+let accountKp;
+
+describe("SEP-6", () => {
+  beforeAll(async () => {
+    wallet = Wallet.TestNet();
+    anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
+    sep6 = anchor.sep6();
+
+    accountKp = wallet.stellar().account().createKeypair();
+    await axios.get(
+      "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
+    );
+  }, 10000);
+  it("should get anchor info", async () => {
+    const resp = await sep6.info();
+    expect(resp.deposit).toBeTruthy();
+    expect(resp.withdraw).toBeTruthy();
+
+    const refreshed = await sep6.info(true);
+    expect(refreshed.deposit).toBeTruthy();
+    expect(refreshed.withdraw).toBeTruthy();
+  });
+  it("should deposit", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const sep12 = await anchor.sep12(authToken);
+
+    // Make first call with missing KYC info
+    let resp = await sep6.deposit({
+      authToken,
+      params: {
+        asset_code: "SRT",
+        account: accountKp.publicKey,
+        type: "bank_account",
+      },
+    });
+    expect(resp.type).toBe("non_interactive_customer_info_needed");
+
+    // Add the missing KYC info
+    await sep12.add({
+      sep9Info: {
+        first_name: "john",
+        last_name: "smith",
+        email_address: "123@gmail.com",
+        bank_number: "12345",
+        bank_account_number: "12345",
+      },
+    });
+
+    // Make deposit call again with all info uploaded
+    resp = await sep6.deposit({
+      authToken,
+      params: {
+        asset_code: "SRT",
+        account: accountKp.publicKey,
+        type: "bank_account",
+      },
+    });
+    expect(resp.id).toBeTruthy();
+  });
+  it("should withdraw", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const sep12 = await anchor.sep12(authToken);
+
+    await sep12.add({
+      sep9Info: {
+        first_name: "john",
+        last_name: "smith",
+        email_address: "123@gmail.com",
+        bank_number: "12345",
+        bank_account_number: "12345",
+      },
+    });
+
+    const resp = await sep6.withdraw({
+      authToken,
+      params: {
+        asset_code: "SRT",
+        account: accountKp.publicKey,
+        type: "bank_account",
+        dest: "123",
+        dest_extra: "12345",
+      },
+    });
+    expect(resp.id).toBeTruthy();
+  });
+
+  it("deposit-exchange should work", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const sep12 = await anchor.sep12(authToken);
+    await sep12.add({
+      sep9Info: {
+        first_name: "john",
+        last_name: "smith",
+        email_address: "123@gmail.com",
+        bank_number: "12345",
+        bank_account_number: "12345",
+      },
+    });
+
+    const params = {
+      destination_asset:
+        "stellar:SRT:GCDNJUBQSX7AJWLJACMJ7I4BC3Z47BQUTMHEICZLE6MU4KQBRYG5JY6B",
+      source_asset: "iso4217:USD",
+      amount: "1",
+      account: accountKp.publicKey,
+      type: "bank_account",
+    };
+
+    const resp = await sep6.depositExchange({ authToken, params });
+    expect(resp.id).toBeTruthy();
+  });
+
+  it("withdraw-exchange should work", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const sep12 = await anchor.sep12(authToken);
+    await sep12.add({
+      sep9Info: {
+        first_name: "john",
+        last_name: "smith",
+        email_address: "123@gmail.com",
+        bank_number: "12345",
+        bank_account_number: "12345",
+      },
+    });
+
+    const params = {
+      destination_asset: "iso4217:USD",
+      source_asset:
+        "stellar:SRT:GCDNJUBQSX7AJWLJACMJ7I4BC3Z47BQUTMHEICZLE6MU4KQBRYG5JY6B",
+      amount: "1",
+      dest: accountKp.publicKey,
+      dest_extra: "1234",
+      type: "bank_account",
+    };
+
+    const resp = await sep6.withdrawExchange({ authToken, params });
+    expect(resp.id).toBeTruthy();
+  });
+
+  it("should get transactions", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    let resp = await anchor.sep6().getTransactionsForAsset({
+      authToken,
+      assetCode: "SRT",
+    });
+    expect(resp[0].id).toBeTruthy();
+
+    const id = resp[0].id;
+
+    resp = await anchor.sep6().getTransactionBy({ authToken, id });
+
+    expect(resp.id).toEqual(id);
+  });
+
+  let txId;
+
+  it("should watch all transactions", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const watcher = anchor.sep6().watcher();
+
+    let messageCount = 0;
+    let errorCount = 0;
+    const onMessage = (m) => {
+      expect(m.id).toBeTruthy();
+      messageCount += 1;
+      txId = m.id;
+    };
+    const onError = (e) => {
+      expect(e).toBeFalsy();
+      errorCount += 1;
+    };
+
+    const { stop } = watcher.watchAllTransactions({
+      authToken,
+      assetCode: "SRT",
+      onMessage,
+      onError,
+      timeout: 1,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    stop();
+    expect(messageCount > 0).toBe(true);
+    expect(errorCount).toBe(0);
+  });
+
+  it("should watch one transaction", async () => {
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const watcher = anchor.sep6().watcher();
+
+    let messageCount = 0;
+    let errorCount = 0;
+    let successCount = 0;
+    const onMessage = (m) => {
+      expect(m.id).toBeTruthy();
+      messageCount += 1;
+    };
+    const onError = (e) => {
+      expect(e).toBeFalsy();
+      errorCount += 1;
+    };
+    const onSuccess = (s) => {
+      expect(s.id).toBeTruthy();
+      successCount += 1;
+    };
+    const { stop } = watcher.watchOneTransaction({
+      authToken,
+      assetCode: "SRT",
+      id: txId,
+      onSuccess,
+      onMessage,
+      onError,
+      timeout: 1,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    stop();
+    expect(messageCount > 0).toBe(true);
+    expect(errorCount).toBe(0);
+    expect(successCount).toBe(0);
+  });
+});

package/test/stellar.test.ts

@@ -1,11 +1,4 @@
-import {
-  Keypair,
-  Memo,
-  MemoText,
-  Operation,
-  Asset,
-  Horizon,
-} from "stellar-sdk";
+import { Keypair, Memo, MemoText, Horizon } from "stellar-sdk";
 import axios from "axios";
 
 import { Stellar, Wallet } from "../src";
@@ -17,6 +10,7 @@ import {
   IssuedAssetId,
   FiatAssetId,
   NativeAssetId,
+  Assets,
 } from "../src/walletSdk/Asset";
 import { TransactionStatus, WithdrawTransaction } from "../src/walletSdk/Types";
 
@@ -34,7 +28,7 @@ describe("Stellar", () => {
     try {
       await stellar.server.loadAccount(kp.publicKey);
     } catch (e) {
-      await axios.get("https://friendbot.stellar.org/?addr=" + kp.publicKey);
+      await stellar.fundTestnetAccount(kp.publicKey);
     }
   }, 10000);
   it("should create and submit a transaction", async () => {
@@ -174,7 +168,7 @@ describe("Stellar", () => {
 
     let acc = await stellar.server.loadAccount(kp.publicKey);
     let balance = acc.balances.find(
-      (b) => (b as Horizon.BalanceLineAsset).asset_code === "USDC",
+      (b) => (b as Horizon.HorizonApi.BalanceLineAsset).asset_code === "USDC",
     );
     expect(balance).toBeTruthy();
 
@@ -184,12 +178,12 @@ describe("Stellar", () => {
 
     acc = await stellar.server.loadAccount(kp.publicKey);
     balance = acc.balances.find(
-      (b) => (b as Horizon.BalanceLineAsset).asset_code === "USDC",
+      (b) => (b as Horizon.HorizonApi.BalanceLineAsset).asset_code === "USDC",
     );
     expect(balance).toBeFalsy();
   }, 20000);
 
-  it("should import and sign a transaction from xdr", async () => {
+  it("should import and sign a transaction from xdr", () => {
     const txnXdr =
       "AAAAAgAAAACHw+LvUYx5O3Ot8A1SUChfTVk4qxFFJZ5QZ/ktaEUKPwAAAGQACEjuAAABDAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAACHw+LvUYx5O3Ot8A1SUChfTVk4qxFFJZ5QZ/ktaEUKPwAAAAAAAAAAATEtAAAAAAAAAAAA";
 
@@ -244,6 +238,11 @@ describe("Stellar", () => {
       expect(txn).toBeTruthy();
     }
   }, 20000);
+
+  it("should return recommended fee", async () => {
+    const fee = await stellar.getRecommendedFee();
+    expect(fee).toBeTruthy();
+  });
 });
 
 let txnSourceKp;
@@ -385,6 +384,17 @@ describe("Asset", () => {
     const fiat = new FiatAssetId("USD");
     expect(fiat.sep38).toBe("iso4217:USD");
   });
+  it("should use premade constants", () => {
+    let issued = Assets.Main.USDC;
+    expect(issued.sep38).toBe(
+      "stellar:USDC:GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
+    );
+
+    issued = Assets.Test.USDC;
+    expect(issued.sep38).toBe(
+      "stellar:USDC:GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+    );
+  });
 });
 
 describe("Account Modifying", () => {
@@ -462,4 +472,39 @@ describe("Account Modifying", () => {
     resp = await stellar.server.loadAccount(sourceKp.publicKey);
     expect(resp.signers[0].weight).toBe(0);
   }, 45000);
+
+  it("should merge account", async () => {
+    const wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+    const account = wallet.stellar().account();
+
+    const accountKp = account.createKeypair();
+    const sourceKp = account.createKeypair();
+    await stellar.fundTestnetAccount(accountKp.publicKey);
+    await stellar.fundTestnetAccount(sourceKp.publicKey);
+
+    const txBuilder = await stellar.transaction({
+      sourceAddress: accountKp,
+      baseFee: 1000,
+    });
+    const mergeTxn = txBuilder
+      .accountMerge(accountKp.publicKey, sourceKp.publicKey)
+      .build();
+    mergeTxn.sign(accountKp.keypair);
+    mergeTxn.sign(sourceKp.keypair);
+    await stellar.submitTransaction(mergeTxn);
+
+    let found;
+    try {
+      const accResp = await stellar.server.loadAccount(sourceKp.publicKey);
+      if (accResp) {
+        found = true;
+      }
+    } catch (e) {
+      found = false;
+    }
+    expect(found).toBeFalsy();
+    const accResp = await stellar.server.loadAccount(accountKp.publicKey);
+    expect(parseInt(accResp.balances[0].balance)).toBeGreaterThan(19998);
+  }, 30000);
 });

package/test/transaction.test.ts

@@ -19,10 +19,10 @@ describe("Muxed Transactions", () => {
     accountService = stellar.account();
 
     // Keys for accounts to issue and receive the new TSWT asset
-    var issuingKeys = SigningKeypair.fromSecret(
+    const issuingKeys = SigningKeypair.fromSecret(
       "SAJMJSEC44DWU22TJF6RWYLRPPXLY4G3L5PVGC7D2QDUCPJIFCOISNQE",
     );
-    var receivingKeys = SigningKeypair.fromSecret(
+    const receivingKeys = SigningKeypair.fromSecret(
       "SAOQQ76UQFEYN4QAAAOIO45KNZZNQKSXAUB5GXKI6YOFLEDCWPWTCDM3",
     );
 
@@ -41,7 +41,7 @@ describe("Muxed Transactions", () => {
       const tswtAssetBalance = receivingAccountInfo.balances.find(
         (balanceLine) => {
           const { asset_code, balance } =
-            balanceLine as Horizon.BalanceLineAsset;
+            balanceLine as Horizon.HorizonApi.BalanceLineAsset;
           return asset_code === testingAsset.code && Number(balance) > 1000;
         },
       );
@@ -291,9 +291,7 @@ describe("Path Payment", () => {
         sendAmount: "5",
       })
       .build();
-    sourceKp.sign(txn);
-    const success = await stellar.submitTransaction(txn);
-    expect(success).toBe(true);
+    expect(txn.operations[0].type).toBe("pathPaymentStrictSend");
   }, 15000);
 
   it("should use path payment receive", async () => {
@@ -308,16 +306,16 @@ describe("Path Payment", () => {
         destAmount: "5",
       })
       .build();
-    sourceKp.sign(txn);
-    const success = await stellar.submitTransaction(txn);
-    expect(success).toBe(true);
+    expect(txn.operations[0].type).toBe("pathPaymentStrictReceive");
   }, 15000);
 
   it("should swap", async () => {
     const txBuilder = await stellar.transaction({
       sourceAddress: sourceKp,
     });
-    const txn = txBuilder.swap(new NativeAssetId(), usdcAsset, "1").build();
+    const txn = txBuilder
+      .swap(new NativeAssetId(), new NativeAssetId(), ".1")
+      .build();
     sourceKp.sign(txn);
     const success = await stellar.submitTransaction(txn);
     expect(success).toBe(true);

package/test/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "baseUrl": "./",
+    "outDir": "lib",
+    "declaration": true,
+    "declarationDir": "lib"
+  },
+  "include": ["./"]
+}

package/test/utils/index.ts

@@ -0,0 +1,12 @@
+export const getRandomString = (length) => {
+  const charset =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let randomString = "";
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * charset.length);
+    randomString += charset[randomIndex];
+  }
+
+  return randomString;
+};

package/test/wallet.test.ts

@@ -11,7 +11,11 @@ import {
 import { DefaultClient } from "../src/walletSdk";
 import { ServerRequestFailedError } from "../src/walletSdk/Exceptions";
 import { Watcher } from "../src/walletSdk/Watcher";
-import { TransactionStatus, AnchorTransaction } from "../src/walletSdk/Types";
+import {
+  TransactionStatus,
+  AnchorTransaction,
+  AuthToken,
+} from "../src/walletSdk/Types";
 import {
   WalletSigner,
   DefaultSigner,
@@ -34,21 +38,21 @@ describe("Wallet", () => {
     Wallet.TestNet();
     Wallet.MainNet();
   });
-  it("should be able return a client", async () => {
-    let appConfig = new ApplicationConfiguration();
-    let wal = new Wallet({
+  it("should be able customize config", () => {
+    const appConfig = new ApplicationConfiguration();
+    new Wallet({
       stellarConfiguration: StellarConfiguration.TestNet(),
       applicationConfiguration: appConfig,
     });
   });
-  it("should be able to customize a client", async () => {
+  it("should be able to customize a client", () => {
     const customClient: AxiosInstance = axios.create({
       baseURL: "https://some-url.com/api",
       timeout: 1000,
       headers: { "X-Custom-Header": "foobar" },
     });
-    let appConfig = new ApplicationConfiguration(DefaultSigner, customClient);
-    let wal = new Wallet({
+    const appConfig = new ApplicationConfiguration(DefaultSigner, customClient);
+    new Wallet({
       stellarConfiguration: StellarConfiguration.TestNet(),
       applicationConfiguration: appConfig,
     });
@@ -64,7 +68,7 @@ describe("SEP-24 flow", () => {
 
 let anchor: Anchor;
 let accountKp: SigningKeypair;
-let authToken: string;
+let authToken: AuthToken;
 const makeTransaction = (eta: number, txStatus: TransactionStatus) => ({
   kind: "deposit",
   id: "TEST",
@@ -81,17 +85,26 @@ describe("Anchor", () => {
     );
   });
   it("should give TOML info", async () => {
-    const resp = await anchor.sep1();
+    let resp = await anchor.sep1();
+    expect(resp.webAuthEndpoint).toBe("https://testanchor.stellar.org/auth");
+    expect(resp.currencies.length).toBe(2);
 
+    // alias
+    resp = await anchor.getInfo();
     expect(resp.webAuthEndpoint).toBe("https://testanchor.stellar.org/auth");
     expect(resp.currencies.length).toBe(2);
   });
   it("should be able to authenticate", async () => {
-    const auth = await anchor.sep10();
+    let auth = await anchor.sep10();
+    authToken = await auth.authenticate({ accountKp });
+    expect(authToken).toBeTruthy();
+    expect(authToken.account).toBeTruthy();
 
+    // alias
+    auth = await anchor.auth();
     authToken = await auth.authenticate({ accountKp });
     expect(authToken).toBeTruthy();
-    expect(typeof authToken).toBe("string");
+    expect(authToken.account).toBeTruthy();
   });
 
   it("should be able to authenticate with client domain", async () => {
@@ -111,7 +124,9 @@ describe("Anchor", () => {
       signWithDomainAccount: async ({
         transactionXDR,
         networkPassphrase,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         accountKp,
+        // eslint-disable-next-line @typescript-eslint/require-await
       }) => {
         // dummy secret key for signing
         const clientDomainKp = Keypair.fromSecret(
@@ -138,8 +153,12 @@ describe("Anchor", () => {
     expect(signedByDomain).toBe(true);
   });
   it("should get anchor services info", async () => {
-    const serviceInfo = await anchor.sep24().getServicesInfo();
+    let serviceInfo = await anchor.sep24().getServicesInfo();
+    expect(serviceInfo.deposit).toBeTruthy();
+    expect(serviceInfo.withdraw).toBeTruthy();
 
+    // alias
+    serviceInfo = await anchor.interactive().getServicesInfo();
     expect(serviceInfo.deposit).toBeTruthy();
     expect(serviceInfo.withdraw).toBeTruthy();
   });
@@ -195,6 +214,26 @@ describe("Anchor", () => {
     expect(resp.id).toBeTruthy();
   });
 
+  it("should throw ServerRequestFailedError", async () => {
+    const assetCode = "SRT";
+    let didError = false;
+    const badAuthToken = new AuthToken();
+    try {
+      await anchor.sep24().withdraw({
+        withdrawalAccount: accountKp.publicKey,
+        assetCode,
+        authToken: badAuthToken,
+      });
+    } catch (e) {
+      didError = true;
+      expect(e.data.status).toBe(403);
+      expect(e.data.statusText).toBe("Forbidden");
+      expect(e.data.responseData.error).toBeTruthy();
+      expect(e.data.headers).toBeTruthy();
+    }
+    expect(didError).toBe(true);
+  });
+
   it("should fetch new transaction by id", async () => {
     const assetCode = "SRT";
 
@@ -213,12 +252,12 @@ describe("Anchor", () => {
     const { id, kind, status, amount_in, amount_out } = transaction;
 
     expect(transaction).toBeTruthy();
-    expect(id === transactionId).toBeTruthy;
-    expect(kind === "deposit").toBeTruthy;
-    expect(status === "incomplete").toBeTruthy;
+    expect(id === transactionId).toBeTruthy();
+    expect(kind === "deposit").toBeTruthy();
+    expect(status === TransactionStatus.incomplete).toBeTruthy();
     // we expect fresh 'incomplete' transactions to not have amounts set yet
-    expect(amount_in).toBeFalsy;
-    expect(amount_out).toBeFalsy;
+    expect(amount_in).toBeFalsy();
+    expect(amount_out).toBeFalsy();
   });
 
   it("should error fetching non-existing transaction by id", async () => {
@@ -294,7 +333,7 @@ describe("Anchor", () => {
     let clock: sinon.SinonFakeTimers;
     let watcher: Watcher;
 
-    beforeEach(async () => {
+    beforeEach(() => {
       clock = sinon.useFakeTimers(0);
       watcher = anchor.sep24().watcher();
     });
@@ -876,7 +915,7 @@ describe("Anchor", () => {
     let clock: sinon.SinonFakeTimers;
     let watcher: Watcher;
 
-    beforeEach(async () => {
+    beforeEach(() => {
       clock = sinon.useFakeTimers(0);
       watcher = anchor.sep24().watcher();
       jest.resetAllMocks();
@@ -1171,7 +1210,7 @@ describe("Anchor", () => {
     });
 
     test("Several pending transactions, one completed, no more after that", async () => {
-      const onMessage = sinon.spy((m) => {
+      const onMessage = sinon.spy(() => {
         expect(onMessage.callCount).toBeLessThanOrEqual(8);
       });
 
@@ -1444,7 +1483,7 @@ describe("Anchor", () => {
     });
 
     test("One pending, one refunded, no more after that", async () => {
-      const onMessage = sinon.spy((e) => {
+      const onMessage = sinon.spy(() => {
         expect(onMessage.callCount).toBeLessThanOrEqual(1);
       });