@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/esm/cryptography/keypair.d.ts

@@ -1,72 +0,0 @@
-import type { IntentScope } from './intent.js';
-import type { PublicKey } from './publickey.js';
-import type { SignatureScheme } from './signature-scheme.js';
-import type { Transaction } from '../transactions/Transaction.js';
-import type { ClientWithCoreApi, Experimental_HaneulClientTypes } from '../experimental/index.js';
-export declare const PRIVATE_KEY_SIZE = 32;
-export declare const LEGACY_PRIVATE_KEY_SIZE = 64;
-export declare const SUI_PRIVATE_KEY_PREFIX = "suiprivkey";
-export type ParsedKeypair = {
-    scheme: SignatureScheme;
-    /** @deprecated use `scheme` instead */
-    schema: SignatureScheme;
-    secretKey: Uint8Array;
-};
-export interface SignatureWithBytes {
-    bytes: string;
-    signature: string;
-}
-export interface SignAndExecuteOptions {
-    transaction: Transaction;
-    client: ClientWithCoreApi;
-}
-/**
- * TODO: Document
- */
-export declare abstract class Signer {
-    abstract sign(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
-     * it ensures that a signed message is tied to a specific purpose and domain separator is provided
-     */
-    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
-    /**
-     * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
-     */
-    signTransaction(bytes: Uint8Array): Promise<SignatureWithBytes>;
-    /**
-     * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
-     */
-    signPersonalMessage(bytes: Uint8Array): Promise<{
-        bytes: string;
-        signature: string;
-    }>;
-    signAndExecuteTransaction({ transaction, client, }: SignAndExecuteOptions): Promise<Omit<Experimental_HaneulClientTypes.TransactionResponse, 'balanceChanges'>>;
-    toHaneulAddress(): string;
-    /**
-     * Get the key scheme of the keypair: Secp256k1 or ED25519
-     */
-    abstract getKeyScheme(): SignatureScheme;
-    /**
-     * The public key for this keypair
-     */
-    abstract getPublicKey(): PublicKey;
-}
-export declare abstract class Keypair extends Signer {
-    /**
-     * This returns the Bech32 secret key string for this keypair.
-     */
-    abstract getSecretKey(): string;
-}
-/**
- * This returns an ParsedKeypair object based by validating the
- * 33-byte Bech32 encoded string starting with `suiprivkey`, and
- * parse out the signature scheme and the private key in bytes.
- */
-export declare function decodeHaneulPrivateKey(value: string): ParsedKeypair;
-/**
- * This returns a Bech32 encoded string starting with `suiprivkey`,
- * encoding 33-byte `flag || bytes` for the given the 32-byte private
- * key and its signature scheme.
- */
-export declare function encodeHaneulPrivateKey(bytes: Uint8Array, scheme: SignatureScheme): string;

package/dist/esm/cryptography/keypair.js

@@ -1,98 +0,0 @@
-import { bcs, toBase64 } from "@haneullabs/bcs";
-import { blake2b } from "@noble/hashes/blake2b";
-import { bech32 } from "@scure/base";
-import { messageWithIntent } from "./intent.js";
-import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from "./signature-scheme.js";
-import { toSerializedSignature } from "./signature.js";
-const PRIVATE_KEY_SIZE = 32;
-const LEGACY_PRIVATE_KEY_SIZE = 64;
-const SUI_PRIVATE_KEY_PREFIX = "suiprivkey";
-class Signer {
-  /**
-   * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
-   * it ensures that a signed message is tied to a specific purpose and domain separator is provided
-   */
-  async signWithIntent(bytes, intent) {
-    const intentMessage = messageWithIntent(intent, bytes);
-    const digest = blake2b(intentMessage, { dkLen: 32 });
-    const signature = toSerializedSignature({
-      signature: await this.sign(digest),
-      signatureScheme: this.getKeyScheme(),
-      publicKey: this.getPublicKey()
-    });
-    return {
-      signature,
-      bytes: toBase64(bytes)
-    };
-  }
-  /**
-   * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
-   */
-  async signTransaction(bytes) {
-    return this.signWithIntent(bytes, "TransactionData");
-  }
-  /**
-   * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
-   */
-  async signPersonalMessage(bytes) {
-    const { signature } = await this.signWithIntent(
-      bcs.byteVector().serialize(bytes).toBytes(),
-      "PersonalMessage"
-    );
-    return {
-      bytes: toBase64(bytes),
-      signature
-    };
-  }
-  async signAndExecuteTransaction({
-    transaction,
-    client
-  }) {
-    const bytes = await transaction.build({ client });
-    const { signature } = await this.signTransaction(bytes);
-    const response = await client.core.executeTransaction({
-      transaction: bytes,
-      signatures: [signature]
-    });
-    return response.transaction;
-  }
-  toHaneulAddress() {
-    return this.getPublicKey().toHaneulAddress();
-  }
-}
-class Keypair extends Signer {
-}
-function decodeHaneulPrivateKey(value) {
-  const { prefix, words } = bech32.decode(value);
-  if (prefix !== SUI_PRIVATE_KEY_PREFIX) {
-    throw new Error("invalid private key prefix");
-  }
-  const extendedSecretKey = new Uint8Array(bech32.fromWords(words));
-  const secretKey = extendedSecretKey.slice(1);
-  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0]];
-  return {
-    scheme: signatureScheme,
-    schema: signatureScheme,
-    secretKey
-  };
-}
-function encodeHaneulPrivateKey(bytes, scheme) {
-  if (bytes.length !== PRIVATE_KEY_SIZE) {
-    throw new Error("Invalid bytes length");
-  }
-  const flag = SIGNATURE_SCHEME_TO_FLAG[scheme];
-  const privKeyBytes = new Uint8Array(bytes.length + 1);
-  privKeyBytes.set([flag]);
-  privKeyBytes.set(bytes, 1);
-  return bech32.encode(SUI_PRIVATE_KEY_PREFIX, bech32.toWords(privKeyBytes));
-}
-export {
-  Keypair,
-  LEGACY_PRIVATE_KEY_SIZE,
-  PRIVATE_KEY_SIZE,
-  SUI_PRIVATE_KEY_PREFIX,
-  Signer,
-  decodeHaneulPrivateKey,
-  encodeHaneulPrivateKey
-};
-//# sourceMappingURL=keypair.js.map

package/dist/esm/cryptography/keypair.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/cryptography/keypair.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs, toBase64 } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { bech32 } from '@scure/base';\n\nimport type { IntentScope } from './intent.js';\nimport { messageWithIntent } from './intent.js';\nimport type { PublicKey } from './publickey.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from './signature-scheme.js';\nimport type { SignatureScheme } from './signature-scheme.js';\nimport { toSerializedSignature } from './signature.js';\nimport type { Transaction } from '../transactions/Transaction.js';\nimport type { ClientWithCoreApi, Experimental_HaneulClientTypes } from '../experimental/index.js';\n\nexport const PRIVATE_KEY_SIZE = 32;\nexport const LEGACY_PRIVATE_KEY_SIZE = 64;\nexport const SUI_PRIVATE_KEY_PREFIX = 'suiprivkey';\n\nexport type ParsedKeypair = {\n\tscheme: SignatureScheme;\n\t/** @deprecated use `scheme` instead */\n\tschema: SignatureScheme;\n\tsecretKey: Uint8Array;\n};\n\nexport interface SignatureWithBytes {\n\tbytes: string;\n\tsignature: string;\n}\n\nexport interface SignAndExecuteOptions {\n\ttransaction: Transaction;\n\tclient: ClientWithCoreApi;\n}\n\n/**\n * TODO: Document\n */\nexport abstract class Signer {\n\tabstract sign(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;\n\t/**\n\t * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,\n\t * it ensures that a signed message is tied to a specific purpose and domain separator is provided\n\t */\n\tasync signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes> {\n\t\tconst intentMessage = messageWithIntent(intent, bytes);\n\t\tconst digest = blake2b(intentMessage, { dkLen: 32 });\n\n\t\tconst signature = toSerializedSignature({\n\t\t\tsignature: await this.sign(digest),\n\t\t\tsignatureScheme: this.getKeyScheme(),\n\t\t\tpublicKey: this.getPublicKey(),\n\t\t});\n\n\t\treturn {\n\t\t\tsignature,\n\t\t\tbytes: toBase64(bytes),\n\t\t};\n\t}\n\t/**\n\t * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope\n\t */\n\tasync signTransaction(bytes: Uint8Array) {\n\t\treturn this.signWithIntent(bytes, 'TransactionData');\n\t}\n\t/**\n\t * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope\n\t */\n\tasync signPersonalMessage(bytes: Uint8Array) {\n\t\tconst { signature } = await this.signWithIntent(\n\t\t\tbcs.byteVector().serialize(bytes).toBytes(),\n\t\t\t'PersonalMessage',\n\t\t);\n\n\t\treturn {\n\t\t\tbytes: toBase64(bytes),\n\t\t\tsignature,\n\t\t};\n\t}\n\n\tasync signAndExecuteTransaction({\n\t\ttransaction,\n\t\tclient,\n\t}: SignAndExecuteOptions): Promise<\n\t\tOmit<Experimental_HaneulClientTypes.TransactionResponse, 'balanceChanges'>\n\t> {\n\t\tconst bytes = await transaction.build({ client });\n\t\tconst { signature } = await this.signTransaction(bytes);\n\t\tconst response = await client.core.executeTransaction({\n\t\t\ttransaction: bytes,\n\t\t\tsignatures: [signature],\n\t\t});\n\n\t\treturn response.transaction;\n\t}\n\n\ttoHaneulAddress(): string {\n\t\treturn this.getPublicKey().toHaneulAddress();\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair: Secp256k1 or ED25519\n\t */\n\tabstract getKeyScheme(): SignatureScheme;\n\n\t/**\n\t * The public key for this keypair\n\t */\n\tabstract getPublicKey(): PublicKey;\n}\n\nexport abstract class Keypair extends Signer {\n\t/**\n\t * This returns the Bech32 secret key string for this keypair.\n\t */\n\tabstract getSecretKey(): string;\n}\n\n/**\n * This returns an ParsedKeypair object based by validating the\n * 33-byte Bech32 encoded string starting with `suiprivkey`, and\n * parse out the signature scheme and the private key in bytes.\n */\nexport function decodeHaneulPrivateKey(value: string): ParsedKeypair {\n\tconst { prefix, words } = bech32.decode(value as `${string}1${string}`);\n\tif (prefix !== SUI_PRIVATE_KEY_PREFIX) {\n\t\tthrow new Error('invalid private key prefix');\n\t}\n\tconst extendedSecretKey = new Uint8Array(bech32.fromWords(words));\n\tconst secretKey = extendedSecretKey.slice(1);\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\treturn {\n\t\tscheme: signatureScheme,\n\t\tschema: signatureScheme,\n\t\tsecretKey: secretKey,\n\t};\n}\n\n/**\n * This returns a Bech32 encoded string starting with `suiprivkey`,\n * encoding 33-byte `flag || bytes` for the given the 32-byte private\n * key and its signature scheme.\n */\nexport function encodeHaneulPrivateKey(bytes: Uint8Array, scheme: SignatureScheme): string {\n\tif (bytes.length !== PRIVATE_KEY_SIZE) {\n\t\tthrow new Error('Invalid bytes length');\n\t}\n\tconst flag = SIGNATURE_SCHEME_TO_FLAG[scheme];\n\tconst privKeyBytes = new Uint8Array(bytes.length + 1);\n\tprivKeyBytes.set([flag]);\n\tprivKeyBytes.set(bytes, 1);\n\treturn bech32.encode(SUI_PRIVATE_KEY_PREFIX, bech32.toWords(privKeyBytes));\n}\n"],
-  "mappings": "AAGA,SAAS,KAAK,gBAAgB;AAC9B,SAAS,eAAe;AACxB,SAAS,cAAc;AAGvB,SAAS,yBAAyB;AAElC,SAAS,0BAA0B,gCAAgC;AAEnE,SAAS,6BAA6B;AAI/B,MAAM,mBAAmB;AACzB,MAAM,0BAA0B;AAChC,MAAM,yBAAyB;AAsB/B,MAAe,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAM5B,MAAM,eAAe,OAAmB,QAAkD;AACzF,UAAM,gBAAgB,kBAAkB,QAAQ,KAAK;AACrD,UAAM,SAAS,QAAQ,eAAe,EAAE,OAAO,GAAG,CAAC;AAEnD,UAAM,YAAY,sBAAsB;AAAA,MACvC,WAAW,MAAM,KAAK,KAAK,MAAM;AAAA,MACjC,iBAAiB,KAAK,aAAa;AAAA,MACnC,WAAW,KAAK,aAAa;AAAA,IAC9B,CAAC;AAED,WAAO;AAAA,MACN;AAAA,MACA,OAAO,SAAS,KAAK;AAAA,IACtB;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAIA,MAAM,gBAAgB,OAAmB;AACxC,WAAO,KAAK,eAAe,OAAO,iBAAiB;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA,EAIA,MAAM,oBAAoB,OAAmB;AAC5C,UAAM,EAAE,UAAU,IAAI,MAAM,KAAK;AAAA,MAChC,IAAI,WAAW,EAAE,UAAU,KAAK,EAAE,QAAQ;AAAA,MAC1C;AAAA,IACD;AAEA,WAAO;AAAA,MACN,OAAO,SAAS,KAAK;AAAA,MACrB;AAAA,IACD;AAAA,EACD;AAAA,EAEA,MAAM,0BAA0B;AAAA,IAC/B;AAAA,IACA;AAAA,EACD,GAEE;AACD,UAAM,QAAQ,MAAM,YAAY,MAAM,EAAE,OAAO,CAAC;AAChD,UAAM,EAAE,UAAU,IAAI,MAAM,KAAK,gBAAgB,KAAK;AACtD,UAAM,WAAW,MAAM,OAAO,KAAK,mBAAmB;AAAA,MACrD,aAAa;AAAA,MACb,YAAY,CAAC,SAAS;AAAA,IACvB,CAAC;AAED,WAAO,SAAS;AAAA,EACjB;AAAA,EAEA,kBAA0B;AACzB,WAAO,KAAK,aAAa,EAAE,gBAAgB;AAAA,EAC5C;AAWD;AAEO,MAAe,gBAAgB,OAAO;AAK7C;AAOO,SAAS,uBAAuB,OAA8B;AACpE,QAAM,EAAE,QAAQ,MAAM,IAAI,OAAO,OAAO,KAA8B;AACtE,MAAI,WAAW,wBAAwB;AACtC,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAC7C;AACA,QAAM,oBAAoB,IAAI,WAAW,OAAO,UAAU,KAAK,CAAC;AAChE,QAAM,YAAY,kBAAkB,MAAM,CAAC;AAC3C,QAAM,kBACL,yBAAyB,kBAAkB,CAAC,CAA0C;AAEvF,SAAO;AAAA,IACN,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR;AAAA,EACD;AACD;AAOO,SAAS,uBAAuB,OAAmB,QAAiC;AAC1F,MAAI,MAAM,WAAW,kBAAkB;AACtC,UAAM,IAAI,MAAM,sBAAsB;AAAA,EACvC;AACA,QAAM,OAAO,yBAAyB,MAAM;AAC5C,QAAM,eAAe,IAAI,WAAW,MAAM,SAAS,CAAC;AACpD,eAAa,IAAI,CAAC,IAAI,CAAC;AACvB,eAAa,IAAI,OAAO,CAAC;AACzB,SAAO,OAAO,OAAO,wBAAwB,OAAO,QAAQ,YAAY,CAAC;AAC1E;",
-  "names": []
-}

package/dist/esm/cryptography/mnemonics.d.ts

@@ -1,27 +0,0 @@
-/**
- * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
- *
- * @param path path string (e.g. `m/44'/784'/0'/0'/0'`).
- */
-export declare function isValidHardenedPath(path: string): boolean;
-/**
- * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
- * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
- *
- * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
- *
- * @param path path string (e.g. `m/54'/784'/0'/0/0`).
- */
-export declare function isValidBIP32Path(path: string): boolean;
-/**
- * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
- *
- * @param mnemonics 12 words string split by spaces.
- */
-export declare function mnemonicToSeed(mnemonics: string): Uint8Array;
-/**
- * Derive the seed in hex format from a 12-word mnemonic string.
- *
- * @param mnemonics 12 words string split by spaces.
- */
-export declare function mnemonicToSeedHex(mnemonics: string): string;

package/dist/esm/cryptography/mnemonics.js

@@ -1,27 +0,0 @@
-import { toHex } from "@haneullabs/bcs";
-import { mnemonicToSeedSync as bip39MnemonicToSeedSync } from "@scure/bip39";
-function isValidHardenedPath(path) {
-  if (!new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$").test(path)) {
-    return false;
-  }
-  return true;
-}
-function isValidBIP32Path(path) {
-  if (!new RegExp("^m\\/(54|74)'\\/784'\\/[0-9]+'\\/[0-9]+\\/[0-9]+$").test(path)) {
-    return false;
-  }
-  return true;
-}
-function mnemonicToSeed(mnemonics) {
-  return bip39MnemonicToSeedSync(mnemonics, "");
-}
-function mnemonicToSeedHex(mnemonics) {
-  return toHex(mnemonicToSeed(mnemonics));
-}
-export {
-  isValidBIP32Path,
-  isValidHardenedPath,
-  mnemonicToSeed,
-  mnemonicToSeedHex
-};
-//# sourceMappingURL=mnemonics.js.map

package/dist/esm/cryptography/mnemonics.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/cryptography/mnemonics.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { toHex } from '@haneullabs/bcs';\nimport { mnemonicToSeedSync as bip39MnemonicToSeedSync } from '@scure/bip39';\n\n/**\n * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.\n *\n * @param path path string (e.g. `m/44'/784'/0'/0'/0'`).\n */\nexport function isValidHardenedPath(path: string): boolean {\n\tif (!new RegExp(\"^m\\\\/44'\\\\/784'\\\\/[0-9]+'\\\\/[0-9]+'\\\\/[0-9]+'+$\").test(path)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\n/**\n * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}\n * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.\n *\n * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.\n *\n * @param path path string (e.g. `m/54'/784'/0'/0/0`).\n */\nexport function isValidBIP32Path(path: string): boolean {\n\tif (!new RegExp(\"^m\\\\/(54|74)'\\\\/784'\\\\/[0-9]+'\\\\/[0-9]+\\\\/[0-9]+$\").test(path)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\n/**\n * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.\n *\n * @param mnemonics 12 words string split by spaces.\n */\nexport function mnemonicToSeed(mnemonics: string): Uint8Array {\n\treturn bip39MnemonicToSeedSync(mnemonics, '');\n}\n\n/**\n * Derive the seed in hex format from a 12-word mnemonic string.\n *\n * @param mnemonics 12 words string split by spaces.\n */\nexport function mnemonicToSeedHex(mnemonics: string): string {\n\treturn toHex(mnemonicToSeed(mnemonics));\n}\n"],
-  "mappings": "AAEA,SAAS,aAAa;AACtB,SAAS,sBAAsB,+BAA+B;AAOvD,SAAS,oBAAoB,MAAuB;AAC1D,MAAI,CAAC,IAAI,OAAO,iDAAiD,EAAE,KAAK,IAAI,GAAG;AAC9E,WAAO;AAAA,EACR;AACA,SAAO;AACR;AAUO,SAAS,iBAAiB,MAAuB;AACvD,MAAI,CAAC,IAAI,OAAO,mDAAmD,EAAE,KAAK,IAAI,GAAG;AAChF,WAAO;AAAA,EACR;AACA,SAAO;AACR;AAOO,SAAS,eAAe,WAA+B;AAC7D,SAAO,wBAAwB,WAAW,EAAE;AAC7C;AAOO,SAAS,kBAAkB,WAA2B;AAC5D,SAAO,MAAM,eAAe,SAAS,CAAC;AACvC;",
-  "names": []
-}

package/dist/esm/cryptography/publickey.d.ts

@@ -1,67 +0,0 @@
-import type { IntentScope } from './intent.js';
-/**
- * Value to be converted into public key.
- */
-export type PublicKeyInitData = string | Uint8Array | Iterable<number>;
-export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
-/**
- * A public key
- */
-export declare abstract class PublicKey {
-    /**
-     * Checks if two public keys are equal
-     */
-    equals(publicKey: PublicKey): boolean;
-    /**
-     * Return the base-64 representation of the public key
-     */
-    toBase64(): string;
-    toString(): never;
-    /**
-     * Return the Haneul representation of the public key encoded in
-     * base-64. A Sui public key is formed by the concatenation
-     * of the scheme flag with the raw bytes of the public key
-     */
-    toHaneulPublicKey(): string;
-    verifyWithIntent(bytes: Uint8Array, signature: Uint8Array | string, intent: IntentScope): Promise<boolean>;
-    /**
-     * Verifies that the signature is valid for for the provided PersonalMessage
-     */
-    verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-    /**
-     * Verifies that the signature is valid for for the provided Transaction
-     */
-    verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-    /**
-     * Verifies that the public key is associated with the provided address
-     */
-    verifyAddress(address: string): boolean;
-    /**
-     * Returns the bytes representation of the public key
-     * prefixed with the signature scheme flag
-     */
-    toHaneulBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Haneul address associated with this Ed25519 public key
-     */
-    toHaneulAddress(): string;
-    /**
-     * Return the byte array representation of the public key
-     */
-    abstract toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return signature scheme flag of the public key
-     */
-    abstract flag(): number;
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
-    abstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-}
-export declare function parseSerializedKeypairSignature(serializedSignature: string): {
-    serializedSignature: string;
-    signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";
-    signature: Uint8Array<ArrayBuffer>;
-    publicKey: Uint8Array<ArrayBuffer>;
-    bytes: Uint8Array<ArrayBuffer>;
-};

package/dist/esm/cryptography/publickey.js

@@ -1,120 +0,0 @@
-import { fromBase64, toBase64 } from "@haneullabs/bcs";
-import { blake2b } from "@noble/hashes/blake2b";
-import { bytesToHex } from "@noble/hashes/utils";
-import { bcs } from "../bcs/index.js";
-import { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from "../utils/haneul-types.js";
-import { messageWithIntent } from "./intent.js";
-import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_SIZE } from "./signature-scheme.js";
-function bytesEqual(a, b) {
-  if (a === b) return true;
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-class PublicKey {
-  /**
-   * Checks if two public keys are equal
-   */
-  equals(publicKey) {
-    return bytesEqual(this.toRawBytes(), publicKey.toRawBytes());
-  }
-  /**
-   * Return the base-64 representation of the public key
-   */
-  toBase64() {
-    return toBase64(this.toRawBytes());
-  }
-  toString() {
-    throw new Error(
-      "`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead."
-    );
-  }
-  /**
-   * Return the Haneul representation of the public key encoded in
-   * base-64. A Sui public key is formed by the concatenation
-   * of the scheme flag with the raw bytes of the public key
-   */
-  toHaneulPublicKey() {
-    const bytes = this.toHaneulBytes();
-    return toBase64(bytes);
-  }
-  verifyWithIntent(bytes, signature, intent) {
-    const intentMessage = messageWithIntent(intent, bytes);
-    const digest = blake2b(intentMessage, { dkLen: 32 });
-    return this.verify(digest, signature);
-  }
-  /**
-   * Verifies that the signature is valid for for the provided PersonalMessage
-   */
-  verifyPersonalMessage(message, signature) {
-    return this.verifyWithIntent(
-      bcs.byteVector().serialize(message).toBytes(),
-      signature,
-      "PersonalMessage"
-    );
-  }
-  /**
-   * Verifies that the signature is valid for for the provided Transaction
-   */
-  verifyTransaction(transaction, signature) {
-    return this.verifyWithIntent(transaction, signature, "TransactionData");
-  }
-  /**
-   * Verifies that the public key is associated with the provided address
-   */
-  verifyAddress(address) {
-    return this.toHaneulAddress() === address;
-  }
-  /**
-   * Returns the bytes representation of the public key
-   * prefixed with the signature scheme flag
-   */
-  toHaneulBytes() {
-    const rawBytes = this.toRawBytes();
-    const suiBytes = new Uint8Array(rawBytes.length + 1);
-    suiBytes.set([this.flag()]);
-    suiBytes.set(rawBytes, 1);
-    return suiBytes;
-  }
-  /**
-   * Return the Haneul address associated with this Ed25519 public key
-   */
-  toHaneulAddress() {
-    return normalizeHaneulAddress(
-      bytesToHex(blake2b(this.toHaneulBytes(), { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2)
-    );
-  }
-}
-function parseSerializedKeypairSignature(serializedSignature) {
-  const bytes = fromBase64(serializedSignature);
-  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
-  switch (signatureScheme) {
-    case "ED25519":
-    case "Secp256k1":
-    case "Secp256r1":
-      const size = SIGNATURE_SCHEME_TO_SIZE[signatureScheme];
-      const signature = bytes.slice(1, bytes.length - size);
-      const publicKey = bytes.slice(1 + signature.length);
-      return {
-        serializedSignature,
-        signatureScheme,
-        signature,
-        publicKey,
-        bytes
-      };
-    default:
-      throw new Error("Unsupported signature scheme");
-  }
-}
-export {
-  PublicKey,
-  bytesEqual,
-  parseSerializedKeypairSignature
-};
-//# sourceMappingURL=publickey.js.map

package/dist/esm/cryptography/publickey.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/cryptography/publickey.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nimport { bcs } from '../bcs/index.js';\nimport { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/haneul-types.js';\nimport type { IntentScope } from './intent.js';\nimport { messageWithIntent } from './intent.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_SIZE } from './signature-scheme.js';\n\n/**\n * Value to be converted into public key.\n */\nexport type PublicKeyInitData = string | Uint8Array | Iterable<number>;\n\nexport function bytesEqual(a: Uint8Array, b: Uint8Array) {\n\tif (a === b) return true;\n\n\tif (a.length !== b.length) {\n\t\treturn false;\n\t}\n\n\tfor (let i = 0; i < a.length; i++) {\n\t\tif (a[i] !== b[i]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\n/**\n * A public key\n */\nexport abstract class PublicKey {\n\t/**\n\t * Checks if two public keys are equal\n\t */\n\tequals(publicKey: PublicKey) {\n\t\treturn bytesEqual(this.toRawBytes(), publicKey.toRawBytes());\n\t}\n\n\t/**\n\t * Return the base-64 representation of the public key\n\t */\n\ttoBase64() {\n\t\treturn toBase64(this.toRawBytes());\n\t}\n\n\ttoString(): never {\n\t\tthrow new Error(\n\t\t\t'`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead.',\n\t\t);\n\t}\n\n\t/**\n\t * Return the Haneul representation of the public key encoded in\n\t * base-64. A Sui public key is formed by the concatenation\n\t * of the scheme flag with the raw bytes of the public key\n\t */\n\ttoHaneulPublicKey(): string {\n\t\tconst bytes = this.toHaneulBytes();\n\t\treturn toBase64(bytes);\n\t}\n\n\tverifyWithIntent(\n\t\tbytes: Uint8Array,\n\t\tsignature: Uint8Array | string,\n\t\tintent: IntentScope,\n\t): Promise<boolean> {\n\t\tconst intentMessage = messageWithIntent(intent, bytes);\n\t\tconst digest = blake2b(intentMessage, { dkLen: 32 });\n\n\t\treturn this.verify(digest, signature);\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided PersonalMessage\n\t */\n\tverifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\treturn this.verifyWithIntent(\n\t\t\tbcs.byteVector().serialize(message).toBytes(),\n\t\t\tsignature,\n\t\t\t'PersonalMessage',\n\t\t);\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided Transaction\n\t */\n\tverifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\treturn this.verifyWithIntent(transaction, signature, 'TransactionData');\n\t}\n\n\t/**\n\t * Verifies that the public key is associated with the provided address\n\t */\n\tverifyAddress(address: string): boolean {\n\t\treturn this.toHaneulAddress() === address;\n\t}\n\n\t/**\n\t * Returns the bytes representation of the public key\n\t * prefixed with the signature scheme flag\n\t */\n\ttoHaneulBytes(): Uint8Array<ArrayBuffer> {\n\t\tconst rawBytes = this.toRawBytes();\n\t\tconst suiBytes = new Uint8Array(rawBytes.length + 1);\n\t\tsuiBytes.set([this.flag()]);\n\t\tsuiBytes.set(rawBytes, 1);\n\n\t\treturn suiBytes;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Ed25519 public key\n\t */\n\ttoHaneulAddress(): string {\n\t\t// Each hex char represents half a byte, hence hex address doubles the length\n\t\treturn normalizeHaneulAddress(\n\t\t\tbytesToHex(blake2b(this.toHaneulBytes(), { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),\n\t\t);\n\t}\n\n\t/**\n\t * Return the byte array representation of the public key\n\t */\n\tabstract toRawBytes(): Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Return signature scheme flag of the public key\n\t */\n\tabstract flag(): number;\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tabstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;\n}\n\nexport function parseSerializedKeypairSignature(serializedSignature: string) {\n\tconst bytes = fromBase64(serializedSignature);\n\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[bytes[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\tswitch (signatureScheme) {\n\t\tcase 'ED25519':\n\t\tcase 'Secp256k1':\n\t\tcase 'Secp256r1':\n\t\t\tconst size =\n\t\t\t\tSIGNATURE_SCHEME_TO_SIZE[signatureScheme as keyof typeof SIGNATURE_SCHEME_TO_SIZE];\n\t\t\tconst signature = bytes.slice(1, bytes.length - size);\n\t\t\tconst publicKey = bytes.slice(1 + signature.length);\n\n\t\t\treturn {\n\t\t\t\tserializedSignature,\n\t\t\t\tsignatureScheme,\n\t\t\t\tsignature,\n\t\t\t\tpublicKey,\n\t\t\t\tbytes,\n\t\t\t};\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported signature scheme');\n\t}\n}\n"],
-  "mappings": "AAGA,SAAS,YAAY,gBAAgB;AACrC,SAAS,eAAe;AACxB,SAAS,kBAAkB;AAE3B,SAAS,WAAW;AACpB,SAAS,wBAAwB,6BAA6B;AAE9D,SAAS,yBAAyB;AAClC,SAAS,0BAA0B,gCAAgC;AAO5D,SAAS,WAAW,GAAe,GAAe;AACxD,MAAI,MAAM,EAAG,QAAO;AAEpB,MAAI,EAAE,WAAW,EAAE,QAAQ;AAC1B,WAAO;AAAA,EACR;AAEA,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AAClC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG;AAClB,aAAO;AAAA,IACR;AAAA,EACD;AACA,SAAO;AACR;AAKO,MAAe,UAAU;AAAA;AAAA;AAAA;AAAA,EAI/B,OAAO,WAAsB;AAC5B,WAAO,WAAW,KAAK,WAAW,GAAG,UAAU,WAAW,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW;AACV,WAAO,SAAS,KAAK,WAAW,CAAC;AAAA,EAClC;AAAA,EAEA,WAAkB;AACjB,UAAM,IAAI;AAAA,MACT;AAAA,IACD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,oBAA4B;AAC3B,UAAM,QAAQ,KAAK,cAAc;AACjC,WAAO,SAAS,KAAK;AAAA,EACtB;AAAA,EAEA,iBACC,OACA,WACA,QACmB;AACnB,UAAM,gBAAgB,kBAAkB,QAAQ,KAAK;AACrD,UAAM,SAAS,QAAQ,eAAe,EAAE,OAAO,GAAG,CAAC;AAEnD,WAAO,KAAK,OAAO,QAAQ,SAAS;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKA,sBAAsB,SAAqB,WAAkD;AAC5F,WAAO,KAAK;AAAA,MACX,IAAI,WAAW,EAAE,UAAU,OAAO,EAAE,QAAQ;AAAA,MAC5C;AAAA,MACA;AAAA,IACD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKA,kBAAkB,aAAyB,WAAkD;AAC5F,WAAO,KAAK,iBAAiB,aAAa,WAAW,iBAAiB;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,SAA0B;AACvC,WAAO,KAAK,gBAAgB,MAAM;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,gBAAyC;AACxC,UAAM,WAAW,KAAK,WAAW;AACjC,UAAM,WAAW,IAAI,WAAW,SAAS,SAAS,CAAC;AACnD,aAAS,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC;AAC1B,aAAS,IAAI,UAAU,CAAC;AAExB,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA,EAKA,kBAA0B;AAEzB,WAAO;AAAA,MACN,WAAW,QAAQ,KAAK,cAAc,GAAG,EAAE,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,wBAAwB,CAAC;AAAA,IAC5F;AAAA,EACD;AAgBD;AAEO,SAAS,gCAAgC,qBAA6B;AAC5E,QAAM,QAAQ,WAAW,mBAAmB;AAE5C,QAAM,kBACL,yBAAyB,MAAM,CAAC,CAA0C;AAE3E,UAAQ,iBAAiB;AAAA,IACxB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACJ,YAAM,OACL,yBAAyB,eAAwD;AAClF,YAAM,YAAY,MAAM,MAAM,GAAG,MAAM,SAAS,IAAI;AACpD,YAAM,YAAY,MAAM,MAAM,IAAI,UAAU,MAAM;AAElD,aAAO;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACD;AAAA,IACD;AACC,YAAM,IAAI,MAAM,8BAA8B;AAAA,EAChD;AACD;",
-  "names": []
-}

package/dist/esm/cryptography/signature-scheme.d.ts

@@ -1,24 +0,0 @@
-export declare const SIGNATURE_SCHEME_TO_FLAG: {
-    readonly ED25519: 0;
-    readonly Secp256k1: 1;
-    readonly Secp256r1: 2;
-    readonly MultiSig: 3;
-    readonly ZkLogin: 5;
-    readonly Passkey: 6;
-};
-export declare const SIGNATURE_SCHEME_TO_SIZE: {
-    ED25519: number;
-    Secp256k1: number;
-    Secp256r1: number;
-    Passkey: number;
-};
-export declare const SIGNATURE_FLAG_TO_SCHEME: {
-    readonly 0: "ED25519";
-    readonly 1: "Secp256k1";
-    readonly 2: "Secp256r1";
-    readonly 3: "MultiSig";
-    readonly 5: "ZkLogin";
-    readonly 6: "Passkey";
-};
-export type SignatureScheme = 'ED25519' | 'Secp256k1' | 'Secp256r1' | 'MultiSig' | 'ZkLogin' | 'Passkey';
-export type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;

package/dist/esm/cryptography/signature-scheme.js

@@ -1,28 +0,0 @@
-const SIGNATURE_SCHEME_TO_FLAG = {
-  ED25519: 0,
-  Secp256k1: 1,
-  Secp256r1: 2,
-  MultiSig: 3,
-  ZkLogin: 5,
-  Passkey: 6
-};
-const SIGNATURE_SCHEME_TO_SIZE = {
-  ED25519: 32,
-  Secp256k1: 33,
-  Secp256r1: 33,
-  Passkey: 33
-};
-const SIGNATURE_FLAG_TO_SCHEME = {
-  0: "ED25519",
-  1: "Secp256k1",
-  2: "Secp256r1",
-  3: "MultiSig",
-  5: "ZkLogin",
-  6: "Passkey"
-};
-export {
-  SIGNATURE_FLAG_TO_SCHEME,
-  SIGNATURE_SCHEME_TO_FLAG,
-  SIGNATURE_SCHEME_TO_SIZE
-};
-//# sourceMappingURL=signature-scheme.js.map

package/dist/esm/cryptography/signature-scheme.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/cryptography/signature-scheme.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport const SIGNATURE_SCHEME_TO_FLAG = {\n\tED25519: 0x00,\n\tSecp256k1: 0x01,\n\tSecp256r1: 0x02,\n\tMultiSig: 0x03,\n\tZkLogin: 0x05,\n\tPasskey: 0x06,\n} as const;\n\nexport const SIGNATURE_SCHEME_TO_SIZE = {\n\tED25519: 32,\n\tSecp256k1: 33,\n\tSecp256r1: 33,\n\tPasskey: 33,\n};\n\nexport const SIGNATURE_FLAG_TO_SCHEME = {\n\t0x00: 'ED25519',\n\t0x01: 'Secp256k1',\n\t0x02: 'Secp256r1',\n\t0x03: 'MultiSig',\n\t0x05: 'ZkLogin',\n\t0x06: 'Passkey',\n} as const;\n\nexport type SignatureScheme =\n\t| 'ED25519'\n\t| 'Secp256k1'\n\t| 'Secp256r1'\n\t| 'MultiSig'\n\t| 'ZkLogin'\n\t| 'Passkey';\n\nexport type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;\n"],
-  "mappings": "AAGO,MAAM,2BAA2B;AAAA,EACvC,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,UAAU;AAAA,EACV,SAAS;AAAA,EACT,SAAS;AACV;AAEO,MAAM,2BAA2B;AAAA,EACvC,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,SAAS;AACV;AAEO,MAAM,2BAA2B;AAAA,EACvC,GAAM;AAAA,EACN,GAAM;AAAA,EACN,GAAM;AAAA,EACN,GAAM;AAAA,EACN,GAAM;AAAA,EACN,GAAM;AACP;",
-  "names": []
-}

package/dist/esm/cryptography/signature.d.ts

@@ -1,65 +0,0 @@
-import type { MultiSigStruct } from '../multisig/publickey.js';
-import type { PublicKey } from './publickey.js';
-import type { SignatureScheme } from './signature-scheme.js';
-/**
- * Pair of signature and corresponding public key
- */
-export type SerializeSignatureInput = {
-    signatureScheme: SignatureScheme;
-    /** Base64-encoded signature */
-    signature: Uint8Array;
-    /** Base64-encoded public key */
-    publicKey?: PublicKey;
-};
-/**
- * Takes in a signature, its associated signing scheme and a public key, then serializes this data
- */
-export declare function toSerializedSignature({ signature, signatureScheme, publicKey, }: SerializeSignatureInput): string;
-/**
- * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
- */
-export declare function parseSerializedSignature(serializedSignature: string): {
-    serializedSignature: string;
-    signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";
-    signature: Uint8Array<ArrayBuffer>;
-    publicKey: Uint8Array<ArrayBuffer>;
-    bytes: Uint8Array<ArrayBuffer>;
-} | {
-    signatureScheme: "Passkey";
-    serializedSignature: string;
-    signature: Uint8Array<ArrayBufferLike>;
-    authenticatorData: Uint8Array<ArrayBufferLike>;
-    clientDataJson: string;
-    userSignature: Uint8Array<ArrayBuffer>;
-    publicKey: Uint8Array<ArrayBuffer>;
-} | {
-    serializedSignature: string;
-    signatureScheme: "ZkLogin";
-    zkLogin: {
-        inputs: {
-            proofPoints: {
-                a: string[];
-                b: string[][];
-                c: string[];
-            };
-            issBase64Details: {
-                value: string;
-                indexMod4: number;
-            };
-            headerBase64: string;
-            addressSeed: string;
-        };
-        maxEpoch: string;
-        userSignature: Uint8Array<ArrayBufferLike>;
-        iss: string;
-        addressSeed: bigint;
-    };
-    signature: Uint8Array<ArrayBufferLike>;
-    publicKey: Uint8Array<ArrayBuffer>;
-} | {
-    serializedSignature: string;
-    signatureScheme: "MultiSig";
-    multisig: MultiSigStruct;
-    bytes: Uint8Array<ArrayBuffer>;
-    signature: undefined;
-};

package/dist/esm/cryptography/signature.js

@@ -1,51 +0,0 @@
-import { fromBase64, toBase64 } from "@haneullabs/bcs";
-import { bcs } from "../bcs/index.js";
-import { parseSerializedPasskeySignature } from "../keypairs/passkey/publickey.js";
-import { parseSerializedZkLoginSignature } from "../zklogin/publickey.js";
-import { parseSerializedKeypairSignature } from "./publickey.js";
-import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from "./signature-scheme.js";
-function toSerializedSignature({
-  signature,
-  signatureScheme,
-  publicKey
-}) {
-  if (!publicKey) {
-    throw new Error("`publicKey` is required");
-  }
-  const pubKeyBytes = publicKey.toRawBytes();
-  const serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);
-  serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
-  serializedSignature.set(signature, 1);
-  serializedSignature.set(pubKeyBytes, 1 + signature.length);
-  return toBase64(serializedSignature);
-}
-function parseSerializedSignature(serializedSignature) {
-  const bytes = fromBase64(serializedSignature);
-  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
-  switch (signatureScheme) {
-    case "Passkey":
-      return parseSerializedPasskeySignature(serializedSignature);
-    case "MultiSig":
-      const multisig = bcs.MultiSig.parse(bytes.slice(1));
-      return {
-        serializedSignature,
-        signatureScheme,
-        multisig,
-        bytes,
-        signature: void 0
-      };
-    case "ZkLogin":
-      return parseSerializedZkLoginSignature(serializedSignature);
-    case "ED25519":
-    case "Secp256k1":
-    case "Secp256r1":
-      return parseSerializedKeypairSignature(serializedSignature);
-    default:
-      throw new Error("Unsupported signature scheme");
-  }
-}
-export {
-  parseSerializedSignature,
-  toSerializedSignature
-};
-//# sourceMappingURL=signature.js.map

package/dist/esm/cryptography/signature.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/cryptography/signature.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\n\nimport { bcs } from '../bcs/index.js';\nimport { parseSerializedPasskeySignature } from '../keypairs/passkey/publickey.js';\nimport type { MultiSigStruct } from '../multisig/publickey.js';\nimport { parseSerializedZkLoginSignature } from '../zklogin/publickey.js';\nimport { parseSerializedKeypairSignature } from './publickey.js';\nimport type { PublicKey } from './publickey.js';\nimport type { SignatureScheme } from './signature-scheme.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from './signature-scheme.js';\n\n/**\n * Pair of signature and corresponding public key\n */\nexport type SerializeSignatureInput = {\n\tsignatureScheme: SignatureScheme;\n\t/** Base64-encoded signature */\n\tsignature: Uint8Array;\n\t/** Base64-encoded public key */\n\tpublicKey?: PublicKey;\n};\n\n/**\n * Takes in a signature, its associated signing scheme and a public key, then serializes this data\n */\nexport function toSerializedSignature({\n\tsignature,\n\tsignatureScheme,\n\tpublicKey,\n}: SerializeSignatureInput): string {\n\tif (!publicKey) {\n\t\tthrow new Error('`publicKey` is required');\n\t}\n\n\tconst pubKeyBytes = publicKey.toRawBytes();\n\tconst serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);\n\tserializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);\n\tserializedSignature.set(signature, 1);\n\tserializedSignature.set(pubKeyBytes, 1 + signature.length);\n\treturn toBase64(serializedSignature);\n}\n\n/**\n * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key\n */\nexport function parseSerializedSignature(serializedSignature: string) {\n\tconst bytes = fromBase64(serializedSignature);\n\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[bytes[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\tswitch (signatureScheme) {\n\t\tcase 'Passkey':\n\t\t\treturn parseSerializedPasskeySignature(serializedSignature);\n\t\tcase 'MultiSig':\n\t\t\tconst multisig: MultiSigStruct = bcs.MultiSig.parse(bytes.slice(1));\n\t\t\treturn {\n\t\t\t\tserializedSignature,\n\t\t\t\tsignatureScheme,\n\t\t\t\tmultisig,\n\t\t\t\tbytes,\n\t\t\t\tsignature: undefined,\n\t\t\t};\n\t\tcase 'ZkLogin':\n\t\t\treturn parseSerializedZkLoginSignature(serializedSignature);\n\t\tcase 'ED25519':\n\t\tcase 'Secp256k1':\n\t\tcase 'Secp256r1':\n\t\t\treturn parseSerializedKeypairSignature(serializedSignature);\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported signature scheme');\n\t}\n}\n"],
-  "mappings": "AAGA,SAAS,YAAY,gBAAgB;AAErC,SAAS,WAAW;AACpB,SAAS,uCAAuC;AAEhD,SAAS,uCAAuC;AAChD,SAAS,uCAAuC;AAGhD,SAAS,0BAA0B,gCAAgC;AAgB5D,SAAS,sBAAsB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACD,GAAoC;AACnC,MAAI,CAAC,WAAW;AACf,UAAM,IAAI,MAAM,yBAAyB;AAAA,EAC1C;AAEA,QAAM,cAAc,UAAU,WAAW;AACzC,QAAM,sBAAsB,IAAI,WAAW,IAAI,UAAU,SAAS,YAAY,MAAM;AACpF,sBAAoB,IAAI,CAAC,yBAAyB,eAAe,CAAC,CAAC;AACnE,sBAAoB,IAAI,WAAW,CAAC;AACpC,sBAAoB,IAAI,aAAa,IAAI,UAAU,MAAM;AACzD,SAAO,SAAS,mBAAmB;AACpC;AAKO,SAAS,yBAAyB,qBAA6B;AACrE,QAAM,QAAQ,WAAW,mBAAmB;AAE5C,QAAM,kBACL,yBAAyB,MAAM,CAAC,CAA0C;AAE3E,UAAQ,iBAAiB;AAAA,IACxB,KAAK;AACJ,aAAO,gCAAgC,mBAAmB;AAAA,IAC3D,KAAK;AACJ,YAAM,WAA2B,IAAI,SAAS,MAAM,MAAM,MAAM,CAAC,CAAC;AAClE,aAAO;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,WAAW;AAAA,MACZ;AAAA,IACD,KAAK;AACJ,aAAO,gCAAgC,mBAAmB;AAAA,IAC3D,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACJ,aAAO,gCAAgC,mBAAmB;AAAA,IAC3D;AACC,YAAM,IAAI,MAAM,8BAA8B;AAAA,EAChD;AACD;",
-  "names": []
-}