Account Creation

import { persisted } from "svelte-local-storage-store";
import {
  KeyManager,
  LocalStorageKeyStore,
  ScryptEncrypter,
  KeyType,
} from "@stellar/typescript-wallet-sdk-km";
import { TransactionBuilder } from "@stellar/stellar-sdk";
import { error } from "@sveltejs/kit";
import { get } from "svelte/store";

// We are wrapping this store in its own function which will allow us to write
// and customize our own store functions to maintain consistent behavior
// wherever the actions need to take place.
function createWalletStore() {
  // Make a `persisted` store that will determine which `keyId` the
  // `keyManager` should load, when the time comes.
  const { subscribe, set } = persisted("bpa:walletStore", {
    keyId: "",
    publicKey: "",
  });

  return {
    subscribe,

    // Registers a user by storing their encrypted keypair in the browser's
    // `localStorage`.
    register: async ({ publicKey, secretKey, pincode }) => {
      try {
        // Get our `KeyManager` to interact with stored keypairs
        const keyManager = setupKeyManager();

        // Use the `keyManager` to store the key in the browser's local
        // storage
        let keyMetadata = await keyManager.storeKey({
          key: {
            type: KeyType.plaintextKey,
            publicKey: publicKey,
            privateKey: secretKey,
          },
          password: pincode,
          encrypterName: ScryptEncrypter.name,
        });

        // Set the `walletStore` fields for the `keyId` and `publicKey`
        set({
          keyId: keyMetadata.id,
          publicKey: publicKey,
          // Don't include this in a real-life production application.
          // It's just here to make the secret key accessible in case
          // we need to do some manual transactions or something.
          devInfo: {
            secretKey: secretKey,
          },
        });
      } catch (err) {
        console.error("Error saving key", err);
        throw error(400, { message: err.toString() });
      }
    },

    // Compares a submitted pincode to make sure it is valid for the stored, encrypted keypair.
    confirmPincode: async ({ pincode, firstPincode = "", signup = false }) => {
      // If we are not signing up, make sure the submitted pincode successfully
      // decrypts and loads the stored keypair.
      if (!signup) {
        try {
          const keyManager = setupKeyManager();
          let { keyId } = get(walletStore);
          await keyManager.loadKey(keyId, pincode);
        } catch (err) {
          throw error(400, { message: "invalid pincode" });
        }
        // If we are signing up for the first time (thus, there is no stored
        // keypair), just make sure the first and second pincodes match.
      } else {
        if (pincode !== firstPincode) {
          throw error(400, { message: "pincode mismatch" });
        }
      }
    },

    // Sign and return a Stellar transaction
    sign: async ({ transactionXDR, network, pincode }) => {
      try {
        // Get our `keyManager` to interact with stored keypairs
        const keyManager = setupKeyManager();

        // Use the `keyManager` to sign the transaction with the
        // encrypted keypair
        let signedTransaction = await keyManager.signTransaction({
          transaction: TransactionBuilder.fromXDR(transactionXDR, network),
          id: get(walletStore).keyId,
          password: pincode,
        });
        return signedTransaction;
      } catch (err) {
        console.error("Error signing transaction", err);
        throw error(400, { message: err.toString() });
      }
    },
  };
}

// We export `walletStore` as the variable that can be used to interact with the wallet store.
export const walletStore = createWalletStore();

// Configure a `KeyManager` for use with stored keypairs.
const setupKeyManager = () => {
  // We make a new `KeyStore`
  const localKeyStore = new LocalStorageKeyStore();

  // Configure it to use `localStorage` and specify a(n optional) prefix
  localKeyStore.configure({
    prefix: "bpa",
    storage: localStorage,
  });

  // Make a new `KeyManager`, that uses the previously configured `KeyStore`
  const keyManager = new KeyManager({
    keyStore: localKeyStore,
  });

  // Configure the `KeyManager` to use the `scrypt` encrypter
  keyManager.registerEncrypter(ScryptEncrypter);

  // Return the `KeyManager` for use in other functions
  return keyManager;
};

// Fund an account using the Friendbot utility on the Testnet.
export async function fundWithFriendbot(publicKey) {
  console.log(`i am requesting a friendbot funding for ${publicKey}`);
  await server.friendbot(publicKey).call();
}