@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/crypto.d.ts

@@ -1,10 +1,6 @@
-/**
- * Cryptographic Utilities for Amadeus Protocol
- *
- * This module provides cryptographic functions for key generation and BLS12-381 operations
- * used by the Amadeus protocol.
- */
-import type { KeyPair } from './types';
+import { KeyPair } from "./types.js";
+
+//#region src/crypto.d.ts
 /**
  * Reduce a 64-byte seed to a 32-byte private key compatible with BLS12-381
  *
@@ -12,7 +8,7 @@ import type { KeyPair } from './types';
  * @returns 32-byte private key
  * @throws Error if input is not exactly 64 bytes
  */
-export declare function reduce512To256LE(bytes64: Uint8Array): Uint8Array;
+declare function reduce512To256LE(bytes64: Uint8Array): Uint8Array;
 /**
  * Derive a keypair from a 64-byte seed
  *
@@ -24,7 +20,7 @@ export declare function reduce512To256LE(bytes64: Uint8Array): Uint8Array;
  * const [pk, sk] = seed64ToKeypair(seed64)
  * ```
  */
-export declare function seed64ToKeypair(seed64: Uint8Array): [Uint8Array, Uint8Array];
+declare function seed64ToKeypair(seed64: Uint8Array): [Uint8Array, Uint8Array];
 /**
  * Get public key from a 64-byte seed
  *
@@ -36,7 +32,7 @@ export declare function seed64ToKeypair(seed64: Uint8Array): [Uint8Array, Uint8A
  * const publicKey = getPublicKey(seed64)
  * ```
  */
-export declare function getPublicKey(seed64: Uint8Array): Uint8Array;
+declare function getPublicKey(seed64: Uint8Array): Uint8Array;
 /**
  * Derive secret key and seed64 from a Base58 encoded seed
  *
@@ -49,9 +45,9 @@ export declare function getPublicKey(seed64: Uint8Array): Uint8Array;
  * const { sk, seed64 } = deriveSkAndSeed64FromBase58Seed(base58Seed)
  * ```
  */
-export declare function deriveSkAndSeed64FromBase58Seed(base58Seed64: string): {
-    sk: Uint8Array;
-    seed64: Uint8Array;
+declare function deriveSkAndSeed64FromBase58Seed(base58Seed64: string): {
+  sk: Uint8Array;
+  seed64: Uint8Array;
 };
 /**
  * Derive public key from a Base58 encoded seed
@@ -65,7 +61,7 @@ export declare function deriveSkAndSeed64FromBase58Seed(base58Seed64: string): {
  * const publicKey = derivePublicKeyFromSeedBase58(base58Seed)
  * ```
  */
-export declare function derivePublicKeyFromSeedBase58(base58Seed: string): string;
+declare function derivePublicKeyFromSeedBase58(base58Seed: string): string;
 /**
  * Generate a cryptographically secure random private key (64-byte seed)
  *
@@ -76,7 +72,7 @@ export declare function derivePublicKeyFromSeedBase58(base58Seed: string): strin
  * const seed = generatePrivateKey()
  * ```
  */
-export declare function generatePrivateKey(): Uint8Array;
+declare function generatePrivateKey(): Uint8Array;
 /**
  * Generate a new keypair
  *
@@ -89,5 +85,7 @@ export declare function generatePrivateKey(): Uint8Array;
  * console.log(keypair.privateKey)  // Base58 private key (seed)
  * ```
  */
-export declare function generateKeypair(): KeyPair;
+declare function generateKeypair(): KeyPair;
+//#endregion
+export { derivePublicKeyFromSeedBase58, deriveSkAndSeed64FromBase58Seed, generateKeypair, generatePrivateKey, getPublicKey, reduce512To256LE, seed64ToKeypair };
 //# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAMtC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAsBhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAI5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAG3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG;IACtE,EAAE,EAAE,UAAU,CAAA;IACd,MAAM,EAAE,UAAU,CAAA;CAClB,CAWA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAUxE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,CAI/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAQzC"}
+{"version":3,"file":"crypto.d.ts","names":[],"sources":["../src/crypto.ts"],"mappings":";;;;;;;;AA+DA;;iBAnCgB,gBAAA,CAAiB,OAAA,EAAS,UAAA,GAAa,UAAA;;;;;;;;;;;;iBAmCvC,eAAA,CAAgB,MAAA,EAAQ,UAAA,IAAc,UAAA,EAAY,UAAA;;;;;;;;;AAkClE;;;iBAjBgB,YAAA,CAAa,MAAA,EAAQ,UAAA,GAAa,UAAA;;;;;;;;AA6ClD;;;;;iBA5BgB,+BAAA,CAAgC,YAAA;EAC/C,EAAA,EAAI,UAAA;EACJ,MAAA,EAAQ,UAAA;AAAA;;AAsET;;;;;;;;;;;iBA5CgB,6BAAA,CAA8B,UAAA;;;;;;;;;;;iBA0B9B,kBAAA,CAAA,GAAsB,UAAA;;;;;;;;;;;;;iBAkBtB,eAAA,CAAA,GAAmB,OAAA"}

package/dist/crypto.js

@@ -1,156 +1,137 @@
+import "./constants.js";
+import { fromBase58, toBase58 } from "./encoding.js";
+import { bls12_381 } from "@noble/curves/bls12-381";
+//#region src/crypto.ts
 /**
- * Cryptographic Utilities for Amadeus Protocol
- *
- * This module provides cryptographic functions for key generation and BLS12-381 operations
- * used by the Amadeus protocol.
- */
-import { bls12_381 as bls } from '@noble/curves/bls12-381';
-import { AMADEUS_SEED_BYTE_LENGTH } from './constants';
-import { toBase58, fromBase58 } from './encoding';
-// Constant: BLS12-381 group order
-const BLS12_381_ORDER = BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001');
-// ============================================================================
-// BLS12-381 KEY OPERATIONS
-// ============================================================================
+* Cryptographic Utilities for Amadeus Protocol
+*
+* This module provides cryptographic functions for key generation and BLS12-381 operations
+* used by the Amadeus protocol.
+*/
+const BLS12_381_ORDER = BigInt("0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
 /**
- * Reduce a 64-byte seed to a 32-byte private key compatible with BLS12-381
- *
- * @param bytes64 - 64-byte seed
- * @returns 32-byte private key
- * @throws Error if input is not exactly 64 bytes
- */
-export function reduce512To256LE(bytes64) {
-    if (!(bytes64 instanceof Uint8Array) || bytes64.length !== AMADEUS_SEED_BYTE_LENGTH) {
-        throw new Error('Expected 64-byte Uint8Array');
-    }
-    // Convert 64 bytes LE -> BigInt
-    let x = BigInt(0);
-    for (let i = 0; i < AMADEUS_SEED_BYTE_LENGTH; i++) {
-        x += BigInt(bytes64[i]) << (BigInt(8) * BigInt(i));
-    }
-    // Reduce mod the group order
-    x = x % BLS12_381_ORDER;
-    // Convert to 32-byte BIG-ENDIAN
-    const out = new Uint8Array(32);
-    for (let i = 31; i >= 0; i--) {
-        out[i] = Number(x & BigInt(0xff));
-        x >>= BigInt(8);
-    }
-    return out;
+* Reduce a 64-byte seed to a 32-byte private key compatible with BLS12-381
+*
+* @param bytes64 - 64-byte seed
+* @returns 32-byte private key
+* @throws Error if input is not exactly 64 bytes
+*/
+function reduce512To256LE(bytes64) {
+	if (!(bytes64 instanceof Uint8Array) || bytes64.length !== 64) throw new Error("Expected 64-byte Uint8Array");
+	let x = BigInt(0);
+	for (let i = 0; i < 64; i++) x += BigInt(bytes64[i]) << BigInt(8) * BigInt(i);
+	x = x % BLS12_381_ORDER;
+	const out = new Uint8Array(32);
+	for (let i = 31; i >= 0; i--) {
+		out[i] = Number(x & BigInt(255));
+		x >>= BigInt(8);
+	}
+	return out;
 }
 /**
- * Derive a keypair from a 64-byte seed
- *
- * @param seed64 - 64-byte seed
- * @returns Tuple of [publicKey, privateKey] as Uint8Array
- *
- * @example
- * ```ts
- * const [pk, sk] = seed64ToKeypair(seed64)
- * ```
- */
-export function seed64ToKeypair(seed64) {
-    const sk = reduce512To256LE(seed64);
-    const pk = bls.getPublicKey(sk);
-    return [pk, sk];
+* Derive a keypair from a 64-byte seed
+*
+* @param seed64 - 64-byte seed
+* @returns Tuple of [publicKey, privateKey] as Uint8Array
+*
+* @example
+* ```ts
+* const [pk, sk] = seed64ToKeypair(seed64)
+* ```
+*/
+function seed64ToKeypair(seed64) {
+	const sk = reduce512To256LE(seed64);
+	return [bls12_381.getPublicKey(sk), sk];
 }
 /**
- * Get public key from a 64-byte seed
- *
- * @param seed64 - 64-byte seed
- * @returns Public key as Uint8Array
- *
- * @example
- * ```ts
- * const publicKey = getPublicKey(seed64)
- * ```
- */
-export function getPublicKey(seed64) {
-    const [pk] = seed64ToKeypair(seed64);
-    return pk;
+* Get public key from a 64-byte seed
+*
+* @param seed64 - 64-byte seed
+* @returns Public key as Uint8Array
+*
+* @example
+* ```ts
+* const publicKey = getPublicKey(seed64)
+* ```
+*/
+function getPublicKey(seed64) {
+	const [pk] = seed64ToKeypair(seed64);
+	return pk;
 }
 /**
- * Derive secret key and seed64 from a Base58 encoded seed
- *
- * @param base58Seed64 - Base58 encoded 64-byte seed
- * @returns Object containing sk (secret key) and seed64
- * @throws Error if the seed is invalid
- *
- * @example
- * ```ts
- * const { sk, seed64 } = deriveSkAndSeed64FromBase58Seed(base58Seed)
- * ```
- */
-export function deriveSkAndSeed64FromBase58Seed(base58Seed64) {
-    const seed64 = fromBase58(base58Seed64);
-    if (seed64.length !== AMADEUS_SEED_BYTE_LENGTH) {
-        throw new Error('Invalid base58Seed: Must be 64 bytes (512 bits) long.');
-    }
-    const sk = reduce512To256LE(seed64);
-    return {
-        sk,
-        seed64
-    };
+* Derive secret key and seed64 from a Base58 encoded seed
+*
+* @param base58Seed64 - Base58 encoded 64-byte seed
+* @returns Object containing sk (secret key) and seed64
+* @throws Error if the seed is invalid
+*
+* @example
+* ```ts
+* const { sk, seed64 } = deriveSkAndSeed64FromBase58Seed(base58Seed)
+* ```
+*/
+function deriveSkAndSeed64FromBase58Seed(base58Seed64) {
+	const seed64 = fromBase58(base58Seed64);
+	if (seed64.length !== 64) throw new Error("Invalid base58Seed: Must be 64 bytes (512 bits) long.");
+	return {
+		sk: reduce512To256LE(seed64),
+		seed64
+	};
 }
 /**
- * Derive public key from a Base58 encoded seed
- *
- * @param base58Seed - Base58 encoded 64-byte seed
- * @returns Base58 encoded public key
- * @throws Error if the seed is invalid
- *
- * @example
- * ```ts
- * const publicKey = derivePublicKeyFromSeedBase58(base58Seed)
- * ```
- */
-export function derivePublicKeyFromSeedBase58(base58Seed) {
-    if (!base58Seed) {
-        throw new Error('Invalid base58Seed: Must be a non-empty base58 string.');
-    }
-    const seed64 = fromBase58(base58Seed);
-    if (seed64.length !== AMADEUS_SEED_BYTE_LENGTH) {
-        throw new Error('Invalid base58Seed: Must be 64 bytes (512 bits) long.');
-    }
-    const publicKey = getPublicKey(seed64);
-    return toBase58(publicKey);
+* Derive public key from a Base58 encoded seed
+*
+* @param base58Seed - Base58 encoded 64-byte seed
+* @returns Base58 encoded public key
+* @throws Error if the seed is invalid
+*
+* @example
+* ```ts
+* const publicKey = derivePublicKeyFromSeedBase58(base58Seed)
+* ```
+*/
+function derivePublicKeyFromSeedBase58(base58Seed) {
+	if (!base58Seed) throw new Error("Invalid base58Seed: Must be a non-empty base58 string.");
+	const seed64 = fromBase58(base58Seed);
+	if (seed64.length !== 64) throw new Error("Invalid base58Seed: Must be 64 bytes (512 bits) long.");
+	return toBase58(getPublicKey(seed64));
 }
-// ============================================================================
-// KEY GENERATION
-// ============================================================================
 /**
- * Generate a cryptographically secure random private key (64-byte seed)
- *
- * @returns 64-byte seed as Uint8Array
- *
- * @example
- * ```ts
- * const seed = generatePrivateKey()
- * ```
- */
-export function generatePrivateKey() {
-    const seed = new Uint8Array(AMADEUS_SEED_BYTE_LENGTH);
-    crypto.getRandomValues(seed);
-    return seed;
+* Generate a cryptographically secure random private key (64-byte seed)
+*
+* @returns 64-byte seed as Uint8Array
+*
+* @example
+* ```ts
+* const seed = generatePrivateKey()
+* ```
+*/
+function generatePrivateKey() {
+	const seed = new Uint8Array(64);
+	crypto.getRandomValues(seed);
+	return seed;
 }
 /**
- * Generate a new keypair
- *
- * @returns KeyPair object with Base58 encoded publicKey and privateKey
- *
- * @example
- * ```ts
- * const keypair = generateKeypair()
- * console.log(keypair.publicKey)  // Base58 public key
- * console.log(keypair.privateKey)  // Base58 private key (seed)
- * ```
- */
-export function generateKeypair() {
-    const seed64 = generatePrivateKey();
-    const [pk] = seed64ToKeypair(seed64);
-    return {
-        publicKey: toBase58(pk),
-        privateKey: toBase58(seed64)
-    };
+* Generate a new keypair
+*
+* @returns KeyPair object with Base58 encoded publicKey and privateKey
+*
+* @example
+* ```ts
+* const keypair = generateKeypair()
+* console.log(keypair.publicKey)  // Base58 public key
+* console.log(keypair.privateKey)  // Base58 private key (seed)
+* ```
+*/
+function generateKeypair() {
+	const seed64 = generatePrivateKey();
+	const [pk] = seed64ToKeypair(seed64);
+	return {
+		publicKey: toBase58(pk),
+		privateKey: toBase58(seed64)
+	};
 }
+//#endregion
+export { derivePublicKeyFromSeedBase58, deriveSkAndSeed64FromBase58Seed, generateKeypair, generatePrivateKey, getPublicKey, reduce512To256LE, seed64ToKeypair };
+
 //# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"crypto.js","names":["bls"],"sources":["../src/crypto.ts"],"sourcesContent":["/**\n * Cryptographic Utilities for Amadeus Protocol\n *\n * This module provides cryptographic functions for key generation and BLS12-381 operations\n * used by the Amadeus protocol.\n */\n\nimport { bls12_381 as bls } from '@noble/curves/bls12-381'\n\nimport { AMADEUS_SEED_BYTE_LENGTH } from './constants'\nimport { toBase58, fromBase58 } from './encoding'\n\n// Constant: BLS12-381 group order\nconst BLS12_381_ORDER = BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001')\n\nimport type { KeyPair } from './types'\n\n// ============================================================================\n// BLS12-381 KEY OPERATIONS\n// ============================================================================\n\n/**\n * Reduce a 64-byte seed to a 32-byte private key compatible with BLS12-381\n *\n * @param bytes64 - 64-byte seed\n * @returns 32-byte private key\n * @throws Error if input is not exactly 64 bytes\n */\nexport function reduce512To256LE(bytes64: Uint8Array): Uint8Array {\n\tif (!(bytes64 instanceof Uint8Array) || bytes64.length !== AMADEUS_SEED_BYTE_LENGTH) {\n\t\tthrow new Error('Expected 64-byte Uint8Array')\n\t}\n\n\t// Convert 64 bytes LE -> BigInt\n\tlet x = BigInt(0)\n\tfor (let i = 0; i < AMADEUS_SEED_BYTE_LENGTH; i++) {\n\t\tx += BigInt(bytes64[i]) << (BigInt(8) * BigInt(i))\n\t}\n\n\t// Reduce mod the group order\n\tx = x % BLS12_381_ORDER\n\n\t// Convert to 32-byte BIG-ENDIAN\n\tconst out = new Uint8Array(32)\n\tfor (let i = 31; i >= 0; i--) {\n\t\tout[i] = Number(x & BigInt(0xff))\n\t\tx >>= BigInt(8)\n\t}\n\n\treturn out\n}\n\n/**\n * Derive a keypair from a 64-byte seed\n *\n * @param seed64 - 64-byte seed\n * @returns Tuple of [publicKey, privateKey] as Uint8Array\n *\n * @example\n * ```ts\n * const [pk, sk] = seed64ToKeypair(seed64)\n * ```\n */\nexport function seed64ToKeypair(seed64: Uint8Array): [Uint8Array, Uint8Array] {\n\tconst sk = reduce512To256LE(seed64)\n\tconst pk = bls.getPublicKey(sk)\n\treturn [pk, sk]\n}\n\n/**\n * Get public key from a 64-byte seed\n *\n * @param seed64 - 64-byte seed\n * @returns Public key as Uint8Array\n *\n * @example\n * ```ts\n * const publicKey = getPublicKey(seed64)\n * ```\n */\nexport function getPublicKey(seed64: Uint8Array): Uint8Array {\n\tconst [pk] = seed64ToKeypair(seed64)\n\treturn pk\n}\n\n/**\n * Derive secret key and seed64 from a Base58 encoded seed\n *\n * @param base58Seed64 - Base58 encoded 64-byte seed\n * @returns Object containing sk (secret key) and seed64\n * @throws Error if the seed is invalid\n *\n * @example\n * ```ts\n * const { sk, seed64 } = deriveSkAndSeed64FromBase58Seed(base58Seed)\n * ```\n */\nexport function deriveSkAndSeed64FromBase58Seed(base58Seed64: string): {\n\tsk: Uint8Array\n\tseed64: Uint8Array\n} {\n\tconst seed64 = fromBase58(base58Seed64)\n\tif (seed64.length !== AMADEUS_SEED_BYTE_LENGTH) {\n\t\tthrow new Error('Invalid base58Seed: Must be 64 bytes (512 bits) long.')\n\t}\n\tconst sk = reduce512To256LE(seed64)\n\n\treturn {\n\t\tsk,\n\t\tseed64\n\t}\n}\n\n/**\n * Derive public key from a Base58 encoded seed\n *\n * @param base58Seed - Base58 encoded 64-byte seed\n * @returns Base58 encoded public key\n * @throws Error if the seed is invalid\n *\n * @example\n * ```ts\n * const publicKey = derivePublicKeyFromSeedBase58(base58Seed)\n * ```\n */\nexport function derivePublicKeyFromSeedBase58(base58Seed: string): string {\n\tif (!base58Seed) {\n\t\tthrow new Error('Invalid base58Seed: Must be a non-empty base58 string.')\n\t}\n\tconst seed64 = fromBase58(base58Seed)\n\tif (seed64.length !== AMADEUS_SEED_BYTE_LENGTH) {\n\t\tthrow new Error('Invalid base58Seed: Must be 64 bytes (512 bits) long.')\n\t}\n\tconst publicKey = getPublicKey(seed64)\n\treturn toBase58(publicKey)\n}\n\n// ============================================================================\n// KEY GENERATION\n// ============================================================================\n\n/**\n * Generate a cryptographically secure random private key (64-byte seed)\n *\n * @returns 64-byte seed as Uint8Array\n *\n * @example\n * ```ts\n * const seed = generatePrivateKey()\n * ```\n */\nexport function generatePrivateKey(): Uint8Array {\n\tconst seed = new Uint8Array(AMADEUS_SEED_BYTE_LENGTH)\n\tcrypto.getRandomValues(seed)\n\treturn seed\n}\n\n/**\n * Generate a new keypair\n *\n * @returns KeyPair object with Base58 encoded publicKey and privateKey\n *\n * @example\n * ```ts\n * const keypair = generateKeypair()\n * console.log(keypair.publicKey)  // Base58 public key\n * console.log(keypair.privateKey)  // Base58 private key (seed)\n * ```\n */\nexport function generateKeypair(): KeyPair {\n\tconst seed64 = generatePrivateKey()\n\tconst [pk] = seed64ToKeypair(seed64)\n\n\treturn {\n\t\tpublicKey: toBase58(pk),\n\t\tprivateKey: toBase58(seed64)\n\t}\n}\n"],"mappings":";;;;;;;;;;AAaA,MAAM,kBAAkB,OAAO,qEAAqE;;;;;;;;AAepG,SAAgB,iBAAiB,SAAiC;CACjE,IAAI,EAAE,mBAAmB,eAAe,QAAQ,WAAA,IAC/C,MAAM,IAAI,MAAM,8BAA8B;CAI/C,IAAI,IAAI,OAAO,EAAE;CACjB,KAAK,IAAI,IAAI,GAAG,IAAA,IAA8B,KAC7C,KAAK,OAAO,QAAQ,GAAG,IAAK,OAAO,EAAE,GAAG,OAAO,EAAE;CAIlD,IAAI,IAAI;CAGR,MAAM,MAAM,IAAI,WAAW,GAAG;CAC9B,KAAK,IAAI,IAAI,IAAI,KAAK,GAAG,KAAK;EAC7B,IAAI,KAAK,OAAO,IAAI,OAAO,IAAK,CAAC;EACjC,MAAM,OAAO,EAAE;;CAGhB,OAAO;;;;;;;;;;;;;AAcR,SAAgB,gBAAgB,QAA8C;CAC7E,MAAM,KAAK,iBAAiB,OAAO;CAEnC,OAAO,CADIA,UAAI,aAAa,GAClB,EAAE,GAAG;;;;;;;;;;;;;AAchB,SAAgB,aAAa,QAAgC;CAC5D,MAAM,CAAC,MAAM,gBAAgB,OAAO;CACpC,OAAO;;;;;;;;;;;;;;AAeR,SAAgB,gCAAgC,cAG9C;CACD,MAAM,SAAS,WAAW,aAAa;CACvC,IAAI,OAAO,WAAA,IACV,MAAM,IAAI,MAAM,wDAAwD;CAIzE,OAAO;EACN,IAHU,iBAAiB,OAGzB;EACF;EACA;;;;;;;;;;;;;;AAeF,SAAgB,8BAA8B,YAA4B;CACzE,IAAI,CAAC,YACJ,MAAM,IAAI,MAAM,yDAAyD;CAE1E,MAAM,SAAS,WAAW,WAAW;CACrC,IAAI,OAAO,WAAA,IACV,MAAM,IAAI,MAAM,wDAAwD;CAGzE,OAAO,SADW,aAAa,OACN,CAAC;;;;;;;;;;;;AAiB3B,SAAgB,qBAAiC;CAChD,MAAM,OAAO,IAAI,WAAA,GAAoC;CACrD,OAAO,gBAAgB,KAAK;CAC5B,OAAO;;;;;;;;;;;;;;AAeR,SAAgB,kBAA2B;CAC1C,MAAM,SAAS,oBAAoB;CACnC,MAAM,CAAC,MAAM,gBAAgB,OAAO;CAEpC,OAAO;EACN,WAAW,SAAS,GAAG;EACvB,YAAY,SAAS,OAAO;EAC5B"}

package/dist/encoding.d.ts

@@ -1,3 +1,4 @@
+//#region src/encoding.d.ts
 /**
  * Encoding/Decoding Utilities
  *
@@ -17,7 +18,7 @@
  * const base64 = uint8ArrayToBase64(new Uint8Array([1, 2, 3]))
  * ```
  */
-export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+declare function uint8ArrayToBase64(bytes: Uint8Array): string;
 /**
  * Convert Base64 string to Uint8Array
  *
@@ -31,7 +32,7 @@ export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
  * const bytes = base64ToUint8Array('AQID')
  * ```
  */
-export declare function base64ToUint8Array(base64: string): Uint8Array;
+declare function base64ToUint8Array(base64: string): Uint8Array;
 /**
  * Convert ArrayBuffer to Base64 string
  *
@@ -43,7 +44,7 @@ export declare function base64ToUint8Array(base64: string): Uint8Array;
  * const base64 = arrayBufferToBase64(new ArrayBuffer(8))
  * ```
  */
-export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
 /**
  * Convert Base64 string to ArrayBuffer
  *
@@ -55,7 +56,7 @@ export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
  * const buffer = base64ToArrayBuffer('AQID')
  * ```
  */
-export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
 /**
  * Convert Uint8Array to ArrayBuffer
  *
@@ -67,7 +68,7 @@ export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
  * const buffer = uint8ArrayToArrayBuffer(new Uint8Array([1, 2, 3]))
  * ```
  */
-export declare function uint8ArrayToArrayBuffer(bytes: Uint8Array): ArrayBuffer;
+declare function uint8ArrayToArrayBuffer(bytes: Uint8Array): ArrayBuffer;
 /**
  * Convert ArrayBuffer to Uint8Array
  *
@@ -79,7 +80,7 @@ export declare function uint8ArrayToArrayBuffer(bytes: Uint8Array): ArrayBuffer;
  * const bytes = arrayBufferToUint8Array(new ArrayBuffer(8))
  * ```
  */
-export declare function arrayBufferToUint8Array(buffer: ArrayBuffer): Uint8Array;
+declare function arrayBufferToUint8Array(buffer: ArrayBuffer): Uint8Array;
 /**
  * Encode a Uint8Array to Base58 string
  *
@@ -91,7 +92,7 @@ export declare function arrayBufferToUint8Array(buffer: ArrayBuffer): Uint8Array
  * const encoded = toBase58(new Uint8Array([1, 2, 3]))
  * ```
  */
-export declare function toBase58(buf: Uint8Array): string;
+declare function toBase58(buf: Uint8Array): string;
 /**
  * Decode a Base58 string to Uint8Array
  *
@@ -104,5 +105,7 @@ export declare function toBase58(buf: Uint8Array): string;
  * const decoded = fromBase58('5Kd3N...')
  * ```
  */
-export declare function fromBase58(str: string): Uint8Array;
+declare function fromBase58(str: string): Uint8Array;
+//#endregion
+export { arrayBufferToBase64, arrayBufferToUint8Array, base64ToArrayBuffer, base64ToUint8Array, fromBase58, toBase58, uint8ArrayToArrayBuffer, uint8ArrayToBase64 };
 //# sourceMappingURL=encoding.d.ts.map

package/dist/encoding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAW5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAY7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAG/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAI/D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAKtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,CAEvE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAElD"}
+{"version":3,"file":"encoding.d.ts","names":[],"sources":["../src/encoding.ts"],"mappings":";;AAiCA;;;;;AA0BA;;;;;AAyBA;;;;;AAgBA;;;AAzCA,iBA1BgB,kBAAA,CAAmB,KAAA,EAAO,UAAA;;AAwF1C;;;;;;;;;AAkBA;;;iBAhFgB,kBAAA,CAAmB,MAAA,WAAiB,UAAA;;;;;;AAmGpD;;;;;AAgBA;iBA1FgB,mBAAA,CAAoB,MAAA,EAAQ,WAAA;;;;;;;;;;;;iBAgB5B,mBAAA,CAAoB,MAAA,WAAiB,WAAA;;;;;;;;;;;;iBAqBrC,uBAAA,CAAwB,KAAA,EAAO,UAAA,GAAa,WAAA;;;;;;;;;;;;iBAkB5C,uBAAA,CAAwB,MAAA,EAAQ,WAAA,GAAc,UAAA;;;;;;;;;;;;iBAmB9C,QAAA,CAAS,GAAA,EAAK,UAAA;;;;;;;;;;;;;iBAgBd,UAAA,CAAW,GAAA,WAAc,UAAA"}