@meshsdk/wallet 1.6.0-alpha.11

package/src/browser/index.ts

@@ -0,0 +1,440 @@
+import {
+  Asset,
+  AssetExtended,
+  DataSignature,
+  DEFAULT_PROTOCOL_PARAMETERS,
+  fromUTF8,
+  IInitiator,
+  ISigner,
+  ISubmitter,
+  POLICY_ID_LENGTH,
+  resolveFingerprint,
+  UTxO,
+  Wallet,
+} from "@meshsdk/common";
+import {
+  Address,
+  addressToBech32,
+  CardanoSDKUtil,
+  deserializeAddress,
+  deserializeTx,
+  deserializeTxUnspentOutput,
+  deserializeValue,
+  fromTxUnspentOutput,
+  fromValue,
+  Serialization,
+  toAddress,
+  Transaction,
+  TransactionUnspentOutput,
+  VkeyWitness,
+} from "@meshsdk/core-cst";
+
+import { Cardano, WalletInstance } from "../types";
+
+declare global {
+  interface Window {
+    cardano: Cardano;
+  }
+}
+
+export class BrowserWallet implements IInitiator, ISigner, ISubmitter {
+  walletInstance: WalletInstance;
+
+  private constructor(
+    readonly _walletInstance: WalletInstance,
+    readonly _walletName: string,
+  ) {
+    this.walletInstance = { ..._walletInstance };
+  }
+
+  /**
+   * Returns a list of wallets installed on user's device. Each wallet is an object with the following properties:
+   * - A name is provided to display wallet's name on the user interface.
+   * - A version is provided to display wallet's version on the user interface.
+   * - An icon is provided to display wallet's icon on the user interface.
+   *
+   * @returns a list of wallet names
+   */
+  static getInstalledWallets(): Wallet[] {
+    if (window === undefined) return [];
+    if (window.cardano === undefined) return [];
+
+    let wallets: Wallet[] = [];
+    for (const key in window.cardano) {
+      try {
+        const _wallet = window.cardano[key];
+        if (_wallet === undefined) continue;
+        if (_wallet.name === undefined) continue;
+        if (_wallet.icon === undefined) continue;
+        if (_wallet.apiVersion === undefined) continue;
+        wallets.push({
+          id: key,
+          name: _wallet.name,
+          icon: _wallet.icon,
+          version: _wallet.apiVersion,
+        });
+      } catch (e) {}
+    }
+
+    return wallets;
+  }
+
+  /**
+   * This is the entrypoint to start communication with the user's wallet. The wallet should request the user's permission to connect the web page to the user's wallet, and if permission has been granted, the wallet will be returned and exposing the full API for the dApp to use.
+   *
+   * Query BrowserWallet.getInstalledWallets() to get a list of available wallets, then provide the wallet name for which wallet the user would like to connect with.
+   *
+   * @param walletName
+   * @returns WalletInstance
+   */
+  static async enable(walletName: string): Promise<BrowserWallet> {
+    try {
+      const walletInstance = await BrowserWallet.resolveInstance(walletName);
+
+      if (walletInstance !== undefined)
+        return new BrowserWallet(walletInstance, walletName);
+
+      throw new Error(`Couldn't create an instance of wallet: ${walletName}`);
+    } catch (error) {
+      throw new Error(
+        `[BrowserWallet] An error occurred during enable: ${JSON.stringify(
+          error,
+        )}.`,
+      );
+    }
+  }
+
+  /**
+   * Retrieves the total available balance of the wallet, encoded in CBOR.
+   * @returns {Promise<Value>} - The balance of the wallet.
+   */
+  // async _getBalance(): Promise<Value> {
+  //   const balance = await this._walletInstance.getBalance();
+  //   return Value.fromCbor(HexBlob(balance));
+  // }
+
+  /**
+   * Returns a list of assets in the wallet. This API will return every assets in the wallet. Each asset is an object with the following properties:
+   * - A unit is provided to display asset's name on the user interface.
+   * - A quantity is provided to display asset's quantity on the user interface.
+   *
+   * @returns a list of assets and their quantities
+   */
+  async getBalance(): Promise<Asset[]> {
+    const balance = await this._walletInstance.getBalance();
+    return fromValue(deserializeValue(balance));
+  }
+
+  /**
+   * Returns an address owned by the wallet that should be used as a change address to return leftover assets during transaction creation back to the connected wallet.
+   *
+   * @returns an address
+   */
+  async getChangeAddress(): Promise<string> {
+    const changeAddress = await this._walletInstance.getChangeAddress();
+    return addressToBech32(deserializeAddress(changeAddress));
+  }
+
+  /**
+   * This function shall return a list of one or more UTXOs (unspent transaction outputs) controlled by the wallet that are required to reach AT LEAST the combined ADA value target specified in amount AND the best suitable to be used as collateral inputs for transactions with plutus script inputs (pure ADA-only UTXOs).
+   *
+   * If this cannot be attained, an error message with an explanation of the blocking problem shall be returned. NOTE: wallets are free to return UTXOs that add up to a greater total ADA value than requested in the amount parameter, but wallets must never return any result where UTXOs would sum up to a smaller total ADA value, instead in a case like that an error message must be returned.
+   *
+   * @param limit
+   * @returns a list of UTXOs
+   */
+  async getCollateral(): Promise<UTxO[]> {
+    const deserializedCollateral = await this.getCollateralUnspentOutput();
+    return deserializedCollateral.map((dc) => fromTxUnspentOutput(dc));
+  }
+
+  /**
+   * Returns the network ID of the currently connected account. 0 is testnet and 1 is mainnet but other networks can possibly be returned by wallets. Those other network ID values are not governed by CIP-30. This result will stay the same unless the connected account has changed.
+   *
+   * @returns network ID
+   */
+  getNetworkId(): Promise<number> {
+    return this._walletInstance.getNetworkId();
+  }
+
+  /**
+   * Returns a list of reward addresses owned by the wallet. A reward address is a stake address that is used to receive rewards from staking, generally starts from `stake` prefix.
+   *
+   * @returns a list of reward addresses
+   */
+  async getRewardAddresses(): Promise<string[]> {
+    const rewardAddresses = await this._walletInstance.getRewardAddresses();
+    return rewardAddresses.map((ra) => addressToBech32(deserializeAddress(ra)));
+  }
+
+  /**
+   * Returns a list of unused addresses controlled by the wallet.
+   *
+   * @returns a list of unused addresses
+   */
+  async getUnusedAddresses(): Promise<string[]> {
+    const unusedAddresses = await this._walletInstance.getUnusedAddresses();
+    return unusedAddresses.map((una) =>
+      addressToBech32(deserializeAddress(una)),
+    );
+  }
+
+  /**
+   * Returns a list of used addresses controlled by the wallet.
+   *
+   * @returns a list of used addresses
+   */
+  async getUsedAddresses(): Promise<string[]> {
+    const usedAddresses = await this._walletInstance.getUsedAddresses();
+    return usedAddresses.map((usa) => addressToBech32(deserializeAddress(usa)));
+  }
+
+  /**
+   * Get a list of UTXOs to be used as collateral inputs for transactions with plutus script inputs.
+   *
+   * This is used in transaction building.
+   *
+   * @returns a list of UTXOs
+   */
+  async getUsedCollateral(
+    limit = DEFAULT_PROTOCOL_PARAMETERS.maxCollateralInputs,
+  ): Promise<TransactionUnspentOutput[]> {
+    const collateral =
+      (await this._walletInstance.experimental.getCollateral()) ?? [];
+    return collateral.map((c) => deserializeTxUnspentOutput(c)).slice(0, limit);
+  }
+
+  /**
+   * Return a list of all UTXOs (unspent transaction outputs) controlled by the wallet.
+   *
+   * @returns a list of UTXOs
+   */
+  async getUtxos(): Promise<UTxO[]> {
+    const deserializedUTxOs = await this.getUsedUTxOs();
+    return deserializedUTxOs.map((du) => fromTxUnspentOutput(du));
+  }
+
+  /**
+   * This endpoint utilizes the [CIP-8 - Message Signing](https://github.com/cardano-foundation/CIPs/tree/master/CIP-0030) to sign arbitrary data, to verify the data was signed by the owner of the private key.
+   *
+   * Here, we get the first wallet's address with wallet.getUsedAddresses(), alternativelly you can use reward addresses (getRewardAddresses()) too. It's really up to you as the developer which address you want to use in your application.
+   *
+   * @param address
+   * @param payload
+   * @returns a signature
+   */
+  signData(address: string, payload: string): Promise<DataSignature> {
+    const signerAddress = toAddress(address).toBytes().toString();
+    return this._walletInstance.signData(signerAddress, fromUTF8(payload));
+  }
+
+  /**
+   * Requests user to sign the provided transaction (tx). The wallet should ask the user for permission, and if given, try to sign the supplied body and return a signed transaction. partialSign should be true if the transaction provided requires multiple signatures.
+   *
+   * @param unsignedTx
+   * @param partialSign
+   * @returns a signed transaction in CBOR
+   */
+  async signTx(unsignedTx: string, partialSign = false): Promise<string> {
+    const witness = await this._walletInstance.signTx(unsignedTx, partialSign);
+    console.log("witness", witness);
+
+    return BrowserWallet.addBrowserWitnesses(unsignedTx, witness);
+  }
+
+  /**
+   * Experimental feature - sign multiple transactions at once (Supported wallet(s): Typhon)
+   *
+   * @param unsignedTxs - array of unsigned transactions in CborHex string
+   * @param partialSign - if the transactions are signed partially
+   * @returns array of signed transactions CborHex string
+   */
+  async signTxs(unsignedTxs: string[], partialSign = false): Promise<string[]> {
+    let witnessSets: string[] | undefined = undefined;
+    // Hardcoded behavior customized for different wallet for now as there is no standard confirmed
+    switch (this._walletName) {
+      case "Typhon Wallet":
+        if (this._walletInstance.signTxs) {
+          witnessSets = await this._walletInstance.signTxs(
+            unsignedTxs,
+            partialSign,
+          );
+        }
+        break;
+      default:
+        if (this._walletInstance.signTxs) {
+          witnessSets = await this._walletInstance.signTxs(
+            unsignedTxs.map((cbor) => ({
+              cbor,
+              partialSign,
+            })),
+          );
+        } else if (this._walletInstance.experimental.signTxs) {
+          witnessSets = await this._walletInstance.experimental.signTxs(
+            unsignedTxs.map((cbor) => ({
+              cbor,
+              partialSign,
+            })),
+          );
+        }
+        break;
+    }
+
+    if (!witnessSets) throw new Error("Wallet does not support signTxs");
+
+    const signedTxs: string[] = [];
+    for (let i = 0; i < witnessSets.length; i++) {
+      const unsignedTx = unsignedTxs[i]!;
+      const cWitness = witnessSets[i]!;
+      const signedTx = BrowserWallet.addBrowserWitnesses(unsignedTx, cWitness);
+      signedTxs.push(signedTx);
+    }
+
+    return signedTxs;
+  }
+
+  /**
+   * Submits the signed transaction to the blockchain network.
+   *
+   * As wallets should already have this ability to submit transaction, we allow dApps to request that a transaction be sent through it. If the wallet accepts the transaction and tries to send it, it shall return the transaction ID for the dApp to track. The wallet can return error messages or failure if there was an error in sending it.
+   *
+   * @param tx
+   * @returns a transaction hash
+   */
+  submitTx(tx: string): Promise<string> {
+    return this._walletInstance.submitTx(tx);
+  }
+
+  /**
+   * Get a used address of type Address from the wallet.
+   *
+   * This is used in transaction building.
+   *
+   * @returns an Address object
+   */
+  async getUsedAddress(): Promise<Address> {
+    const usedAddresses = await this._walletInstance.getUsedAddresses();
+    if (usedAddresses.length === 0) throw new Error("No used addresses found");
+    return deserializeAddress(usedAddresses[0]!);
+  }
+
+  /**
+   * Get a list of UTXOs to be used as collateral inputs for transactions with plutus script inputs.
+   *
+   * This is used in transaction building.
+   *
+   * @returns a list of UTXOs
+   */
+  async getCollateralUnspentOutput(): Promise<TransactionUnspentOutput[]> {
+    const collateral =
+      (await this._walletInstance.experimental.getCollateral()) ?? [];
+    return collateral.map((c) => deserializeTxUnspentOutput(c));
+  }
+
+  /**
+   * Get a list of UTXOs to be used for transaction building.
+   *
+   * This is used in transaction building.
+   *
+   * @returns a list of UTXOs
+   */
+  async getUsedUTxOs(): Promise<TransactionUnspentOutput[]> {
+    const utxos = (await this._walletInstance.getUtxos()) ?? [];
+    return utxos.map((u) => deserializeTxUnspentOutput(u));
+  }
+
+  /**
+   * A helper function to get the assets in the wallet.
+   *
+   * @returns a list of assets
+   */
+  async getAssets(): Promise<AssetExtended[]> {
+    const balance = await this.getBalance();
+    return balance
+      .filter((v) => v.unit !== "lovelace")
+      .map((v) => {
+        const policyId = v.unit.slice(0, POLICY_ID_LENGTH);
+        const assetName = v.unit.slice(POLICY_ID_LENGTH);
+        const fingerprint = resolveFingerprint(policyId, assetName);
+
+        return {
+          unit: v.unit,
+          policyId,
+          assetName,
+          fingerprint,
+          quantity: v.quantity,
+        };
+      });
+  }
+
+  /**
+   * A helper function to get the lovelace balance in the wallet.
+   *
+   * @returns lovelace balance
+   */
+  async getLovelace(): Promise<string> {
+    const balance = await this.getBalance();
+    const nativeAsset = balance.find((v) => v.unit === "lovelace");
+
+    return nativeAsset !== undefined ? nativeAsset.quantity : "0";
+  }
+
+  /**
+   * A helper function to get the assets of a specific policy ID in the wallet.
+   *
+   * @param policyId
+   * @returns a list of assets
+   */
+  async getPolicyIdAssets(policyId: string): Promise<AssetExtended[]> {
+    const assets = await this.getAssets();
+    return assets.filter((v) => v.policyId === policyId);
+  }
+
+  /**
+   * A helper function to get the policy IDs of all the assets in the wallet.
+   *
+   * @returns a list of policy IDs
+   */
+  async getPolicyIds(): Promise<string[]> {
+    const balance = await this.getBalance();
+    return Array.from(
+      new Set(balance.map((v) => v.unit.slice(0, POLICY_ID_LENGTH))),
+    ).filter((p) => p !== "lovelace");
+  }
+
+  private static resolveInstance(walletName: string) {
+    if (window.cardano === undefined) return undefined;
+    if (window.cardano[walletName] === undefined) return undefined;
+
+    const wallet = window.cardano[walletName];
+    return wallet?.enable();
+  }
+
+  static addBrowserWitnesses(unsignedTx: string, witnesses: string) {
+    const cWitness = Serialization.TransactionWitnessSet.fromCbor(
+      CardanoSDKUtil.HexBlob(witnesses),
+    )
+      .vkeys()
+      ?.values();
+
+    if (cWitness === undefined) {
+      return unsignedTx;
+    }
+
+    let tx = deserializeTx(unsignedTx);
+    // let tx = Transaction.fromCbor(CardanoSDK.TxCBOR(txHex));
+    let witnessSet = tx.witnessSet();
+    let witnessSetVkeys = witnessSet.vkeys();
+    let witnessSetVkeysValues: Serialization.VkeyWitness[] = witnessSetVkeys
+      ? [...witnessSetVkeys.values(), ...cWitness]
+      : [...cWitness];
+    witnessSet.setVkeys(
+      Serialization.CborSet.fromCore(
+        witnessSetVkeysValues.map((vkw) => vkw.toCore()),
+        VkeyWitness.fromCore,
+      ),
+    );
+
+    return new Transaction(tx.body(), witnessSet, tx.auxiliaryData()).toCbor();
+  }
+}

package/src/embedded/index.ts

@@ -0,0 +1,258 @@
+import * as BaseEncoding from "@scure/base";
+
+import {
+  bytesToHex,
+  DataSignature,
+  generateMnemonic,
+  mnemonicToEntropy,
+} from "@meshsdk/common";
+import {
+  Address,
+  Bip32PrivateKey,
+  buildBaseAddress,
+  buildBip32PrivateKey,
+  buildEnterpriseAddress,
+  buildKeys,
+  buildRewardAddress,
+  deserializeTx,
+  deserializeTxHash,
+  Ed25519KeyHashHex,
+  Ed25519PublicKeyHex,
+  Ed25519SignatureHex,
+  Hash28ByteBase16,
+  PrivateKey,
+  resolveTxHash,
+  Serialization,
+  signData,
+  Transaction,
+  VkeyWitness,
+} from "@meshsdk/core-cst";
+
+export type Account = {
+  baseAddress: Address;
+  enterpriseAddress: Address;
+  rewardAddress: Address;
+  baseAddressBech32: string;
+  enterpriseAddressBech32: string;
+  rewardAddressBech32: string;
+  paymentKey: PrivateKey;
+  stakeKey: PrivateKey;
+  paymentKeyHex: string;
+  stakeKeyHex: string;
+};
+
+export type EmbeddedWalletKeyType =
+  | {
+      type: "root";
+      bech32: string;
+    }
+  | {
+      type: "cli";
+      payment: string;
+      stake?: string;
+    }
+  | {
+      type: "mnemonic";
+      words: string[];
+    };
+
+export type CreateEmbeddedWalletOptions = {
+  networkId: number;
+  key: EmbeddedWalletKeyType;
+};
+
+export class WalletStaticMethods {
+  static privateKeyToEntropy(bech32: string): string {
+    const bech32DecodedBytes = BaseEncoding.bech32.decodeToBytes(bech32).bytes;
+    const bip32PrivateKey = Bip32PrivateKey.fromBytes(bech32DecodedBytes);
+    return bytesToHex(bip32PrivateKey.bytes());
+  }
+
+  static mnemonicToEntropy(words: string[]): string {
+    const entropy = mnemonicToEntropy(words.join(" "));
+    const bip32PrivateKey = buildBip32PrivateKey(entropy);
+    return bytesToHex(bip32PrivateKey.bytes());
+  }
+
+  static signingKeyToEntropy(
+    paymentKey: string,
+    stakeKey: string,
+  ): [string, string] {
+    return [
+      paymentKey.startsWith("5820") ? paymentKey.slice(4) : paymentKey,
+      stakeKey.startsWith("5820") ? stakeKey.slice(4) : stakeKey,
+    ];
+  }
+
+  static getAddresses(
+    paymentKey: PrivateKey,
+    stakingKey: PrivateKey,
+    networkId = 0,
+  ): {
+    baseAddress: Address;
+    enterpriseAddress: Address;
+    rewardAddress: Address;
+  } {
+    const baseAddress = buildBaseAddress(
+      networkId,
+      Hash28ByteBase16.fromEd25519KeyHashHex(
+        Ed25519KeyHashHex(paymentKey.toPublicKey().hash().toString("hex")),
+      ),
+      Hash28ByteBase16.fromEd25519KeyHashHex(
+        Ed25519KeyHashHex(stakingKey.toPublicKey().hash().toString("hex")),
+      ),
+    );
+
+    const enterpriseAddress = buildEnterpriseAddress(
+      networkId,
+      Hash28ByteBase16.fromEd25519KeyHashHex(
+        Ed25519KeyHashHex(paymentKey.toPublicKey().hash().toString("hex")),
+      ),
+    );
+
+    const rewardAddress = buildRewardAddress(
+      networkId,
+      Hash28ByteBase16.fromEd25519KeyHashHex(
+        Ed25519KeyHashHex(stakingKey.toPublicKey().hash().toString("hex")),
+      ),
+    );
+
+    return {
+      baseAddress: baseAddress.toAddress(),
+      enterpriseAddress: enterpriseAddress.toAddress(),
+      rewardAddress: rewardAddress.toAddress(),
+    };
+  }
+
+  static generateMnemonic(strength = 256): string[] {
+    const mnemonic = generateMnemonic(strength);
+    return mnemonic.split(" ");
+  }
+
+  static addWitnessSets(txHex: string, witnesses: VkeyWitness[]): string {
+    let tx = deserializeTx(txHex);
+    let witnessSet = tx.witnessSet();
+    let witnessSetVkeys = witnessSet.vkeys();
+    let witnessSetVkeysValues: Serialization.VkeyWitness[] = witnessSetVkeys
+      ? [...witnessSetVkeys.values(), ...witnesses]
+      : witnesses;
+    witnessSet.setVkeys(
+      Serialization.CborSet.fromCore(
+        witnessSetVkeysValues.map((vkw) => vkw.toCore()),
+        VkeyWitness.fromCore,
+      ),
+    );
+    return new Transaction(tx.body(), witnessSet, tx.auxiliaryData()).toCbor();
+  }
+}
+
+export class EmbeddedWallet extends WalletStaticMethods {
+  private readonly _entropy?: string | [string, string];
+  private readonly _networkId: number;
+
+  constructor(options: CreateEmbeddedWalletOptions) {
+    super();
+    this._networkId = options.networkId;
+
+    switch (options.key.type) {
+      case "mnemonic":
+        this._entropy = WalletStaticMethods.mnemonicToEntropy(
+          options.key.words,
+        );
+        break;
+      case "root":
+        this._entropy = WalletStaticMethods.privateKeyToEntropy(
+          options.key.bech32,
+        );
+        break;
+      case "cli":
+        this._entropy = WalletStaticMethods.signingKeyToEntropy(
+          options.key.payment,
+          options.key.stake ?? "f0".repeat(32),
+        );
+        break;
+    }
+  }
+
+  getAccount(accountIndex = 0, keyIndex = 0): Account {
+    if (this._entropy == undefined)
+      throw new Error("[EmbeddedWallet] No keys initialized");
+
+    const { paymentKey, stakeKey } = buildKeys(
+      this._entropy,
+      accountIndex,
+      keyIndex,
+    );
+
+    const { baseAddress, enterpriseAddress, rewardAddress } =
+      WalletStaticMethods.getAddresses(paymentKey, stakeKey, this._networkId);
+
+    return {
+      baseAddress: baseAddress,
+      enterpriseAddress: enterpriseAddress,
+      rewardAddress: rewardAddress,
+      baseAddressBech32: baseAddress.toBech32(),
+      enterpriseAddressBech32: enterpriseAddress.toBech32(),
+      rewardAddressBech32: rewardAddress.toBech32(),
+      paymentKey: paymentKey,
+      stakeKey: stakeKey,
+      paymentKeyHex: paymentKey.toBytes().toString("hex"),
+      stakeKeyHex: stakeKey.toBytes().toString("hex"),
+    };
+  }
+
+  getNetworkId(): number {
+    return this._networkId;
+  }
+
+  signData(
+    address: string,
+    payload: string,
+    accountIndex = 0,
+    keyIndex = 0,
+  ): DataSignature {
+    try {
+      const account = this.getAccount(accountIndex, keyIndex);
+
+      const foundAddress = [
+        account.baseAddress,
+        account.enterpriseAddress,
+        account.rewardAddress,
+      ].find((a) => a.toBech32() === address);
+
+      if (foundAddress === undefined)
+        throw new Error(
+          `[EmbeddedWallet] Address: ${address} doesn't belong to this account.`,
+        );
+
+      return signData(payload, account.paymentKey);
+    } catch (error) {
+      throw new Error(
+        `[EmbeddedWallet] An error occurred during signData: ${error}.`,
+      );
+    }
+  }
+
+  signTx(unsignedTx: string, accountIndex = 0, keyIndex = 0): VkeyWitness {
+    try {
+      const txHash = deserializeTxHash(resolveTxHash(unsignedTx));
+
+      const account = this.getAccount(accountIndex, keyIndex);
+
+      const vKeyWitness = new VkeyWitness(
+        Ed25519PublicKeyHex(
+          account.paymentKey.toPublicKey().toBytes().toString("hex"),
+        ),
+        Ed25519SignatureHex(
+          account.paymentKey.sign(Buffer.from(txHash, "hex")).toString("hex"),
+        ),
+      );
+
+      return vKeyWitness;
+    } catch (error) {
+      throw new Error(
+        `[EmbeddedWallet] An error occurred during signTx: ${error}.`,
+      );
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./app";
+export * from "./browser";
+export * from "./embedded";
+export * from "./mesh";