@stellar/typescript-wallet-sdk 1.2.1 → 1.3.1

package/src/walletSdk/index.ts

@@ -1,5 +1,5 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
-import { Networks, Server } from "stellar-sdk";
+import axios, { AxiosInstance } from "axios";
+import { Networks, Horizon } from "@stellar/stellar-sdk";
 
 import { Anchor } from "./Anchor";
 import { DefaultSigner, WalletSigner } from "./Auth";
@@ -10,34 +10,54 @@ import {
   StellarConfigurationParams,
   WalletAnchor,
   WalletParams,
-  WalletRecovery,
+  WalletRecoveryServers,
   NETWORK_URLS,
 } from "./Types";
 import { getUrlDomain } from "./Utils";
 
-/* tslint:disable-next-line:no-var-requires */
+/* eslint-disable-next-line @typescript-eslint/no-var-requires */
 const version = require("../../package.json").version;
 const walletHeaders = {
   "X-Client-Name": "typescript-wallet-sdk",
   "X-Client-Version": version,
 };
 
+/**
+ * The Wallet SDK main entry point class. From these class methods you can create a
+ * wallet on the Stellar network.
+ * @class
+ */
 export class Wallet {
   private cfg: Config;
   private language: string;
 
+  /**
+   * Creates a Wallet instance configured to the test network.
+   * @returns {Wallet} A Wallet instance configured to the test network.
+   */
   static TestNet = (): Wallet => {
     return new Wallet({
       stellarConfiguration: StellarConfiguration.TestNet(),
     });
   };
 
+  /**
+   * Creates a Wallet instance configured to the public network.
+   * @returns {Wallet} A Wallet instance configured to the public network.
+   */
   static MainNet = (): Wallet => {
     return new Wallet({
       stellarConfiguration: StellarConfiguration.MainNet(),
     });
   };
 
+  /**
+   * Creates a new Wallet instance.
+   * @param {WalletParams} params - The Wallet params.
+   * @param {StellarConfiguration} params.stellarConfiguration - The Stellar configuration.
+   * @param {ApplicationConfiguration} params.applicationConfiguration - The Application configuration.
+   * @param {string} [params.language] - The default langauge to use.
+   */
   constructor({
     stellarConfiguration,
     applicationConfiguration = new ApplicationConfiguration(),
@@ -48,6 +68,14 @@ export class Wallet {
     this.language = language;
   }
 
+  /**
+   * Create an Anchor instance for interacting with an Anchor.
+   * @param {WalletAnchor} params - The anchor params.
+   * @param {string} params.homeDomain - The home domain of the anchor. This domain will be used for
+   * things like getting the toml info.
+   * @param {string} [params.language=this.language] - The language setting for the Anchor.
+   * @returns {Anchor} An Anchor instance.
+   */
   anchor({ homeDomain, language = this.language }: WalletAnchor): Anchor {
     const url =
       homeDomain.indexOf("://") !== -1 ? homeDomain : `https://${homeDomain}`;
@@ -60,11 +88,20 @@ export class Wallet {
     });
   }
 
-  stellar() {
+  /**
+   * Create a Stellar instance for interacting with the Stellar network.
+   * @returns {Stellar} A Stellar instance.
+   */
+  stellar(): Stellar {
     return new Stellar(this.cfg);
   }
 
-  recovery({ servers }: WalletRecovery): Recovery {
+  /**
+   * Create a Recovery instance for account recovery using SEP-30.
+   * @param {WalletRecoveryServers} servers - A map of recovery servers.
+   * @returns {Recovery} A Recovery instance.
+   */
+  recovery({ servers }: WalletRecoveryServers): Recovery {
     return new Recovery({
       cfg: this.cfg,
       stellar: this.stellar(),
@@ -88,7 +125,7 @@ export class Config {
 }
 
 export class StellarConfiguration {
-  server: Server;
+  server: Horizon.Server;
   network: Networks;
   horizonUrl: string;
   baseFee: number;
@@ -118,7 +155,7 @@ export class StellarConfiguration {
     this.horizonUrl = horizonUrl;
     this.baseFee = baseFee;
     this.defaultTimeout = defaultTimeout;
-    this.server = new Server(horizonUrl);
+    this.server = new Horizon.Server(horizonUrl);
   }
 }
 

package/test/README.md

@@ -0,0 +1,18 @@
+# Recovery Integration Tests
+
+## How it works
+
+The recovery integration tests run different recovery scenarios against recovery
+signer and webauth servers. 2 recovery signer and 2 webauth servers are started
+in a docker-compose file (see test/docker/docker-compose.yml), to simulate a
+wallet interacting with 2 separate recovery servers.
+
+## To run tests locally:
+
+```
+// start servers using docker
+$ docker-compose -f test/docker/docker-compose.yml up
+
+// run tests
+$ yarn test:integration:ci
+```

package/test/account.test.ts

@@ -1,5 +1,5 @@
 import crypto from "crypto";
-import { TransactionBuilder, Networks } from "stellar-sdk";
+import { TransactionBuilder, Networks } from "@stellar/stellar-sdk";
 
 import { Wallet } from "../src";
 import { PublicKeypair } from "../src/walletSdk/Horizon/Account";

package/test/accountService.test.ts

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { Horizon } from "stellar-sdk";
+import { Horizon } from "@stellar/stellar-sdk";
 
 import { AccountService, SigningKeypair, Wallet } from "../src";
 import { HORIZON_ORDER } from "../src/walletSdk/Types";
@@ -83,11 +83,23 @@ describe("Horizon", () => {
     expect(
       response.balances.some(
         (balance) =>
-          (balance as Horizon.BalanceLineAsset).asset_code === "USDC",
+          (balance as Horizon.HorizonApi.BalanceLineAsset).asset_code ===
+          "USDC",
       ),
     ).toBeTruthy();
   });
 
+  it("should error 404 in case account not found", async () => {
+    // Any recently generated keypair won't be tied to a stellar account
+    const publicKeyWithoutAccount = accountService.createKeypair().publicKey;
+
+    try {
+      await accountService.getInfo({ accountAddress: publicKeyWithoutAccount });
+    } catch (e) {
+      expect(e?.response?.status).toBe(404);
+    }
+  });
+
   it("should return stellar account operations", async () => {
     const response = await accountService.getHistory({
       accountAddress,
@@ -100,10 +112,16 @@ describe("Horizon", () => {
     expect(response.records[0]).toHaveProperty("type");
     expect(response.records[0]).toHaveProperty("created_at");
     expect(
-      response.records.some(({ type }) => type === "create_account"),
+      response.records.some(
+        ({ type }) =>
+          type === Horizon.HorizonApi.OperationResponseType.createAccount,
+      ),
     ).toBeTruthy();
     expect(
-      response.records.some(({ type }) => type === "change_trust"),
+      response.records.some(
+        ({ type }) =>
+          type === Horizon.HorizonApi.OperationResponseType.changeTrust,
+      ),
     ).toBeTruthy();
   });
 });

package/test/customer.test.ts

@@ -0,0 +1,82 @@
+import { Wallet } from "../src";
+import axios from "axios";
+import { getRandomString } from "./utils";
+
+let wallet;
+let accountKp;
+
+describe("Customer", () => {
+  beforeAll(async () => {
+    wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+    const account = stellar.account();
+    accountKp = account.createKeypair();
+    await axios.get(
+      "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
+    );
+  }, 10000);
+
+  test("Sep-12 methods work", async () => {
+    const anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
+
+    const auth = await anchor.sep10();
+    const authToken = await auth.authenticate({ accountKp });
+
+    const sep12 = await anchor.sep12(authToken);
+    const customerType = "sep31-receiver";
+    const customerEmail = `${getRandomString(6)}@gmail.com`;
+
+    // Add
+    let resp = await sep12.add({
+      sep9Info: {
+        first_name: "john",
+        last_name: "smith",
+        email_address: customerEmail,
+        type: customerType,
+      },
+    });
+    expect(resp.data.id).toBeTruthy();
+    const { id } = resp.data;
+
+    // Get
+    resp = await sep12.getCustomer({ id, type: customerType });
+    expect(Object.keys(resp.data).sort()).toEqual(
+      ["id", "provided_fields", "fields", "status"].sort(),
+    );
+    expect(Object.keys(resp.data?.provided_fields).sort()).toEqual(
+      ["first_name", "last_name", "email_address"].sort(),
+    );
+    expect(Object.keys(resp.data?.fields).sort()).toEqual(
+      [
+        "bank_account_number",
+        "bank_number",
+        "photo_id_front",
+        "photo_id_back",
+      ].sort(),
+    );
+
+    // Update
+    resp = await sep12.update({
+      sep9Info: {
+        first_name: "j",
+        last_name: "s",
+        email_address: "1" + customerEmail,
+        bank_account_number: "12345",
+        bank_number: "54321",
+      },
+      sep9BinaryInfo: {
+        photo_id_front: Buffer.from("test-front-image"),
+        photo_id_back: Buffer.from("test-back-image"),
+      },
+      id,
+    });
+    expect(resp.data.id).toBeTruthy();
+
+    // Get again, check that the provided fields updated
+    resp = await sep12.getCustomer({ id, type: customerType });
+    expect(Object.keys(resp.data.fields).length).toBe(0);
+
+    // Delete
+    await sep12.delete();
+  }, 20000);
+});

package/test/docker/docker-compose.yml

@@ -0,0 +1,97 @@
+version: "3"
+services:
+  recovery-signer-migrate1:
+    image: stellar/recoverysigner:latest
+    depends_on:
+      postgres1:
+        condition: service_healthy
+    restart: on-failure
+    command: ["db", "migrate", "up"]
+    environment:
+      DB_URL: "postgresql://postgres:pg_password@postgres1:5432/pg_database1?sslmode=disable"
+
+  recovery-signer-migrate2:
+    image: stellar/recoverysigner:latest
+    depends_on:
+      postgres2:
+        condition: service_healthy
+    restart: on-failure
+    command: ["db", "migrate", "up"]
+    environment:
+      DB_URL: "postgresql://postgres:pg_password@postgres2:5432/pg_database2?sslmode=disable"
+
+  recovery-signer1:
+    image: stellar/recoverysigner:latest
+    ports:
+      - "8000:8000"
+    depends_on:
+      - postgres1
+    environment:
+      DB_URL: "postgresql://postgres:pg_password@postgres1:5432/pg_database1?sslmode=disable"
+      SIGNING_KEY: SAQFNCKPZ3ON5TSSEURAF4NPTZONPA37JPHQNHSLSRUNFP43MMT5LNH6
+      FIREBASE_PROJECT_ID: "none"
+      SEP10_JWKS: '{"keys":[{"kty":"EC","crv":"P-256","alg":"ES256","x":"dzqvhrMYwbmv7kcZK6L1oOATMFXG9wLFlnKfHf3E7FM","y":"Vb_wmcX-Zq2Hg2LFoXCEVWMwdJ01q41pSnxC3psunUY"}]}'
+      PORT: 8000
+
+  recovery-signer2:
+    image: stellar/recoverysigner:latest
+    ports:
+      - "8002:8002"
+    depends_on:
+      - postgres2
+    environment:
+      DB_URL: "postgresql://postgres:pg_password@postgres2:5432/pg_database2?sslmode=disable"
+      SIGNING_KEY: SA3Y2KQCPN6RAKLUISMY252QABWPQ3A65FBMZO2JJFKJ7O7VJNQ2PRYH # Use a different key for the second recovery signer
+      FIREBASE_PROJECT_ID: "none"
+      SEP10_JWKS: '{"keys":[{"kty":"EC","crv":"P-256","alg":"ES256","x":"dzqvhrMYwbmv7kcZK6L1oOATMFXG9wLFlnKfHf3E7FM","y":"Vb_wmcX-Zq2Hg2LFoXCEVWMwdJ01q41pSnxC3psunUY"}]}'
+      PORT: 8002
+
+  web-auth1:
+    image: stellar/webauth:latest
+    ports:
+      - "8001:8001"
+    environment:
+      SIGNING_KEY: SDYHSG4V2JP5H66N2CXBFCOBTAUFWXGJVPKWY6OXSIPMYW743N62QX6U
+      JWK: '{"kty":"EC","crv":"P-256","alg":"ES256","x":"dzqvhrMYwbmv7kcZK6L1oOATMFXG9wLFlnKfHf3E7FM","y":"Vb_wmcX-Zq2Hg2LFoXCEVWMwdJ01q41pSnxC3psunUY","d":"ivOMB4Wscz8ShvhwWDRyd-JJVfSMsjsz1oU3sNc-XJo"}'
+      DOMAIN: test-domain
+      AUTH_HOME_DOMAIN: test-domain
+      JWT_ISSUER: test
+      PORT: 8001
+
+  web-auth2:
+    image: stellar/webauth:latest
+    ports:
+      - "8003:8003"
+    environment:
+      SIGNING_KEY: SCAS7BUKVDL44A2BAP23RVAM6XXHB24YRCANQGDTP24HP7T6LPUFIGGU # Use a different key for the second web auth server
+      JWK: '{"kty":"EC","crv":"P-256","alg":"ES256","x":"dzqvhrMYwbmv7kcZK6L1oOATMFXG9wLFlnKfHf3E7FM","y":"Vb_wmcX-Zq2Hg2LFoXCEVWMwdJ01q41pSnxC3psunUY","d":"ivOMB4Wscz8ShvhwWDRyd-JJVfSMsjsz1oU3sNc-XJo"}'
+      DOMAIN: test-domain
+      AUTH_HOME_DOMAIN: test-domain
+      JWT_ISSUER: test
+      PORT: 8003
+
+  postgres1:
+    image: postgres:14
+    environment:
+      POSTGRES_PASSWORD: pg_password
+      POSTGRES_DB: pg_database1
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  postgres2:
+    image: postgres:14
+    environment:
+      POSTGRES_PASSWORD: pg_password
+      POSTGRES_DB: pg_database2
+    ports:
+      - "5433:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5

package/test/integration.test.ts

@@ -0,0 +1,166 @@
+import axios from "axios";
+import { Wallet } from "../src";
+
+import {
+  RecoveryServer,
+  RecoveryServerKey,
+  RecoveryServerMap,
+  RecoverableWalletConfig,
+  RecoveryRole,
+  RecoveryAccountIdentity,
+  RecoveryType,
+} from "../src/walletSdk/Types/recovery";
+
+describe("Recovery Integration Tests", () => {
+  it("should work", async () => {
+    const wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+    const accountService = stellar.account();
+
+    const server1Key: RecoveryServerKey = "server1";
+    const server1: RecoveryServer = {
+      endpoint: "http://localhost:8000",
+      authEndpoint: "http://localhost:8001",
+      homeDomain: "test-domain",
+    };
+
+    const server2Key: RecoveryServerKey = "server2";
+    const server2: RecoveryServer = {
+      endpoint: "http://localhost:8002",
+      authEndpoint: "http://localhost:8003",
+      homeDomain: "test-domain",
+    };
+
+    const servers: RecoveryServerMap = {
+      [server1Key]: server1,
+      [server2Key]: server2,
+    };
+
+    const recovery = wallet.recovery({ servers });
+
+    // Create accounts
+
+    const accountKp = accountService.createKeypair();
+    const deviceKp = accountService.createKeypair();
+    const recoveryKp = accountService.createKeypair();
+
+    try {
+      await stellar.server.loadAccount(accountKp.publicKey);
+      await stellar.server.loadAccount(deviceKp.publicKey);
+      await stellar.server.loadAccount(recoveryKp.publicKey);
+    } catch (e) {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
+      );
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + deviceKp.publicKey,
+      );
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + recoveryKp.publicKey,
+      );
+    }
+
+    // Create SEP-30 identities
+
+    const identity1: RecoveryAccountIdentity = {
+      role: RecoveryRole.OWNER,
+      authMethods: [
+        {
+          type: RecoveryType.STELLAR_ADDRESS,
+          value: recoveryKp.publicKey,
+        },
+      ],
+    };
+
+    const identity2: RecoveryAccountIdentity = {
+      role: RecoveryRole.OWNER,
+      authMethods: [
+        {
+          type: RecoveryType.STELLAR_ADDRESS,
+          value: recoveryKp.publicKey,
+        },
+        {
+          type: RecoveryType.EMAIL,
+          value: "my-email@example.com",
+        },
+      ],
+    };
+
+    // Create recoverable wallet
+
+    const config: RecoverableWalletConfig = {
+      accountAddress: accountKp,
+      deviceAddress: deviceKp,
+      accountThreshold: { low: 10, medium: 10, high: 10 },
+      accountIdentity: { [server1Key]: [identity1], [server2Key]: [identity2] },
+      signerWeight: { device: 10, recoveryServer: 5 },
+    };
+    const recoverableWallet = await recovery.createRecoverableWallet(config);
+
+    // Sign and submit
+
+    recoverableWallet.transaction.sign(accountKp.keypair);
+    await stellar.submitTransaction(recoverableWallet.transaction);
+
+    let resp = await stellar.server.loadAccount(accountKp.publicKey);
+
+    expect(resp.signers.map((obj) => obj.weight).sort((a, b) => a - b)).toEqual(
+      [0, 5, 5, 10],
+    );
+    expect(
+      resp.signers.find((obj) => obj.key === accountKp.publicKey).weight,
+    ).toBe(0);
+    expect(
+      resp.signers.find((obj) => obj.key === deviceKp.publicKey).weight,
+    ).toBe(10);
+
+    // Get Account Info
+
+    const authToken1 = await recovery
+      .sep10Auth(server1Key)
+      .authenticate({ accountKp: recoveryKp });
+
+    const authMap = { [server1Key]: authToken1 };
+
+    const accountResp = await recovery.getAccountInfo(accountKp, authMap);
+    expect(accountResp[server1Key].address).toBe(accountKp.publicKey);
+    expect(accountResp[server1Key].identities[0].role).toBe("owner");
+    expect(accountResp[server1Key].signers.length).toBe(1);
+
+    // Recover Wallet
+
+    const authToken2 = await recovery
+      .sep10Auth(server2Key)
+      .authenticate({ accountKp: recoveryKp });
+
+    const recoverySignerAddress1 = recoverableWallet.signers[0];
+    const recoverySignerAddress2 = recoverableWallet.signers[1];
+    const newKp = accountService.createKeypair();
+    const signerMap = {
+      [server1Key]: {
+        signerAddress: recoverySignerAddress1,
+        authToken: authToken1,
+      },
+      [server2Key]: {
+        signerAddress: recoverySignerAddress2,
+        authToken: authToken2,
+      },
+    };
+    const recoverTxn = await recovery.replaceDeviceKey(
+      accountKp,
+      newKp,
+      signerMap,
+    );
+
+    await stellar.submitTransaction(recoverTxn);
+
+    resp = await stellar.server.loadAccount(accountKp.publicKey);
+
+    expect(
+      resp.signers.find((obj) => obj.key === deviceKp.publicKey),
+    ).toBeFalsy();
+    expect(resp.signers.find((obj) => obj.key === newKp.publicKey).weight).toBe(
+      10,
+    );
+  }, 60000);
+});

package/test/recovery.test.ts

@@ -0,0 +1,107 @@
+import axios from "axios";
+import { xdr } from "@stellar/stellar-sdk";
+
+import { SigningKeypair, Wallet } from "../src";
+
+const testingAccountKp = SigningKeypair.fromSecret(
+  "SDZZHNNOHOLFCAQ7XZZREXTXFTEPPT3L527WB2LVYCXODEDGTT6KBUSL",
+);
+
+const accountSignerKp = SigningKeypair.fromSecret(
+  "SDZF2OUDSU32XIQYVO53X2P4F7VYP72HJP7JR3RWTT3AFZSADENNL7YZ",
+);
+
+const sponsorAccountKp = SigningKeypair.fromSecret(
+  "SCIKQPLKAARVTUX76R3PPJ5PY5KANAJ4H5TXKBAZA4L2JIQCHVGVFFGS",
+);
+
+let wallet: Wallet;
+
+describe("Recovery / Register Signers", () => {
+  beforeAll(async () => {
+    wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+
+    // make sure testing accounts exist
+    try {
+      await stellar.server.loadAccount(testingAccountKp.publicKey);
+    } catch (e) {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + testingAccountKp.publicKey,
+      );
+    }
+
+    try {
+      await stellar.server.loadAccount(sponsorAccountKp.publicKey);
+    } catch (e) {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + sponsorAccountKp.publicKey,
+      );
+    }
+  }, 60000);
+
+  it("defaults work", async () => {
+    const transaction = await wallet
+      .recovery({ servers: {} })
+      .registerRecoveryServerSigners(
+        testingAccountKp,
+        [
+          {
+            address: accountSignerKp,
+            weight: 10,
+          },
+        ],
+        {
+          low: 10,
+          medium: 10,
+          high: 10,
+        },
+      );
+
+    expect(transaction.toXDR()).toBeTruthy();
+    expect(transaction.toEnvelope()).toBeInstanceOf(xdr.TransactionEnvelope);
+  });
+
+  it("there are 3 operations in non-sponsored transaction", async () => {
+    const transaction = await wallet
+      .recovery({ servers: {} })
+      .registerRecoveryServerSigners(
+        testingAccountKp,
+        [
+          {
+            address: accountSignerKp,
+            weight: 10,
+          },
+        ],
+        {
+          low: 10,
+          medium: 10,
+          high: 10,
+        },
+      );
+
+    expect(transaction.operations.length).toBe(3);
+  });
+
+  it("there are 5 operations in sponsored transaction", async () => {
+    const transaction = await wallet
+      .recovery({ servers: {} })
+      .registerRecoveryServerSigners(
+        testingAccountKp,
+        [
+          {
+            address: accountSignerKp,
+            weight: 10,
+          },
+        ],
+        {
+          low: 10,
+          medium: 10,
+          high: 10,
+        },
+        sponsorAccountKp,
+      );
+
+    expect(transaction.operations.length).toBe(5);
+  });
+});