@aptos-labs/ts-sdk 0.0.4 → 0.0.6

package/dist/esm/core/accountAddress.d.mts

@@ -0,0 +1,244 @@
+import { Serializable, Serializer } from '../bcs/serializer.mjs';
+import { Deserializer } from '../bcs/deserializer.mjs';
+import { ParsingResult } from './common.mjs';
+import { TransactionArgument } from '../transactions/instances/transactionArgument.mjs';
+import { HexInput } from '../types/index.mjs';
+import './hex.mjs';
+import '../utils/apiEndpoints.mjs';
+import '../types/indexer.mjs';
+import '../types/generated/operations.mjs';
+import '../types/generated/types.mjs';
+
+/**
+ * This enum is used to explain why an address was invalid.
+ */
+declare enum AddressInvalidReason {
+    INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
+    INVALID_HEX_CHARS = "invalid_hex_chars",
+    TOO_SHORT = "too_short",
+    TOO_LONG = "too_long",
+    LEADING_ZERO_X_REQUIRED = "leading_zero_x_required",
+    LONG_FORM_REQUIRED_UNLESS_SPECIAL = "long_form_required_unless_special",
+    INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES"
+}
+type AccountAddressInput = HexInput | AccountAddress;
+/**
+ * NOTE: Only use this class for account addresses. For other hex data, e.g. transaction
+ * hashes, use the Hex class.
+ *
+ * AccountAddress is used for working with account addresses. Account addresses, when
+ * represented as a string, generally look like these examples:
+ * - 0x1
+ * - 0xaa86fe99004361f747f91342ca13c426ca0cccb0c1217677180c9493bad6ef0c
+ *
+ * Proper formatting and parsing of account addresses is defined by AIP-40.
+ * To learn more about the standard, read the AIP here:
+ * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+ *
+ * The comments in this class make frequent reference to the LONG and SHORT formats,
+ * as well as "special" addresses. To learn what these refer to see AIP-40.
+ */
+declare class AccountAddress extends Serializable implements TransactionArgument {
+    /**
+     * This is the internal representation of an account address.
+     */
+    readonly data: Uint8Array;
+    /**
+     * The number of bytes that make up an account address.
+     */
+    static readonly LENGTH: number;
+    /**
+     * The length of an address string in LONG form without a leading 0x.
+     */
+    static readonly LONG_STRING_LENGTH: number;
+    static ZERO: AccountAddress;
+    static ONE: AccountAddress;
+    static TWO: AccountAddress;
+    static THREE: AccountAddress;
+    static FOUR: AccountAddress;
+    /**
+     * Creates an instance of AccountAddress from a Uint8Array.
+     *
+     * @param args.data A Uint8Array representing an account address.
+     */
+    constructor(input: Uint8Array);
+    /**
+     * Returns whether an address is special, where special is defined as 0x0 to 0xf
+     * inclusive. In other words, the last byte of the address must be < 0b10000 (16)
+     * and every other byte must be zero.
+     *
+     * For more information on how special addresses are defined see AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @returns true if the address is special, false if not.
+     */
+    isSpecial(): boolean;
+    /**
+     * Return the AccountAddress as a string as per AIP-40.
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * In short, it means that special addresses are represented in SHORT form, meaning
+     * 0x0 through to 0xf inclusive, and every other address is represented in LONG form,
+     * meaning 0x + 64 hex characters.
+     *
+     * @returns AccountAddress as a string conforming to AIP-40.
+     */
+    toString(): `0x${string}`;
+    /**
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * Return the AccountAddress as a string as per AIP-40 but without the leading 0x.
+     *
+     * Learn more by reading the docstring of `toString`.
+     *
+     * @returns AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+     */
+    toStringWithoutPrefix(): string;
+    /**
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * Whereas toString will format special addresses (as defined by isSpecial) using the
+     * SHORT form (no leading 0s), this format the address in the LONG format
+     * unconditionally.
+     *
+     * This means it will be 0x + 64 hex characters.
+     *
+     * @returns AccountAddress as a string in LONG form.
+     */
+    toStringLong(): `0x${string}`;
+    /**
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * Whereas toString will format special addresses (as defined by isSpecial) using the
+     * SHORT form (no leading 0s), this function will include leading zeroes. The string
+     * will not have a leading zero.
+     *
+     * This means it will be 64 hex characters without a leading 0x.
+     *
+     * @returns AccountAddress as a string in LONG form without a leading 0x.
+     */
+    toStringLongWithoutPrefix(): string;
+    /**
+     * Get the inner hex data. The inner data is already a Uint8Array so no conversion
+     * is taking place here, it just returns the inner data.
+     *
+     * @returns Hex data as Uint8Array
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Serialize the AccountAddress to a Serializer instance's data buffer.
+     * @param serializer The serializer to serialize the AccountAddress to.
+     * @returns void
+     * @example
+     * const serializer = new Serializer();
+     * const address = AccountAddress.fromString("0x1");
+     * address.serialize(serializer);
+     * const bytes = serializer.toUint8Array();
+     * // `bytes` is now the BCS-serialized address.
+     */
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    /**
+     * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+     * @param deserializer The deserializer to deserialize the AccountAddress from.
+     * @returns An instance of AccountAddress.
+     * @example
+     * const bytes = hexToBytes("0x0102030405060708091011121314151617181920212223242526272829303132");
+     * const deserializer = new Deserializer(bytes);
+     * const address = AccountAddress.deserialize(deserializer);
+     * // `address` is now an instance of AccountAddress.
+     */
+    static deserialize(deserializer: Deserializer): AccountAddress;
+    /**
+     * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
+     * the `fromStringRelaxed` function.
+     *
+     * Creates an instance of AccountAddress from a hex string.
+     *
+     * This function allows only the strictest formats defined by AIP-40. In short this
+     * means only the following formats are accepted:
+     *
+     * - LONG
+     * - SHORT for special addresses
+     *
+     * Where:
+     * - LONG is defined as 0x + 64 hex characters.
+     * - SHORT for special addresses is 0x0 to 0xf inclusive without padding zeroes.
+     *
+     * This means the following are not accepted:
+     * - SHORT for non-special addresses.
+     * - Any address without a leading 0x.
+     *
+     * Learn more about the different address formats by reading AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @param input A hex string representing an account address.
+     *
+     * @returns An instance of AccountAddress.
+     */
+    static fromString(input: string): AccountAddress;
+    /**
+     * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
+     * the `fromString` function. Where possible use `fromString` rather than this
+     * function, `fromStringRelaxed` is only provided for backwards compatibility.
+     *
+     * Creates an instance of AccountAddress from a hex string.
+     *
+     * This function allows all formats defined by AIP-40. In short this means the
+     * following formats are accepted:
+     *
+     * - LONG, with or without leading 0x
+     * - SHORT, with or without leading 0x
+     *
+     * Where:
+     * - LONG is 64 hex characters.
+     * - SHORT is 1 to 63 hex characters inclusive.
+     * - Padding zeroes are allowed, e.g. 0x0123 is valid.
+     *
+     * Learn more about the different address formats by reading AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @param input A hex string representing an account address.
+     *
+     * @returns An instance of AccountAddress.
+     */
+    static fromStringRelaxed(input: string): AccountAddress;
+    /**
+     * Convenience method for creating an AccountAddress from all known inputs.
+     *
+     * This handles, Uint8array, string, and AccountAddress itself
+     * @param input
+     */
+    static fromRelaxed(input: AccountAddressInput): AccountAddress;
+    /**
+     * Convenience method for creating an AccountAddress from all known inputs.
+     *
+     * This handles, Uint8array, string, and AccountAddress itself
+     * @param input
+     */
+    static from(input: AccountAddressInput): AccountAddress;
+    /**
+     * Check if the string is a valid AccountAddress.
+     *
+     * @param args.input A hex string representing an account address.
+     * @param args.relaxed If true, use relaxed parsing behavior. If false, use strict parsing behavior.
+     *
+     * @returns valid = true if the string is valid, valid = false if not. If the string
+     * is not valid, invalidReason will be set explaining why it is invalid.
+     */
+    static isValid(args: {
+        input: AccountAddressInput;
+        relaxed?: boolean;
+    }): ParsingResult<AddressInvalidReason>;
+    /**
+     * Return whether AccountAddresses are equal. AccountAddresses are considered equal
+     * if their underlying byte data is identical.
+     *
+     * @param other The AccountAddress to compare to.
+     * @returns true if the AccountAddresses are equal, false if not.
+     */
+    equals(other: AccountAddress): boolean;
+}
+
+export { AccountAddress, AccountAddressInput, AddressInvalidReason };

package/dist/esm/core/accountAddress.mjs

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-NZIJV4O2.mjs";import"../chunk-HA6JD5R6.mjs";import"../chunk-DNDWTM7A.mjs";import"../chunk-TIH6ARYP.mjs";import"../chunk-FBPNHF54.mjs";import"../chunk-Y7VR7X5W.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-ZWH2ESXT.mjs";export{b as AccountAddress,a as AddressInvalidReason};
+//# sourceMappingURL=accountAddress.mjs.map

package/dist/esm/core/accountAddress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/authenticationKey.d.mts

@@ -0,0 +1,74 @@
+import { AccountAddress } from './accountAddress.mjs';
+import { PublicKey } from './crypto/asymmetricCrypto.mjs';
+import { Hex } from './hex.mjs';
+import { HexInput, AuthenticationKeyScheme } from '../types/index.mjs';
+import { Serializable, Serializer } from '../bcs/serializer.mjs';
+import { Deserializer } from '../bcs/deserializer.mjs';
+import './common.mjs';
+import '../transactions/instances/transactionArgument.mjs';
+import '../utils/apiEndpoints.mjs';
+import '../types/indexer.mjs';
+import '../types/generated/operations.mjs';
+import '../types/generated/types.mjs';
+
+/**
+ * Each account stores an authentication key. Authentication key enables account owners to rotate
+ * their private key(s) associated with the account without changing the address that hosts their account.
+ * @see {@link https://aptos.dev/concepts/accounts | Account Basics}
+ *
+ * Account addresses can be derived from AuthenticationKey
+ */
+declare class AuthenticationKey extends Serializable {
+    /**
+     * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
+     *
+     * The data to hash depends on the underlying public key type and the derivation scheme.
+     */
+    static readonly LENGTH: number;
+    /**
+     * The raw bytes of the authentication key.
+     */
+    readonly data: Hex;
+    constructor(args: {
+        data: HexInput;
+    });
+    serialize(serializer: Serializer): void;
+    /**
+     * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
+     * @param deserializer The deserializer to deserialize the AuthenticationKey from.
+     * @returns An instance of AuthenticationKey.
+     */
+    static deserialize(deserializer: Deserializer): AuthenticationKey;
+    toString(): string;
+    toUint8Array(): Uint8Array;
+    /**
+     * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
+     *
+     * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
+     *
+     * @param args - the public key and scheme to use for the derivation
+     */
+    static fromPublicKeyAndScheme(args: {
+        publicKey: PublicKey;
+        scheme: AuthenticationKeyScheme;
+    }): AuthenticationKey;
+    /**
+     * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the
+     * instance of the PublicKey type passed in.
+     *
+     * @param args.publicKey
+     * @returns AuthenticationKey
+     */
+    static fromPublicKey(args: {
+        publicKey: PublicKey;
+    }): AuthenticationKey;
+    /**
+     * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,
+     * the AuthenticationKey bytes are directly translated to an AccountAddress.
+     *
+     * @returns AccountAddress
+     */
+    derivedAddress(): AccountAddress;
+}
+
+export { AuthenticationKey };

package/dist/esm/core/authenticationKey.mjs

@@ -0,0 +1,2 @@
+import{a}from"../chunk-U3LO2FSJ.mjs";import"../chunk-U25N2VWA.mjs";import"../chunk-44MGBJ73.mjs";import"../chunk-YYRDFZE6.mjs";import"../chunk-62SCW5NH.mjs";import"../chunk-RYETO74W.mjs";import"../chunk-EFIYW4WK.mjs";import"../chunk-LR65XHSF.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-HVADSXTB.mjs";import"../chunk-BPYLPPEQ.mjs";import"../chunk-4ADA5BE7.mjs";import"../chunk-X32O46IB.mjs";import"../chunk-GTC7WHMV.mjs";import"../chunk-NZIJV4O2.mjs";import"../chunk-HA6JD5R6.mjs";import"../chunk-DNDWTM7A.mjs";import"../chunk-TIH6ARYP.mjs";import"../chunk-FBPNHF54.mjs";import"../chunk-Y7VR7X5W.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-ZWH2ESXT.mjs";export{a as AuthenticationKey};
+//# sourceMappingURL=authenticationKey.mjs.map

package/dist/esm/core/authenticationKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/common.d.mts

@@ -0,0 +1,32 @@
+/**
+ * This error is used to explain why parsing failed.
+ */
+declare class ParsingError<T> extends Error {
+    /**
+     * This provides a programmatic way to access why parsing failed. Downstream devs
+     * might want to use this to build their own error messages if the default error
+     * messages are not suitable for their use case. This should be an enum.
+     */
+    invalidReason: T;
+    constructor(message: string, invalidReason: T);
+}
+/**
+ * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,
+ * this type is returned from "defensive" functions like isValid.
+ */
+type ParsingResult<T> = {
+    /**
+     * True if valid, false otherwise.
+     */
+    valid: boolean;
+    /**
+     * If valid is false, this will be a code explaining why parsing failed.
+     */
+    invalidReason?: T;
+    /**
+     * If valid is false, this will be a string explaining why parsing failed.
+     */
+    invalidReasonMessage?: string;
+};
+
+export { ParsingError, ParsingResult };

package/dist/esm/core/common.mjs

@@ -0,0 +1,2 @@
+import{a}from"../chunk-FBPNHF54.mjs";import"../chunk-ZWH2ESXT.mjs";export{a as ParsingError};
+//# sourceMappingURL=common.mjs.map

package/dist/esm/core/common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/anyPublicKey.d.mts

@@ -0,0 +1,54 @@
+import { Deserializer } from '../../bcs/deserializer.mjs';
+import { Serializer } from '../../bcs/serializer.mjs';
+import { HexInput } from '../../types/index.mjs';
+import { AnySignature } from './anySignature.mjs';
+import { PublicKey } from './asymmetricCrypto.mjs';
+import '../../utils/apiEndpoints.mjs';
+import '../../types/indexer.mjs';
+import '../../types/generated/operations.mjs';
+import '../../types/generated/types.mjs';
+import '../hex.mjs';
+import '../common.mjs';
+
+/**
+ * Represents any public key supported by Aptos.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class AnyPublicKey extends PublicKey {
+    /**
+     * Reference to the inner public key
+     */
+    readonly publicKey: PublicKey;
+    constructor(publicKey: PublicKey);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     *
+     * @param args.message message
+     * @param args.signature The signature
+     * @returns true if the signature is valid
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: AnySignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AnyPublicKey;
+}
+
+export { AnyPublicKey };

package/dist/esm/core/crypto/anyPublicKey.mjs

@@ -0,0 +1,2 @@
+import{a}from"../../chunk-YYRDFZE6.mjs";import"../../chunk-62SCW5NH.mjs";import"../../chunk-RYETO74W.mjs";import"../../chunk-EFIYW4WK.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-HVADSXTB.mjs";import"../../chunk-BPYLPPEQ.mjs";import"../../chunk-4ADA5BE7.mjs";import"../../chunk-X32O46IB.mjs";import"../../chunk-GTC7WHMV.mjs";import"../../chunk-HA6JD5R6.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-TIH6ARYP.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-Y7VR7X5W.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-ZWH2ESXT.mjs";export{a as AnyPublicKey};
+//# sourceMappingURL=anyPublicKey.mjs.map

package/dist/esm/core/crypto/anyPublicKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/anySignature.d.mts

@@ -0,0 +1,31 @@
+import { Deserializer } from '../../bcs/deserializer.mjs';
+import { Serializer } from '../../bcs/serializer.mjs';
+import { Signature } from './asymmetricCrypto.mjs';
+import '../../types/index.mjs';
+import '../../utils/apiEndpoints.mjs';
+import '../../types/indexer.mjs';
+import '../../types/generated/operations.mjs';
+import '../../types/generated/types.mjs';
+import '../hex.mjs';
+import '../common.mjs';
+
+declare class AnySignature extends Signature {
+    readonly signature: Signature;
+    constructor(signature: Signature);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AnySignature;
+}
+
+export { AnySignature };

package/dist/esm/core/crypto/anySignature.mjs

@@ -0,0 +1,2 @@
+import{a}from"../../chunk-QWVR4RCV.mjs";import"../../chunk-62SCW5NH.mjs";import"../../chunk-RYETO74W.mjs";import"../../chunk-EFIYW4WK.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-HVADSXTB.mjs";import"../../chunk-BPYLPPEQ.mjs";import"../../chunk-4ADA5BE7.mjs";import"../../chunk-X32O46IB.mjs";import"../../chunk-GTC7WHMV.mjs";import"../../chunk-HA6JD5R6.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-TIH6ARYP.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-Y7VR7X5W.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-ZWH2ESXT.mjs";export{a as AnySignature};
+//# sourceMappingURL=anySignature.mjs.map

package/dist/esm/core/crypto/anySignature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/asymmetricCrypto.d.mts

@@ -0,0 +1,74 @@
+import { HexInput } from '../../types/index.mjs';
+import { Serializable, Serializer } from '../../bcs/serializer.mjs';
+import '../../utils/apiEndpoints.mjs';
+import '../../types/indexer.mjs';
+import '../../types/generated/operations.mjs';
+import '../../types/generated/types.mjs';
+import '../hex.mjs';
+import '../common.mjs';
+
+/**
+ * An abstract representation of a public key.  All Asymmetric key pairs will use this to
+ * verify signatures and for authentication keys.
+ */
+declare abstract class PublicKey extends Serializable {
+    /**
+     * Verifies that the private key associated with this public key signed the message with the given signature.
+     * @param args.message The message that was signed
+     * @param args.signature The signature to verify
+     */
+    abstract verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
+    /**
+     * Get the raw public key bytes
+     */
+    abstract toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
+     */
+    abstract toString(): string;
+    abstract serialize(serializer: Serializer): void;
+}
+/**
+ * An abstract representation of a private key.  This is used to sign transactions and
+ * derive the public key associated.
+ */
+declare abstract class PrivateKey extends Serializable {
+    /**
+     * Sign a message with the key
+     * @param message The message to sign
+     */
+    abstract sign(message: HexInput): Signature;
+    /**
+     * Get the raw private key bytes
+     */
+    abstract toUint8Array(): Uint8Array;
+    /**
+     * Get the private key as a hex string with a 0x prefix e.g. 0x123456...
+     */
+    abstract toString(): string;
+    abstract serialize(serializer: Serializer): void;
+    /**
+     * Derives the public key associated with the private key
+     */
+    abstract publicKey(): PublicKey;
+}
+/**
+ * An abstract representation of a signature.  This is the product of signing a
+ * message and can be used with the PublicKey to verify the signature.
+ */
+declare abstract class Signature extends Serializable {
+    /**
+     * Get the raw signature bytes
+     */
+    abstract toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
+     */
+    abstract toString(): string;
+    abstract serialize(serializer: Serializer): void;
+}
+
+export { PrivateKey, PublicKey, Signature };

package/dist/esm/core/crypto/asymmetricCrypto.mjs

@@ -0,0 +1,2 @@
+import{a,b,c}from"../../chunk-EFIYW4WK.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-HVADSXTB.mjs";import"../../chunk-BPYLPPEQ.mjs";import"../../chunk-4ADA5BE7.mjs";import"../../chunk-X32O46IB.mjs";import"../../chunk-GTC7WHMV.mjs";import"../../chunk-HA6JD5R6.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-TIH6ARYP.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-Y7VR7X5W.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-ZWH2ESXT.mjs";export{b as PrivateKey,a as PublicKey,c as Signature};
+//# sourceMappingURL=asymmetricCrypto.mjs.map

package/dist/esm/core/crypto/asymmetricCrypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}