wowok 1.8.2 → 2.1.9

package/dist/esm/keypairs/ed25519/ed25519-hd-key.js

@@ -0,0 +1,62 @@
+import { fromHex } from "@mysten/bcs";
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+const ED25519_CURVE = "ed25519 seed";
+const HARDENED_OFFSET = 2147483648;
+const pathRegex = new RegExp("^m(\\/[0-9]+')+$");
+const replaceDerive = (val) => val.replace("'", "");
+const getMasterKeyFromSeed = (seed) => {
+  const h = hmac.create(sha512, ED25519_CURVE);
+  const I = h.update(fromHex(seed)).digest();
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    key: IL,
+    chainCode: IR
+  };
+};
+const CKDPriv = ({ key, chainCode }, index) => {
+  const indexBuffer = new ArrayBuffer(4);
+  const cv = new DataView(indexBuffer);
+  cv.setUint32(0, index);
+  const data = new Uint8Array(1 + key.length + indexBuffer.byteLength);
+  data.set(new Uint8Array(1).fill(0));
+  data.set(key, 1);
+  data.set(
+    new Uint8Array(indexBuffer, 0, indexBuffer.byteLength),
+    key.length + 1
+  );
+  const I = hmac.create(sha512, chainCode).update(data).digest();
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    key: IL,
+    chainCode: IR
+  };
+};
+const isValidPath = (path) => {
+  if (!pathRegex.test(path)) {
+    return false;
+  }
+  return !path.split("/").slice(1).map(replaceDerive).some(
+    isNaN
+    /* ts T_T*/
+  );
+};
+const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
+  if (!isValidPath(path)) {
+    throw new Error("Invalid derivation path");
+  }
+  const { key, chainCode } = getMasterKeyFromSeed(seed);
+  const segments = path.split("/").slice(1).map(replaceDerive).map((el) => parseInt(el, 10));
+  return segments.reduce(
+    (parentKeys, segment) => CKDPriv(parentKeys, segment + offset),
+    {
+      key,
+      chainCode
+    }
+  );
+};
+export {
+  derivePath
+};

package/dist/esm/keypairs/ed25519/index.d.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair, type Ed25519KeypairData, } from "./keypair.js";
+export { Ed25519PublicKey } from "./publickey.js";

package/dist/esm/keypairs/ed25519/index.js

@@ -0,0 +1,10 @@
+import {
+  DEFAULT_ED25519_DERIVATION_PATH,
+  Ed25519Keypair
+} from "./keypair.js";
+import { Ed25519PublicKey } from "./publickey.js";
+export {
+  DEFAULT_ED25519_DERIVATION_PATH,
+  Ed25519Keypair,
+  Ed25519PublicKey
+};

package/dist/esm/keypairs/ed25519/keypair.d.ts

@@ -0,0 +1,74 @@
+import { Keypair } from "../../cryptography/keypair.js";
+import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
+import { Ed25519PublicKey } from "./publickey.js";
+export declare const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+/**
+ * Ed25519 Keypair data. The publickey is the 32-byte public key and
+ * the secretkey is 64-byte, where the first 32 bytes is the secret
+ * key and the last 32 bytes is the public key.
+ */
+export interface Ed25519KeypairData {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+/**
+ * An Ed25519 Keypair used for signing transactions.
+ */
+export declare class Ed25519Keypair extends Keypair {
+    private keypair;
+    /**
+     * Create a new Ed25519 keypair instance.
+     * Generate random keypair if no {@link Ed25519Keypair} is provided.
+     *
+     * @param keypair Ed25519 keypair
+     */
+    constructor(keypair?: Ed25519KeypairData);
+    /**
+     * Get the key scheme of the keypair ED25519
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Generate a new random Ed25519 keypair
+     */
+    static generate(): Ed25519Keypair;
+    /**
+     * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+     * This is NOT the private scalar which is result of hashing and bit clamping of
+     * the raw secret key.
+     *
+     * @throws error if the provided secret key is invalid and validation is not skipped.
+     *
+     * @param secretKey secret key as a byte array or Bech32 secret key string
+     * @param options: skip secret key validation
+     */
+    static fromSecretKey(secretKey: Uint8Array | string, options?: {
+        skipValidation?: boolean;
+    }): Ed25519Keypair;
+    /**
+     * The public key for this Ed25519 keypair
+     */
+    getPublicKey(): Ed25519PublicKey;
+    /**
+     * The Bech32 secret key string for this Ed25519 keypair
+     */
+    getSecretKey(): string;
+    /**
+     * Return the signature for the provided data using Ed25519.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
+     * and validated against the english wordlist.
+     *
+     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+     */
+    static deriveKeypair(mnemonics: string, path?: string): Ed25519Keypair;
+    /**
+     * Derive Ed25519 keypair from mnemonicSeed and path.
+     *
+     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+     */
+    static deriveKeypairFromSeed(seedHex: string, path?: string): Ed25519Keypair;
+}

package/dist/esm/keypairs/ed25519/keypair.js

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { ed25519 } from "@noble/curves/ed25519";
+import {
+  decodeWowPrivateKey,
+  encodeWowPrivateKey,
+  Keypair,
+  PRIVATE_KEY_SIZE
+} from "../../cryptography/keypair.js";
+import {
+  isValidHardenedPath,
+  mnemonicToSeedHex
+} from "../../cryptography/mnemonics.js";
+import { derivePath } from "./ed25519-hd-key.js";
+import { Ed25519PublicKey } from "./publickey.js";
+const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+class Ed25519Keypair extends Keypair {
+  /**
+   * Create a new Ed25519 keypair instance.
+   * Generate random keypair if no {@link Ed25519Keypair} is provided.
+   *
+   * @param keypair Ed25519 keypair
+   */
+  constructor(keypair) {
+    super();
+    __publicField(this, "keypair");
+    if (keypair) {
+      this.keypair = {
+        publicKey: keypair.publicKey,
+        secretKey: keypair.secretKey.slice(0, 32)
+      };
+    } else {
+      const privateKey = ed25519.utils.randomPrivateKey();
+      this.keypair = {
+        publicKey: ed25519.getPublicKey(privateKey),
+        secretKey: privateKey
+      };
+    }
+  }
+  /**
+   * Get the key scheme of the keypair ED25519
+   */
+  getKeyScheme() {
+    return "ED25519";
+  }
+  /**
+   * Generate a new random Ed25519 keypair
+   */
+  static generate() {
+    const secretKey = ed25519.utils.randomPrivateKey();
+    return new Ed25519Keypair({
+      publicKey: ed25519.getPublicKey(secretKey),
+      secretKey
+    });
+  }
+  /**
+   * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+   * This is NOT the private scalar which is result of hashing and bit clamping of
+   * the raw secret key.
+   *
+   * @throws error if the provided secret key is invalid and validation is not skipped.
+   *
+   * @param secretKey secret key as a byte array or Bech32 secret key string
+   * @param options: skip secret key validation
+   */
+  static fromSecretKey(secretKey, options) {
+    if (typeof secretKey === "string") {
+      const decoded = decodeWowPrivateKey(secretKey);
+      if (decoded.scheme !== "ED25519") {
+        throw new Error(
+          `Expected a ED25519 keypair, got ${decoded.scheme}`
+        );
+      }
+      return this.fromSecretKey(decoded.secretKey, options);
+    }
+    const secretKeyLength = secretKey.length;
+    if (secretKeyLength !== PRIVATE_KEY_SIZE) {
+      throw new Error(
+        `Wrong secretKey size. Expected ${PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`
+      );
+    }
+    const keypair = {
+      publicKey: ed25519.getPublicKey(secretKey),
+      secretKey
+    };
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode("sui validation");
+      const signature = ed25519.sign(signData, secretKey);
+      if (!ed25519.verify(signature, signData, keypair.publicKey)) {
+        throw new Error("provided secretKey is invalid");
+      }
+    }
+    return new Ed25519Keypair(keypair);
+  }
+  /**
+   * The public key for this Ed25519 keypair
+   */
+  getPublicKey() {
+    return new Ed25519PublicKey(this.keypair.publicKey);
+  }
+  /**
+   * The Bech32 secret key string for this Ed25519 keypair
+   */
+  getSecretKey() {
+    return encodeWowPrivateKey(
+      this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE),
+      this.getKeyScheme()
+    );
+  }
+  /**
+   * Return the signature for the provided data using Ed25519.
+   */
+  async sign(data) {
+    return ed25519.sign(
+      data,
+      this.keypair.secretKey
+    );
+  }
+  /**
+   * Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
+   * and validated against the english wordlist.
+   *
+   * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+   * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+   */
+  static deriveKeypair(mnemonics, path) {
+    if (path == null) {
+      path = DEFAULT_ED25519_DERIVATION_PATH;
+    }
+    if (!isValidHardenedPath(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const { key } = derivePath(path, mnemonicToSeedHex(mnemonics));
+    return Ed25519Keypair.fromSecretKey(key);
+  }
+  /**
+   * Derive Ed25519 keypair from mnemonicSeed and path.
+   *
+   * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+   * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+   */
+  static deriveKeypairFromSeed(seedHex, path) {
+    if (path == null) {
+      path = DEFAULT_ED25519_DERIVATION_PATH;
+    }
+    if (!isValidHardenedPath(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const { key } = derivePath(path, seedHex);
+    return Ed25519Keypair.fromSecretKey(key);
+  }
+}
+export {
+  DEFAULT_ED25519_DERIVATION_PATH,
+  Ed25519Keypair
+};

package/dist/esm/keypairs/ed25519/publickey.d.ts

@@ -0,0 +1,30 @@
+import { PublicKey } from "../../cryptography/publickey.js";
+import type { PublicKeyInitData } from "../../cryptography/publickey.js";
+/**
+ * An Ed25519 public key
+ */
+export declare class Ed25519PublicKey extends PublicKey {
+    static SIZE: number;
+    private data;
+    /**
+     * Create a new Ed25519PublicKey object
+     * @param value ed25519 public key as buffer or base-64 encoded string
+     */
+    constructor(value: PublicKeyInitData);
+    /**
+     * Checks if two Ed25519 public keys are equal
+     */
+    equals(publicKey: Ed25519PublicKey): boolean;
+    /**
+     * Return the byte array representation of the Ed25519 public key
+     */
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return the Sui address associated with this Ed25519 public key
+     */
+    flag(): number;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}

package/dist/esm/keypairs/ed25519/publickey.js

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { fromBase64 } from "@mysten/bcs";
+import { ed25519 } from "@noble/curves/ed25519";
+import {
+  bytesEqual,
+  parseSerializedKeypairSignature,
+  PublicKey
+} from "../../cryptography/publickey.js";
+import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
+const PUBLIC_KEY_SIZE = 32;
+class Ed25519PublicKey extends PublicKey {
+  /**
+   * Create a new Ed25519PublicKey object
+   * @param value ed25519 public key as buffer or base-64 encoded string
+   */
+  constructor(value) {
+    super();
+    __publicField(this, "data");
+    if (typeof value === "string") {
+      this.data = fromBase64(value);
+    } else if (value instanceof Uint8Array) {
+      this.data = value;
+    } else {
+      this.data = Uint8Array.from(value);
+    }
+    if (this.data.length !== PUBLIC_KEY_SIZE) {
+      throw new Error(
+        `Invalid public key input. Expected ${PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
+      );
+    }
+  }
+  /**
+   * Checks if two Ed25519 public keys are equal
+   */
+  equals(publicKey) {
+    return super.equals(publicKey);
+  }
+  /**
+   * Return the byte array representation of the Ed25519 public key
+   */
+  toRawBytes() {
+    return this.data;
+  }
+  /**
+   * Return the Sui address associated with this Ed25519 public key
+   */
+  flag() {
+    return SIGNATURE_SCHEME_TO_FLAG["ED25519"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(message, signature) {
+    let bytes;
+    if (typeof signature === "string") {
+      const parsed = parseSerializedKeypairSignature(signature);
+      if (parsed.signatureScheme !== "ED25519") {
+        throw new Error("Invalid signature scheme");
+      }
+      if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {
+        throw new Error("Signature does not match public key");
+      }
+      bytes = parsed.signature;
+    } else {
+      bytes = signature;
+    }
+    return ed25519.verify(bytes, message, this.toRawBytes());
+  }
+}
+__publicField(Ed25519PublicKey, "SIZE", PUBLIC_KEY_SIZE);
+export {
+  Ed25519PublicKey
+};

package/dist/esm/keypairs/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ed25519/index.js";
+export * from "./passkey/index.js";
+export * from "./secp256k1/index.js";
+export * from "./secp256r1/index.js";

package/dist/esm/keypairs/index.js

@@ -0,0 +1,4 @@
+export * from "./ed25519/index.js";
+export * from "./passkey/index.js";
+export * from "./secp256k1/index.js";
+export * from "./secp256r1/index.js";

package/dist/esm/keypairs/passkey/index.d.ts

@@ -0,0 +1,3 @@
+export { PasskeyKeypair, BrowserPasskeyProvider, findCommonPublicKey, } from "./keypair.js";
+export type { PasskeyProvider, BrowserPasswordProviderOptions, } from "./keypair.js";
+export { PasskeyPublicKey } from "./publickey.js";

package/dist/esm/keypairs/passkey/index.js

@@ -0,0 +1,12 @@
+import {
+  PasskeyKeypair,
+  BrowserPasskeyProvider,
+  findCommonPublicKey
+} from "./keypair.js";
+import { PasskeyPublicKey } from "./publickey.js";
+export {
+  BrowserPasskeyProvider,
+  PasskeyKeypair,
+  PasskeyPublicKey,
+  findCommonPublicKey
+};

package/dist/esm/keypairs/passkey/keypair.d.ts

@@ -0,0 +1,113 @@
+import type { IntentScope, SignatureWithBytes } from "../../cryptography/index.js";
+import { Signer } from "../../cryptography/index.js";
+import type { PublicKey } from "../../cryptography/publickey.js";
+import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
+import type { AuthenticationCredential, RegistrationCredential } from "./types.js";
+type DeepPartialConfigKeys = "rp" | "user" | "authenticatorSelection";
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type BrowserPasswordProviderOptions = Pick<DeepPartial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys> & Omit<Partial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys | "pubKeyCredParams" | "challenge">;
+export interface PasskeyProvider {
+    create(): Promise<RegistrationCredential>;
+    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
+}
+export declare class BrowserPasskeyProvider implements PasskeyProvider {
+    #private;
+    constructor(name: string, options: BrowserPasswordProviderOptions);
+    create(): Promise<RegistrationCredential>;
+    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
+}
+/**
+ * @experimental
+ * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md).
+ */
+export declare class PasskeyKeypair extends Signer {
+    private publicKey;
+    private provider;
+    /**
+     * Get the key scheme of passkey,
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Creates an instance of Passkey signer. If no passkey wallet had created before,
+     * use `getPasskeyInstance`. For example:
+     * ```
+     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
+     * 	  rpName: 'Sui Passkey Example',
+     * 	  rpId: window.location.hostname,
+     * } as BrowserPasswordProviderOptions);
+     * const signer = await PasskeyKeypair.getPasskeyInstance(provider);
+     * ```
+     *
+     * If there are existing passkey wallet, use `signAndRecover` to identify the correct
+     * public key and then initialize the instance. See usage in `signAndRecover`.
+     */
+    constructor(publicKey: Uint8Array, provider: PasskeyProvider);
+    /**
+     * Creates an instance of Passkey signer invoking the passkey from navigator.
+     * Note that this will invoke the passkey device to create a fresh credential.
+     * Should only be called if passkey wallet is created for the first time.
+     *
+     * @param provider - the passkey provider.
+     * @returns the passkey instance.
+     */
+    static getPasskeyInstance(provider: PasskeyProvider): Promise<PasskeyKeypair>;
+    /**
+     * Return the public key for this passkey.
+     */
+    getPublicKey(): PublicKey;
+    /**
+     * Return the signature for the provided data (i.e. blake2b(intent_message)).
+     * This is sent to passkey as the challenge field.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * This overrides the base class implementation that accepts the raw bytes and signs its
+     * digest of the intent message, then serialize it with the passkey flag.
+     */
+    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
+    /**
+     * Given a message, asks the passkey device to sign it and return all (up to 4) possible public keys.
+     * See: https://bitcoin.stackexchange.com/questions/81232/how-is-public-key-extracted-from-message-digital-signature-address
+     *
+     * This is useful if the user previously created passkey wallet with the origin, but the wallet session
+     * does not have the public key / address. By calling this method twice with two different messages, the
+     * wallet can compare the returned public keys and uniquely identify the previously created passkey wallet
+     * using `findCommonPublicKey`.
+     *
+     * Alternatively, one call can be made and all possible public keys should be checked onchain to see if
+     * there is any assets.
+     *
+     * Once the correct public key is identified, a passkey instance can then be initialized with this public key.
+     *
+     * Example usage to recover wallet with two signing calls:
+     * ```
+     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
+     *     rpName: 'Sui Passkey Example',
+     * 	   rpId: window.location.hostname,
+     * } as BrowserPasswordProviderOptions);
+     * const testMessage = new TextEncoder().encode('Hello world!');
+     * const possiblePks = await PasskeyKeypair.signAndRecover(provider, testMessage);
+     * const testMessage2 = new TextEncoder().encode('Hello world 2!');
+     * const possiblePks2 = await PasskeyKeypair.signAndRecover(provider, testMessage2);
+     * const commonPk = findCommonPublicKey(possiblePks, possiblePks2);
+     * const signer = new PasskeyKeypair(provider, commonPk.toRawBytes());
+     * ```
+     *
+     * @param provider - the passkey provider.
+     * @param message - the message to sign.
+     * @returns all possible public keys.
+     */
+    static signAndRecover(provider: PasskeyProvider, message: Uint8Array): Promise<PublicKey[]>;
+}
+/**
+ * Finds the unique public key that exists in both arrays, throws error if the common
+ * pubkey does not equal to one.
+ *
+ * @param arr1 - The first pubkeys array.
+ * @param arr2 - The second pubkeys array.
+ * @returns The only common pubkey in both arrays.
+ */
+export declare function findCommonPublicKey(arr1: PublicKey[], arr2: PublicKey[]): PublicKey;
+export {};