@haneullabs/haneul 0.1.0 → 2.5.0

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

@@ -1,130 +0,0 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { blake2b } from "@noble/hashes/blake2b";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
-import { HDKey } from "@scure/bip32";
-import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from "../../cryptography/keypair.js";
-import { isValidBIP32Path, mnemonicToSeed } from "../../cryptography/mnemonics.js";
-import { Secp256k1PublicKey } from "./publickey.js";
-const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
-class Secp256k1Keypair extends Keypair {
-  /**
-   * Create a new keypair instance.
-   * Generate random keypair if no {@link Secp256k1Keypair} is provided.
-   *
-   * @param keypair secp256k1 keypair
-   */
-  constructor(keypair) {
-    super();
-    if (keypair) {
-      this.keypair = keypair;
-    } else {
-      const secretKey = secp256k1.utils.randomPrivateKey();
-      const publicKey = secp256k1.getPublicKey(secretKey, true);
-      this.keypair = { publicKey, secretKey };
-    }
-  }
-  /**
-   * Get the key scheme of the keypair Secp256k1
-   */
-  getKeyScheme() {
-    return "Secp256k1";
-  }
-  /**
-   * Generate a new random keypair
-   */
-  static generate() {
-    return new Secp256k1Keypair();
-  }
-  /**
-   * Create a keypair from a raw secret key byte array.
-   *
-   * This method should only be used to recreate a keypair from a previously
-   * generated secret key. Generating keypairs from a random seed should be done
-   * with the {@link Keypair.fromSeed} method.
-   *
-   * @throws error if the provided secret key is invalid and validation is not skipped.
-   *
-   * @param secretKey secret key byte array  or Bech32 secret key string
-   * @param options: skip secret key validation
-   */
-  static fromSecretKey(secretKey, options) {
-    if (typeof secretKey === "string") {
-      const decoded = decodeHaneulPrivateKey(secretKey);
-      if (decoded.schema !== "Secp256k1") {
-        throw new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);
-      }
-      return this.fromSecretKey(decoded.secretKey, options);
-    }
-    const publicKey = secp256k1.getPublicKey(secretKey, true);
-    if (!options || !options.skipValidation) {
-      const encoder = new TextEncoder();
-      const signData = encoder.encode("sui validation");
-      const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-      const signature = secp256k1.sign(msgHash, secretKey);
-      if (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {
-        throw new Error("Provided secretKey is invalid");
-      }
-    }
-    return new Secp256k1Keypair({ publicKey, secretKey });
-  }
-  /**
-   * Generate a keypair from a 32 byte seed.
-   *
-   * @param seed seed byte array
-   */
-  static fromSeed(seed) {
-    const publicKey = secp256k1.getPublicKey(seed, true);
-    return new Secp256k1Keypair({ publicKey, secretKey: seed });
-  }
-  /**
-   * The public key for this keypair
-   */
-  getPublicKey() {
-    return new Secp256k1PublicKey(this.keypair.publicKey);
-  }
-  /**
-   * The Bech32 secret key string for this Secp256k1 keypair
-   */
-  getSecretKey() {
-    return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-  }
-  /**
-   * Return the signature for the provided data.
-   */
-  async sign(data) {
-    const msgHash = sha256(data);
-    const sig = secp256k1.sign(msgHash, this.keypair.secretKey, {
-      lowS: true
-    });
-    return sig.toCompactRawBytes();
-  }
-  /**
-   * Derive Secp256k1 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/54'/784'/0'/0/0, otherwise the path must
-   * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
-   */
-  static deriveKeypair(mnemonics, path) {
-    if (path == null) {
-      path = DEFAULT_SECP256K1_DERIVATION_PATH;
-    }
-    if (!isValidBIP32Path(path)) {
-      throw new Error("Invalid derivation path");
-    }
-    const key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);
-    if (key.publicKey == null || key.privateKey == null) {
-      throw new Error("Invalid key");
-    }
-    return new Secp256k1Keypair({
-      publicKey: key.publicKey,
-      secretKey: key.privateKey
-    });
-  }
-}
-export {
-  DEFAULT_SECP256K1_DERIVATION_PATH,
-  Secp256k1Keypair
-};
-//# sourceMappingURL=keypair.js.map

package/dist/esm/keypairs/secp256k1/keypair.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/keypairs/secp256k1/keypair.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { bytesToHex } from '@noble/hashes/utils';\nimport { HDKey } from '@scure/bip32';\n\nimport { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';\nimport { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';\nimport type { PublicKey } from '../../cryptography/publickey.js';\nimport type { SignatureScheme } from '../../cryptography/signature-scheme.js';\nimport { Secp256k1PublicKey } from './publickey.js';\n\nexport const DEFAULT_SECP256K1_DERIVATION_PATH = \"m/54'/784'/0'/0/0\";\n\n/**\n * Secp256k1 Keypair data\n */\nexport interface Secp256k1KeypairData {\n\tpublicKey: Uint8Array;\n\tsecretKey: Uint8Array;\n}\n\n/**\n * An Secp256k1 Keypair used for signing transactions.\n */\nexport class Secp256k1Keypair extends Keypair {\n\tprivate keypair: Secp256k1KeypairData;\n\n\t/**\n\t * Create a new keypair instance.\n\t * Generate random keypair if no {@link Secp256k1Keypair} is provided.\n\t *\n\t * @param keypair secp256k1 keypair\n\t */\n\tconstructor(keypair?: Secp256k1KeypairData) {\n\t\tsuper();\n\t\tif (keypair) {\n\t\t\tthis.keypair = keypair;\n\t\t} else {\n\t\t\tconst secretKey: Uint8Array = secp256k1.utils.randomPrivateKey();\n\t\t\tconst publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);\n\n\t\t\tthis.keypair = { publicKey, secretKey };\n\t\t}\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair Secp256k1\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'Secp256k1';\n\t}\n\n\t/**\n\t * Generate a new random keypair\n\t */\n\tstatic generate(): Secp256k1Keypair {\n\t\treturn new Secp256k1Keypair();\n\t}\n\n\t/**\n\t * Create a keypair from a raw secret key byte array.\n\t *\n\t * This method should only be used to recreate a keypair from a previously\n\t * generated secret key. Generating keypairs from a random seed should be done\n\t * with the {@link Keypair.fromSeed} method.\n\t *\n\t * @throws error if the provided secret key is invalid and validation is not skipped.\n\t *\n\t * @param secretKey secret key byte array  or Bech32 secret key string\n\t * @param options: skip secret key validation\n\t */\n\n\tstatic fromSecretKey(\n\t\tsecretKey: Uint8Array | string,\n\t\toptions?: { skipValidation?: boolean },\n\t): Secp256k1Keypair {\n\t\tif (typeof secretKey === 'string') {\n\t\t\tconst decoded = decodeHaneulPrivateKey(secretKey);\n\n\t\t\tif (decoded.schema !== 'Secp256k1') {\n\t\t\t\tthrow new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);\n\t\t\t}\n\n\t\t\treturn this.fromSecretKey(decoded.secretKey, options);\n\t\t}\n\n\t\tconst publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);\n\t\tif (!options || !options.skipValidation) {\n\t\t\tconst encoder = new TextEncoder();\n\t\t\tconst signData = encoder.encode('sui validation');\n\t\t\tconst msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));\n\t\t\tconst signature = secp256k1.sign(msgHash, secretKey);\n\t\t\tif (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {\n\t\t\t\tthrow new Error('Provided secretKey is invalid');\n\t\t\t}\n\t\t}\n\t\treturn new Secp256k1Keypair({ publicKey, secretKey });\n\t}\n\n\t/**\n\t * Generate a keypair from a 32 byte seed.\n\t *\n\t * @param seed seed byte array\n\t */\n\tstatic fromSeed(seed: Uint8Array): Secp256k1Keypair {\n\t\tconst publicKey = secp256k1.getPublicKey(seed, true);\n\t\treturn new Secp256k1Keypair({ publicKey, secretKey: seed });\n\t}\n\n\t/**\n\t * The public key for this keypair\n\t */\n\tgetPublicKey(): PublicKey {\n\t\treturn new Secp256k1PublicKey(this.keypair.publicKey);\n\t}\n\t/**\n\t * The Bech32 secret key string for this Secp256k1 keypair\n\t */\n\tgetSecretKey(): string {\n\t\treturn encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());\n\t}\n\n\t/**\n\t * Return the signature for the provided data.\n\t */\n\tasync sign(data: Uint8Array) {\n\t\tconst msgHash = sha256(data);\n\t\tconst sig = secp256k1.sign(msgHash, this.keypair.secretKey, {\n\t\t\tlowS: true,\n\t\t});\n\t\treturn sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;\n\t}\n\n\t/**\n\t * Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized\n\t * and validated against the english wordlist.\n\t *\n\t * If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must\n\t * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.\n\t */\n\tstatic deriveKeypair(mnemonics: string, path?: string): Secp256k1Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_SECP256K1_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidBIP32Path(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\tconst key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);\n\t\tif (key.publicKey == null || key.privateKey == null) {\n\t\t\tthrow new Error('Invalid key');\n\t\t}\n\t\treturn new Secp256k1Keypair({\n\t\t\tpublicKey: key.publicKey,\n\t\t\tsecretKey: key.privateKey,\n\t\t});\n\t}\n}\n"],
-  "mappings": "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",
-  "names": []
-}

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

@@ -1,30 +0,0 @@
-import { PublicKey } from '../../cryptography/publickey.js';
-import type { PublicKeyInitData } from '../../cryptography/publickey.js';
-/**
- * A Secp256k1 public key
- */
-export declare class Secp256k1PublicKey extends PublicKey {
-    static SIZE: number;
-    private data;
-    /**
-     * Create a new Secp256k1PublicKey object
-     * @param value secp256k1 public key as buffer or base-64 encoded string
-     */
-    constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two Secp256k1 public keys are equal
-     */
-    equals(publicKey: Secp256k1PublicKey): boolean;
-    /**
-     * Return the byte array representation of the Secp256k1 public key
-     */
-    toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Haneul address associated with this Secp256k1 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/secp256k1/publickey.js

@@ -1,77 +0,0 @@
-import { fromBase64 } from "@haneullabs/bcs";
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { sha256 } from "@noble/hashes/sha256";
-import {
-  bytesEqual,
-  parseSerializedKeypairSignature,
-  PublicKey
-} from "../../cryptography/publickey.js";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
-const SECP256K1_PUBLIC_KEY_SIZE = 33;
-class Secp256k1PublicKey extends PublicKey {
-  /**
-   * Create a new Secp256k1PublicKey object
-   * @param value secp256k1 public key as buffer or base-64 encoded string
-   */
-  constructor(value) {
-    super();
-    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 !== SECP256K1_PUBLIC_KEY_SIZE) {
-      throw new Error(
-        `Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
-      );
-    }
-  }
-  /**
-   * Checks if two Secp256k1 public keys are equal
-   */
-  equals(publicKey) {
-    return super.equals(publicKey);
-  }
-  /**
-   * Return the byte array representation of the Secp256k1 public key
-   */
-  toRawBytes() {
-    return this.data;
-  }
-  /**
-   * Return the Haneul address associated with this Secp256k1 public key
-   */
-  flag() {
-    return SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
-  }
-  /**
-   * 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 !== "Secp256k1") {
-        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 secp256k1.verify(
-      secp256k1.Signature.fromCompact(bytes),
-      sha256(message),
-      this.toRawBytes()
-    );
-  }
-}
-Secp256k1PublicKey.SIZE = SECP256K1_PUBLIC_KEY_SIZE;
-export {
-  Secp256k1PublicKey
-};
-//# sourceMappingURL=publickey.js.map

package/dist/esm/keypairs/secp256k1/publickey.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/keypairs/secp256k1/publickey.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport {\n\tbytesEqual,\n\tparseSerializedKeypairSignature,\n\tPublicKey,\n} from '../../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';\n\nconst SECP256K1_PUBLIC_KEY_SIZE = 33;\n\n/**\n * A Secp256k1 public key\n */\nexport class Secp256k1PublicKey extends PublicKey {\n\tstatic SIZE = SECP256K1_PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new Secp256k1PublicKey object\n\t * @param value secp256k1 public key as buffer or base-64 encoded string\n\t */\n\tconstructor(value: PublicKeyInitData) {\n\t\tsuper();\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.data = fromBase64(value);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.data = value as Uint8Array<ArrayBuffer>;\n\t\t} else {\n\t\t\tthis.data = Uint8Array.from(value);\n\t\t}\n\n\t\tif (this.data.length !== SECP256K1_PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if two Secp256k1 public keys are equal\n\t */\n\toverride equals(publicKey: Secp256k1PublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the Secp256k1 public key\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.data;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Secp256k1 public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['Secp256k1'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tlet bytes;\n\t\tif (typeof signature === 'string') {\n\t\t\tconst parsed = parseSerializedKeypairSignature(signature);\n\t\t\tif (parsed.signatureScheme !== 'Secp256k1') {\n\t\t\t\tthrow new Error('Invalid signature scheme');\n\t\t\t}\n\n\t\t\tif (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {\n\t\t\t\tthrow new Error('Signature does not match public key');\n\t\t\t}\n\n\t\t\tbytes = parsed.signature;\n\t\t} else {\n\t\t\tbytes = signature;\n\t\t}\n\n\t\treturn secp256k1.verify(\n\t\t\tsecp256k1.Signature.fromCompact(bytes),\n\t\t\tsha256(message),\n\t\t\tthis.toRawBytes(),\n\t\t);\n\t}\n}\n"],
-  "mappings": "AAGA,SAAS,kBAAkB;AAC3B,SAAS,iBAAiB;AAC1B,SAAS,cAAc;AAEvB;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,OACM;AAEP,SAAS,gCAAgC;AAEzC,MAAM,4BAA4B;AAK3B,MAAM,2BAA2B,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjD,YAAY,OAA0B;AACrC,UAAM;AAEN,QAAI,OAAO,UAAU,UAAU;AAC9B,WAAK,OAAO,WAAW,KAAK;AAAA,IAC7B,WAAW,iBAAiB,YAAY;AACvC,WAAK,OAAO;AAAA,IACb,OAAO;AACN,WAAK,OAAO,WAAW,KAAK,KAAK;AAAA,IAClC;AAEA,QAAI,KAAK,KAAK,WAAW,2BAA2B;AACnD,YAAM,IAAI;AAAA,QACT,sCAAsC,yBAAyB,eAAe,KAAK,KAAK,MAAM;AAAA,MAC/F;AAAA,IACD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKS,OAAO,WAAwC;AACvD,WAAO,MAAM,OAAO,SAAS;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKA,aAAsC;AACrC,WAAO,KAAK;AAAA,EACb;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe;AACd,WAAO,yBAAyB,WAAW;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OAAO,SAAqB,WAAkD;AACnF,QAAI;AACJ,QAAI,OAAO,cAAc,UAAU;AAClC,YAAM,SAAS,gCAAgC,SAAS;AACxD,UAAI,OAAO,oBAAoB,aAAa;AAC3C,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC3C;AAEA,UAAI,CAAC,WAAW,KAAK,WAAW,GAAG,OAAO,SAAS,GAAG;AACrD,cAAM,IAAI,MAAM,qCAAqC;AAAA,MACtD;AAEA,cAAQ,OAAO;AAAA,IAChB,OAAO;AACN,cAAQ;AAAA,IACT;AAEA,WAAO,UAAU;AAAA,MAChB,UAAU,UAAU,YAAY,KAAK;AAAA,MACrC,OAAO,OAAO;AAAA,MACd,KAAK,WAAW;AAAA,IACjB;AAAA,EACD;AACD;AAzEa,mBACL,OAAO;",
-  "names": []
-}

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

@@ -1,2 +0,0 @@
-export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, type Secp256r1KeypairData, } from './keypair.js';
-export { Secp256r1PublicKey } from './publickey.js';

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

@@ -1,11 +0,0 @@
-import {
-  DEFAULT_SECP256R1_DERIVATION_PATH,
-  Secp256r1Keypair
-} from "./keypair.js";
-import { Secp256r1PublicKey } from "./publickey.js";
-export {
-  DEFAULT_SECP256R1_DERIVATION_PATH,
-  Secp256r1Keypair,
-  Secp256r1PublicKey
-};
-//# sourceMappingURL=index.js.map

package/dist/esm/keypairs/secp256r1/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/keypairs/secp256r1/index.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n\tDEFAULT_SECP256R1_DERIVATION_PATH,\n\tSecp256r1Keypair,\n\ttype Secp256r1KeypairData,\n} from './keypair.js';\nexport { Secp256r1PublicKey } from './publickey.js';\n"],
-  "mappings": "AAGA;AAAA,EACC;AAAA,EACA;AAAA,OAEM;AACP,SAAS,0BAA0B;",
-  "names": []
-}

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

@@ -1,73 +0,0 @@
-import { Keypair } from '../../cryptography/keypair.js';
-import type { PublicKey } from '../../cryptography/publickey.js';
-import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
-export declare const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
-/**
- * Secp256r1 Keypair data
- */
-export interface Secp256r1KeypairData {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-}
-/**
- * An Secp256r1 Keypair used for signing transactions.
- */
-export declare class Secp256r1Keypair extends Keypair {
-    private keypair;
-    /**
-     * Create a new keypair instance.
-     * Generate random keypair if no {@link Secp256r1Keypair} is provided.
-     *
-     * @param keypair Secp256r1 keypair
-     */
-    constructor(keypair?: Secp256r1KeypairData);
-    /**
-     * Get the key scheme of the keypair Secp256r1
-     */
-    getKeyScheme(): SignatureScheme;
-    /**
-     * Generate a new random keypair
-     */
-    static generate(): Secp256r1Keypair;
-    /**
-     * Create a keypair from a raw secret key byte array.
-     *
-     * This method should only be used to recreate a keypair from a previously
-     * generated secret key. Generating keypairs from a random seed should be done
-     * with the {@link Keypair.fromSeed} method.
-     *
-     * @throws error if the provided secret key is invalid and validation is not skipped.
-     *
-     * @param secretKey secret key byte array or Bech32 secret key string
-     * @param options: skip secret key validation
-     */
-    static fromSecretKey(secretKey: Uint8Array | string, options?: {
-        skipValidation?: boolean;
-    }): Secp256r1Keypair;
-    /**
-     * Generate a keypair from a 32 byte seed.
-     *
-     * @param seed seed byte array
-     */
-    static fromSeed(seed: Uint8Array): Secp256r1Keypair;
-    /**
-     * The public key for this keypair
-     */
-    getPublicKey(): PublicKey;
-    /**
-     * The Bech32 secret key string for this Secp256r1 keypair
-     */
-    getSecretKey(): string;
-    /**
-     * Return the signature for the provided data.
-     */
-    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * Derive Secp256r1 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/74'/784'/0'/0/0, otherwise the path must
-     * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
-     */
-    static deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair;
-}

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

@@ -1,124 +0,0 @@
-import { secp256r1 } from "@noble/curves/p256";
-import { blake2b } from "@noble/hashes/blake2b";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
-import { HDKey } from "@scure/bip32";
-import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from "../../cryptography/keypair.js";
-import { isValidBIP32Path, mnemonicToSeed } from "../../cryptography/mnemonics.js";
-import { Secp256r1PublicKey } from "./publickey.js";
-const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
-class Secp256r1Keypair extends Keypair {
-  /**
-   * Create a new keypair instance.
-   * Generate random keypair if no {@link Secp256r1Keypair} is provided.
-   *
-   * @param keypair Secp256r1 keypair
-   */
-  constructor(keypair) {
-    super();
-    if (keypair) {
-      this.keypair = keypair;
-    } else {
-      const secretKey = secp256r1.utils.randomPrivateKey();
-      const publicKey = secp256r1.getPublicKey(secretKey, true);
-      this.keypair = { publicKey, secretKey };
-    }
-  }
-  /**
-   * Get the key scheme of the keypair Secp256r1
-   */
-  getKeyScheme() {
-    return "Secp256r1";
-  }
-  /**
-   * Generate a new random keypair
-   */
-  static generate() {
-    return new Secp256r1Keypair();
-  }
-  /**
-   * Create a keypair from a raw secret key byte array.
-   *
-   * This method should only be used to recreate a keypair from a previously
-   * generated secret key. Generating keypairs from a random seed should be done
-   * with the {@link Keypair.fromSeed} method.
-   *
-   * @throws error if the provided secret key is invalid and validation is not skipped.
-   *
-   * @param secretKey secret key byte array or Bech32 secret key string
-   * @param options: skip secret key validation
-   */
-  static fromSecretKey(secretKey, options) {
-    if (typeof secretKey === "string") {
-      const decoded = decodeHaneulPrivateKey(secretKey);
-      if (decoded.schema !== "Secp256r1") {
-        throw new Error(`Expected a Secp256r1 keypair, got ${decoded.schema}`);
-      }
-      return this.fromSecretKey(decoded.secretKey, options);
-    }
-    const publicKey = secp256r1.getPublicKey(secretKey, true);
-    if (!options || !options.skipValidation) {
-      const encoder = new TextEncoder();
-      const signData = encoder.encode("sui validation");
-      const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-      const signature = secp256r1.sign(msgHash, secretKey, { lowS: true });
-      if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {
-        throw new Error("Provided secretKey is invalid");
-      }
-    }
-    return new Secp256r1Keypair({ publicKey, secretKey });
-  }
-  /**
-   * Generate a keypair from a 32 byte seed.
-   *
-   * @param seed seed byte array
-   */
-  static fromSeed(seed) {
-    const publicKey = secp256r1.getPublicKey(seed, true);
-    return new Secp256r1Keypair({ publicKey, secretKey: seed });
-  }
-  /**
-   * The public key for this keypair
-   */
-  getPublicKey() {
-    return new Secp256r1PublicKey(this.keypair.publicKey);
-  }
-  /**
-   * The Bech32 secret key string for this Secp256r1 keypair
-   */
-  getSecretKey() {
-    return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-  }
-  /**
-   * Return the signature for the provided data.
-   */
-  async sign(data) {
-    const msgHash = sha256(data);
-    const sig = secp256r1.sign(msgHash, this.keypair.secretKey, {
-      lowS: true
-    });
-    return sig.toCompactRawBytes();
-  }
-  /**
-   * Derive Secp256r1 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/74'/784'/0'/0/0, otherwise the path must
-   * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
-   */
-  static deriveKeypair(mnemonics, path) {
-    if (path == null) {
-      path = DEFAULT_SECP256R1_DERIVATION_PATH;
-    }
-    if (!isValidBIP32Path(path)) {
-      throw new Error("Invalid derivation path");
-    }
-    const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
-    return Secp256r1Keypair.fromSecretKey(privateKey);
-  }
-}
-export {
-  DEFAULT_SECP256R1_DERIVATION_PATH,
-  Secp256r1Keypair
-};
-//# sourceMappingURL=keypair.js.map

package/dist/esm/keypairs/secp256r1/keypair.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/keypairs/secp256r1/keypair.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { secp256r1 } from '@noble/curves/p256';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { bytesToHex } from '@noble/hashes/utils';\nimport { HDKey } from '@scure/bip32';\n\nimport { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';\nimport { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';\nimport type { PublicKey } from '../../cryptography/publickey.js';\nimport type { SignatureScheme } from '../../cryptography/signature-scheme.js';\nimport { Secp256r1PublicKey } from './publickey.js';\n\nexport const DEFAULT_SECP256R1_DERIVATION_PATH = \"m/74'/784'/0'/0/0\";\n\n/**\n * Secp256r1 Keypair data\n */\nexport interface Secp256r1KeypairData {\n\tpublicKey: Uint8Array;\n\tsecretKey: Uint8Array;\n}\n\n/**\n * An Secp256r1 Keypair used for signing transactions.\n */\nexport class Secp256r1Keypair extends Keypair {\n\tprivate keypair: Secp256r1KeypairData;\n\n\t/**\n\t * Create a new keypair instance.\n\t * Generate random keypair if no {@link Secp256r1Keypair} is provided.\n\t *\n\t * @param keypair Secp256r1 keypair\n\t */\n\tconstructor(keypair?: Secp256r1KeypairData) {\n\t\tsuper();\n\t\tif (keypair) {\n\t\t\tthis.keypair = keypair;\n\t\t} else {\n\t\t\tconst secretKey: Uint8Array = secp256r1.utils.randomPrivateKey();\n\t\t\tconst publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);\n\n\t\t\tthis.keypair = { publicKey, secretKey };\n\t\t}\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair Secp256r1\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'Secp256r1';\n\t}\n\n\t/**\n\t * Generate a new random keypair\n\t */\n\tstatic generate(): Secp256r1Keypair {\n\t\treturn new Secp256r1Keypair();\n\t}\n\n\t/**\n\t * Create a keypair from a raw secret key byte array.\n\t *\n\t * This method should only be used to recreate a keypair from a previously\n\t * generated secret key. Generating keypairs from a random seed should be done\n\t * with the {@link Keypair.fromSeed} method.\n\t *\n\t * @throws error if the provided secret key is invalid and validation is not skipped.\n\t *\n\t * @param secretKey secret key byte array or Bech32 secret key string\n\t * @param options: skip secret key validation\n\t */\n\n\tstatic fromSecretKey(\n\t\tsecretKey: Uint8Array | string,\n\t\toptions?: { skipValidation?: boolean },\n\t): Secp256r1Keypair {\n\t\tif (typeof secretKey === 'string') {\n\t\t\tconst decoded = decodeHaneulPrivateKey(secretKey);\n\n\t\t\tif (decoded.schema !== 'Secp256r1') {\n\t\t\t\tthrow new Error(`Expected a Secp256r1 keypair, got ${decoded.schema}`);\n\t\t\t}\n\n\t\t\treturn this.fromSecretKey(decoded.secretKey, options);\n\t\t}\n\n\t\tconst publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);\n\t\tif (!options || !options.skipValidation) {\n\t\t\tconst encoder = new TextEncoder();\n\t\t\tconst signData = encoder.encode('sui validation');\n\t\t\tconst msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));\n\t\t\tconst signature = secp256r1.sign(msgHash, secretKey, { lowS: true });\n\t\t\tif (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {\n\t\t\t\tthrow new Error('Provided secretKey is invalid');\n\t\t\t}\n\t\t}\n\t\treturn new Secp256r1Keypair({ publicKey, secretKey });\n\t}\n\n\t/**\n\t * Generate a keypair from a 32 byte seed.\n\t *\n\t * @param seed seed byte array\n\t */\n\tstatic fromSeed(seed: Uint8Array): Secp256r1Keypair {\n\t\tconst publicKey = secp256r1.getPublicKey(seed, true);\n\t\treturn new Secp256r1Keypair({ publicKey, secretKey: seed });\n\t}\n\n\t/**\n\t * The public key for this keypair\n\t */\n\tgetPublicKey(): PublicKey {\n\t\treturn new Secp256r1PublicKey(this.keypair.publicKey);\n\t}\n\n\t/**\n\t * The Bech32 secret key string for this Secp256r1 keypair\n\t */\n\tgetSecretKey(): string {\n\t\treturn encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());\n\t}\n\n\t/**\n\t * Return the signature for the provided data.\n\t */\n\tasync sign(data: Uint8Array) {\n\t\tconst msgHash = sha256(data);\n\t\tconst sig = secp256r1.sign(msgHash, this.keypair.secretKey, {\n\t\t\tlowS: true,\n\t\t});\n\t\treturn sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;\n\t}\n\n\t/**\n\t * Derive Secp256r1 keypair from mnemonics and path. The mnemonics must be normalized\n\t * and validated against the english wordlist.\n\t *\n\t * If path is none, it will default to m/74'/784'/0'/0/0, otherwise the path must\n\t * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.\n\t */\n\tstatic deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_SECP256R1_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidBIP32Path(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\t// We use HDKey which is hardcoded to use Secp256k1 but since we only need the 32 bytes for the private key it's okay to use here as well.\n\t\tconst privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;\n\t\treturn Secp256r1Keypair.fromSecretKey(privateKey!);\n\t}\n}\n"],
-  "mappings": "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",
-  "names": []
-}

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

@@ -1,30 +0,0 @@
-import { PublicKey } from '../../cryptography/publickey.js';
-import type { PublicKeyInitData } from '../../cryptography/publickey.js';
-/**
- * A Secp256r1 public key
- */
-export declare class Secp256r1PublicKey extends PublicKey {
-    static SIZE: number;
-    private data;
-    /**
-     * Create a new Secp256r1PublicKey object
-     * @param value secp256r1 public key as buffer or base-64 encoded string
-     */
-    constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two Secp256r1 public keys are equal
-     */
-    equals(publicKey: Secp256r1PublicKey): boolean;
-    /**
-     * Return the byte array representation of the Secp256r1 public key
-     */
-    toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Haneul address associated with this Secp256r1 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/secp256r1/publickey.js

@@ -1,74 +0,0 @@
-import { fromBase64 } from "@haneullabs/bcs";
-import { secp256r1 } from "@noble/curves/p256";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesEqual, PublicKey } from "../../cryptography/publickey.js";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
-import { parseSerializedSignature } from "../../cryptography/signature.js";
-const SECP256R1_PUBLIC_KEY_SIZE = 33;
-class Secp256r1PublicKey extends PublicKey {
-  /**
-   * Create a new Secp256r1PublicKey object
-   * @param value secp256r1 public key as buffer or base-64 encoded string
-   */
-  constructor(value) {
-    super();
-    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 !== SECP256R1_PUBLIC_KEY_SIZE) {
-      throw new Error(
-        `Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
-      );
-    }
-  }
-  /**
-   * Checks if two Secp256r1 public keys are equal
-   */
-  equals(publicKey) {
-    return super.equals(publicKey);
-  }
-  /**
-   * Return the byte array representation of the Secp256r1 public key
-   */
-  toRawBytes() {
-    return this.data;
-  }
-  /**
-   * Return the Haneul address associated with this Secp256r1 public key
-   */
-  flag() {
-    return SIGNATURE_SCHEME_TO_FLAG["Secp256r1"];
-  }
-  /**
-   * Verifies that the signature is valid for for the provided message
-   */
-  async verify(message, signature) {
-    let bytes;
-    if (typeof signature === "string") {
-      const parsed = parseSerializedSignature(signature);
-      if (parsed.signatureScheme !== "Secp256r1") {
-        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 secp256r1.verify(
-      secp256r1.Signature.fromCompact(bytes),
-      sha256(message),
-      this.toRawBytes()
-    );
-  }
-}
-Secp256r1PublicKey.SIZE = SECP256R1_PUBLIC_KEY_SIZE;
-export {
-  Secp256r1PublicKey
-};
-//# sourceMappingURL=publickey.js.map

package/dist/esm/keypairs/secp256r1/publickey.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/keypairs/secp256r1/publickey.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\nimport { secp256r1 } from '@noble/curves/p256';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { bytesEqual, PublicKey } from '../../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';\nimport { parseSerializedSignature } from '../../cryptography/signature.js';\n\nconst SECP256R1_PUBLIC_KEY_SIZE = 33;\n\n/**\n * A Secp256r1 public key\n */\nexport class Secp256r1PublicKey extends PublicKey {\n\tstatic SIZE = SECP256R1_PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new Secp256r1PublicKey object\n\t * @param value secp256r1 public key as buffer or base-64 encoded string\n\t */\n\tconstructor(value: PublicKeyInitData) {\n\t\tsuper();\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.data = fromBase64(value);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.data = value as Uint8Array<ArrayBuffer>;\n\t\t} else {\n\t\t\tthis.data = Uint8Array.from(value);\n\t\t}\n\n\t\tif (this.data.length !== SECP256R1_PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if two Secp256r1 public keys are equal\n\t */\n\toverride equals(publicKey: Secp256r1PublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the Secp256r1 public key\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.data;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Secp256r1 public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['Secp256r1'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tlet bytes;\n\t\tif (typeof signature === 'string') {\n\t\t\tconst parsed = parseSerializedSignature(signature);\n\t\t\tif (parsed.signatureScheme !== 'Secp256r1') {\n\t\t\t\tthrow new Error('Invalid signature scheme');\n\t\t\t}\n\n\t\t\tif (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {\n\t\t\t\tthrow new Error('Signature does not match public key');\n\t\t\t}\n\n\t\t\tbytes = parsed.signature;\n\t\t} else {\n\t\t\tbytes = signature;\n\t\t}\n\n\t\treturn secp256r1.verify(\n\t\t\tsecp256r1.Signature.fromCompact(bytes),\n\t\t\tsha256(message),\n\t\t\tthis.toRawBytes(),\n\t\t);\n\t}\n}\n"],
-  "mappings": "AAGA,SAAS,kBAAkB;AAC3B,SAAS,iBAAiB;AAC1B,SAAS,cAAc;AAEvB,SAAS,YAAY,iBAAiB;AAEtC,SAAS,gCAAgC;AACzC,SAAS,gCAAgC;AAEzC,MAAM,4BAA4B;AAK3B,MAAM,2BAA2B,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjD,YAAY,OAA0B;AACrC,UAAM;AAEN,QAAI,OAAO,UAAU,UAAU;AAC9B,WAAK,OAAO,WAAW,KAAK;AAAA,IAC7B,WAAW,iBAAiB,YAAY;AACvC,WAAK,OAAO;AAAA,IACb,OAAO;AACN,WAAK,OAAO,WAAW,KAAK,KAAK;AAAA,IAClC;AAEA,QAAI,KAAK,KAAK,WAAW,2BAA2B;AACnD,YAAM,IAAI;AAAA,QACT,sCAAsC,yBAAyB,eAAe,KAAK,KAAK,MAAM;AAAA,MAC/F;AAAA,IACD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKS,OAAO,WAAwC;AACvD,WAAO,MAAM,OAAO,SAAS;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKA,aAAsC;AACrC,WAAO,KAAK;AAAA,EACb;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe;AACd,WAAO,yBAAyB,WAAW;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OAAO,SAAqB,WAAkD;AACnF,QAAI;AACJ,QAAI,OAAO,cAAc,UAAU;AAClC,YAAM,SAAS,yBAAyB,SAAS;AACjD,UAAI,OAAO,oBAAoB,aAAa;AAC3C,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC3C;AAEA,UAAI,CAAC,WAAW,KAAK,WAAW,GAAG,OAAO,SAAS,GAAG;AACrD,cAAM,IAAI,MAAM,qCAAqC;AAAA,MACtD;AAEA,cAAQ,OAAO;AAAA,IAChB,OAAO;AACN,cAAQ;AAAA,IACT;AAEA,WAAO,UAAU;AAAA,MAChB,UAAU,UAAU,YAAY,KAAK;AAAA,MACrC,OAAO,OAAO;AAAA,MACd,KAAK,WAAW;AAAA,IACjB;AAAA,EACD;AACD;AAzEa,mBACL,OAAO;",
-  "names": []
-}

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

@@ -1,2 +0,0 @@
-export { MultiSigSigner } from './signer.js';
-export { type MultiSigStruct, MultiSigPublicKey, parsePartialSignatures } from './publickey.js';

package/dist/esm/multisig/index.js

@@ -1,8 +0,0 @@
-import { MultiSigSigner } from "./signer.js";
-import { MultiSigPublicKey, parsePartialSignatures } from "./publickey.js";
-export {
-  MultiSigPublicKey,
-  MultiSigSigner,
-  parsePartialSignatures
-};
-//# sourceMappingURL=index.js.map