@aptos-labs/ts-sdk 5.1.3 → 5.1.5

package/LICENSE

@@ -1,201 +1,68 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Copyright 2023 Aptos Foundation
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+Innovation-Enabling Source Code License
+
+Copyright © Aptos Foundation
+Parts of the project are originally copyright © Meta Platforms, Inc.
+
+-----------------------------------------------------------------------------
+
+“Licensed Work” shall mean the work of authorship, whether in source code or 
+object code form or otherwise, made available under this license, as 
+indicated by a notice that is included in or attached to the work.  
+
+Aptos Foundation (the “Licensor”) hereby grants you the right to copy, 
+modify, create derivative
+works, redistribute, and make non-production and non-commercial use of the 
+Licensed Work solely for your internal purposes. Without limiting the 
+generality of the foregoing, you may not use the Licensed Work (or any 
+information therein) for the purpose of creating, publishing, deploying, 
+launching or offering any blockchain or protocols (whether in mainnet, 
+testnet, devnet, beta or alpha versions) outside of personal, non-production 
+and non-commercial environments.
+
+Notwithstanding the foregoing, on the date that is 4 years after 
+the date that the Licensor has publicly uploaded the specific code of the 
+Licensed Work that you are using (the “Change Date”), the license herein 
+shall automatically terminate and you shall have the right to then use the 
+Licensed Work pursuant to the terms of the Apache 2.0 license.
+
+In addition, notwithstanding the foregoing, you may additionally use the 
+software included in the repositories available at this link 
+(https://docs.google.com/spreadsheets/d/1YXfK8bpXNbXUhRtH1hZAaZGdDPyM-ppoKuh6hoLC3Cs/edit?gid=0#gid=0) 
+for production commercial uses (the “Additional Use Grant 
+Software”), but solely to the extent if such uses are (i) for an application 
+built exclusively on the Aptos protocol and (ii) not Competing Uses.  
+“Competing Use” means any use of the Additional Use Grant Software in any 
+product, protocol, application or service that is made available to third 
+parties and that (i) (a) substitutes for use of Aptos protocol or (b) is 
+related to the development of a layer 1 or layer 2 blockchain, (ii) offers 
+similar functionality as the Aptos protocol or (iii) is built on or using a 
+protocol other than Aptos protocol.
+
+All copies of the original and modified Licensed Work, and derivative works 
+of the Licensed Work, are subject to this License. This License applies 
+separately for each version of the Licensed Work and the Change Date may 
+vary for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified 
+copy of the Licensed Work. If you receive the Licensed Work in original or 
+modified form from a third party, the terms and conditions set forth in this 
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically 
+terminate your rights under this License for the current and all other 
+versions of the Licensed Work.  You may contact Aptos Foundation if you are 
+interested in seeking a commercial license.
+
+
+This License does not grant you any right in any trademark or logo of 
+Licensor or its affiliates (provided that you may use a trademark or logo of 
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON 
+AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, 
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND 
+TITLE. TO THE FULLEST EXTENT PERMITTED UNDER APPLICABLE LAW, LICENSOR SHALL 
+NOT BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY LOST PROFITS, LOSS OF 
+REVENUE OR BUSINESS, COST OF COVER OR ANY INCIDENTAL, SPECIAL OR 
+CONSEQUENTIAL DAMAGES OF ANY KIND AND NATURE.

package/dist/common/{account-nCfrFDHy.d.ts → account-DefhsHe3.d.ts}

@@ -1018,6 +1018,57 @@ declare class Serializer {
      * @category BCS
      */
     serializeU256(value: AnyNumber): void;
+    /**
+     * Serializes an 8-bit signed integer value.
+     * BCS layout for "int8": One byte. Binary format in little-endian representation.
+     *
+     * @param value - The 8-bit signed integer value to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI8(value: number): void;
+    /**
+     * Serializes a 16-bit signed integer value into a binary format.
+     * BCS layout for "int16": Two bytes. Binary format in little-endian representation.
+     *
+     * @param value - The 16-bit signed integer value to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI16(value: number): void;
+    /**
+     * Serializes a 32-bit signed integer value into a binary format.
+     *
+     * @param value - The 32-bit signed integer value to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI32(value: number): void;
+    /**
+     * Serializes a 64-bit signed integer into a format suitable for storage or transmission.
+     * This function uses two's complement representation for negative values.
+     *
+     * @param value - The 64-bit signed integer to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI64(value: AnyNumber): void;
+    /**
+     * Serializes a 128-bit signed integer value.
+     *
+     * @param value - The 128-bit signed integer value to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI128(value: AnyNumber): void;
+    /**
+     * Serializes a 256-bit signed integer value.
+     *
+     * @param value - The 256-bit signed integer value to serialize.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeI256(value: AnyNumber): void;
     /**
      * Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array.
      * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
@@ -4719,6 +4770,108 @@ declare class U256 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U256;
 }
+/**
+ * Represents an 8-bit signed integer (I8) value.
+ * This class extends the Serializable class and provides methods for serialization and deserialization of I8 values.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I8 extends Serializable implements TransactionArgument {
+    readonly value: Int8;
+    constructor(value: Int8);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I8;
+}
+/**
+ * Represents a 16-bit signed integer (I16) value.
+ * This class extends the Serializable class and provides methods for serialization
+ * and deserialization of the I16 value.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I16 extends Serializable implements TransactionArgument {
+    readonly value: Int16;
+    constructor(value: Int16);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I16;
+}
+/**
+ * Represents a 32-bit signed integer (I32) that can be serialized and deserialized.
+ * This class ensures that the value is within the valid range for an I32.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I32 extends Serializable implements TransactionArgument {
+    readonly value: Int32;
+    constructor(value: Int32);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I32;
+}
+/**
+ * Represents a 64-bit signed integer (I64) and provides methods for serialization.
+ *
+ * This class ensures that the value is within the valid range for an I64 and provides
+ * functionality to serialize the value for various use cases, including entry functions
+ * and script functions.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I64 extends Serializable implements TransactionArgument {
+    readonly value: bigint;
+    constructor(value: AnyNumber);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I64;
+}
+/**
+ * Represents a 128-bit signed integer value.
+ * This class provides methods for serialization and deserialization
+ * of I128 values, ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I128 extends Serializable implements TransactionArgument {
+    readonly value: bigint;
+    constructor(value: AnyNumber);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I128;
+}
+/**
+ * Represents a 256-bit signed integer (I256) that extends the Serializable class.
+ * This class provides methods for serialization and deserialization of I256 values,
+ * ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+declare class I256 extends Serializable implements TransactionArgument {
+    readonly value: bigint;
+    constructor(value: AnyNumber);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): I256;
+}
 
 /**
  * This class is the Aptos Typescript SDK representation of a Move `vector<T>`,
@@ -5832,6 +5985,30 @@ type Uint128 = bigint;
  * A 256-bit unsigned integer used for precise numerical calculations.
  */
 type Uint256 = bigint;
+/**
+ * A signed 8-bit integer.
+ */
+type Int8 = number;
+/**
+ * A signed 16-bit integer.
+ */
+type Int16 = number;
+/**
+ * A signed 32-bit integer.
+ */
+type Int32 = number;
+/**
+ * A signed 64-bit integer.
+ */
+type Int64 = bigint;
+/**
+ * A signed 128-bit integer.
+ */
+type Int128 = bigint;
+/**
+ * A signed 256-bit integer.
+ */
+type Int256 = bigint;
 /**
  * A number or a bigint value.
  */
@@ -7295,6 +7472,60 @@ declare class Deserializer {
      * @category BCS
      */
     deserializeU256(): Uint256;
+    /**
+     * Deserializes an 8-bit signed integer from the binary data.
+     * BCS layout for "int8": One byte. Binary format in little-endian representation.
+     *
+     * @returns {number} The deserialized int8 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI8(): number;
+    /**
+     * Deserializes a 16-bit signed integer from a binary format in little-endian representation.
+     * BCS layout for "int16": Two bytes.
+     *
+     * @returns {number} The deserialized int16 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI16(): number;
+    /**
+     * Deserializes a 32-bit signed integer from a binary format in little-endian representation.
+     * BCS layout for "int32": Four bytes.
+     *
+     * @returns {number} The deserialized int32 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI32(): number;
+    /**
+     * Deserializes a 64-bit signed integer.
+     * This function combines two 32-bit values to return a 64-bit signed integer in little-endian representation.
+     *
+     * @returns {bigint} The deserialized int64 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI64(): bigint;
+    /**
+     * Deserializes a 128-bit signed integer from its binary representation.
+     * This function combines two 64-bit values to return a single int128 value in little-endian format.
+     *
+     * @returns {bigint} The deserialized int128 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI128(): bigint;
+    /**
+     * Deserializes a 256-bit signed integer from its binary representation.
+     * BCS layout for "int256": Thirty-two bytes in little-endian format.
+     *
+     * @returns {bigint} The deserialized int256 number.
+     * @group Implementation
+     * @category BCS
+     */
+    deserializeI256(): bigint;
     /**
      * Deserializes a uleb128 encoded uint32 number.
      *
@@ -7535,4 +7766,4 @@ declare class AccountAbstractionMessage extends Serializable {
     static deserialize(deserializer: Deserializer): AccountAbstractionMessage;
 }
 
-export { type InputViewFunctionDataWithABI as $, AccountAddress as A, Bool as B, type InputGenerateTransactionPayloadData as C, Deserializer as D, EphemeralPublicKeyVariant as E, FixedBytes as F, type InputScriptData as G, type HexInput as H, type InputGenerateTransactionPayloadDataWithRemoteABI as I, type MoveFunction as J, type InputEntryFunctionDataWithRemoteABI as K, type LedgerVersionArg as L, MultiKey as M, TransactionPayloadEntryFunction as N, type InputMultiSigDataWithRemoteABI as O, PublicKey as P, TransactionPayloadMultiSig as Q, RawTransaction as R, Serializer as S, TransactionPayloadScript as T, U8 as U, type VerifySignatureArgs as V, type InputEntryFunctionDataWithABI as W, type InputMultiSigDataWithABI as X, type InputViewFunctionDataWithRemoteABI as Y, ZkpVariant as Z, EntryFunction as _, AccountPublicKey as a, type GasEstimation as a$, type AnyTransactionPayloadInstance as a0, type InputGenerateTransactionOptions as a1, TransactionInnerPayload as a2, type InputGenerateSingleSignerRawTransactionArgs as a3, SimpleTransaction as a4, type InputGenerateMultiAgentRawTransactionArgs as a5, MultiAgentTransaction as a6, type InputSimulateTransactionData as a7, AccountAuthenticatorNoAccountAuthenticator as a8, AccountAuthenticatorEd25519 as a9, type PrivateKeyInput as aA, type GetCollectionDataResponse as aB, type GetTokenDataResponse as aC, type GetCurrentTokenOwnershipResponse as aD, type GetOwnedTokensResponse as aE, type GetTokenActivityResponse as aF, type WaitForTransactionOptions as aG, type UserTransactionResponse as aH, type GetFungibleAssetMetadataResponse as aI, type GetFungibleAssetActivitiesResponse as aJ, type GetCurrentFungibleAssetBalancesResponse as aK, type LedgerInfo as aL, type Block as aM, type MoveValue as aN, type InputViewFunctionData as aO, type InputViewFunctionJsonData as aP, type GetChainTopUserTransactionsResponse as aQ, type GraphqlQuery as aR, ProcessorType as aS, type GetProcessorStatusResponse as aT, type GetANSNameResponse as aU, type GetNumberOfDelegatorsResponse as aV, type GetDelegatedStakingActivitiesResponse as aW, type InputSimulateTransactionOptions as aX, type InputTransactionPluginData as aY, type PendingTransactionResponse as aZ, type CommittedTransactionResponse as a_, AccountAuthenticatorSingleKey as aa, AccountAuthenticatorMultiKey as ab, type InputSubmitTransactionData as ac, type TypeArgument as ad, TypeTag as ae, type MoveModule as af, type FunctionABI as ag, type EntryFunctionABI as ah, type ViewFunctionABI as ai, type AnyRawTransaction as aj, type AnyRawTransactionInstance as ak, type AccountData as al, type MoveModuleBytecode as am, type CursorPaginationArgs as an, type PaginationArgs as ao, type TransactionResponse as ap, type MoveResource as aq, type MoveStructId as ar, type TokenStandardArg as as, type OrderByArg as at, type GetAccountOwnedTokensQueryResponse as au, type GetAccountOwnedTokensFromCollectionResponse as av, type GetAccountCollectionsWithOwnedTokenResponse as aw, type GetAccountCoinsDataResponse as ax, type WhereArg as ay, type GetObjectDataQueryResponse as az, AuthenticationKey as b, TypeTagI32 as b$, Ed25519PrivateKey as b0, type TableItemRequest as b1, type GetTableItemsDataResponse as b2, type GetTableItemsMetadataResponse as b3, SigningScheme as b4, SigningSchemeInput as b5, AnySignature as b6, type EntryFunctionArgument as b7, MultiKeySignature as b8, AccountAuthenticatorMultiEd25519 as b9, AccountAbstractionMessage as bA, ChainId as bB, Identifier as bC, ModuleId as bD, RawTransactionWithData as bE, MultiAgentRawTransaction as bF, FeePayerRawTransaction as bG, type TransactionArgument as bH, type ScriptFunctionArgument as bI, deserializeFromScriptArgument as bJ, TransactionPayload as bK, Script as bL, MultiSig as bM, MultiSigTransactionPayload as bN, TransactionInnerPayloadV1 as bO, TransactionExecutable as bP, TransactionExecutableScript as bQ, TransactionExecutableEntryFunction as bR, TransactionExecutableEmpty as bS, TransactionExtraConfig as bT, TransactionExtraConfigV1 as bU, TypeTagBool as bV, TypeTagU8 as bW, TypeTagI8 as bX, TypeTagU16 as bY, TypeTagI16 as bZ, TypeTagU32 as b_, AccountAuthenticatorAbstraction as ba, type MoveFunctionId as bb, type ClientRequest as bc, type Client as bd, type ClientResponse as be, type AptosRequest as bf, AptosApiType as bg, type AptosResponse as bh, MimeType as bi, type ClientConfig as bj, type Deserializable as bk, ensureBoolean as bl, outOfRangeErrorMessage as bm, validateNumberInRange as bn, Serialized as bo, MoveOption as bp, AddressInvalidReason as bq, ParsingError as br, type ParsingResult as bs, isCanonicalEd25519Signature as bt, AbstractMultiKey as bu, Secp256k1PublicKey as bv, Secp256k1PrivateKey as bw, Secp256k1Signature as bx, HexInvalidReason as by, hexToAsciiString as bz, type VerifySignatureAsyncArgs as c, isPendingTransactionResponse as c$, TypeTagU64 as c0, TypeTagI64 as c1, TypeTagU128 as c2, TypeTagI128 as c3, TypeTagU256 as c4, TypeTagI256 as c5, TypeTagAddress as c6, TypeTagSigner as c7, TypeTagReference as c8, TypeTagGeneric as c9, TransactionInnerPayloadVariants as cA, TransactionExecutableVariants as cB, TransactionExtraConfigVariants as cC, TransactionVariants as cD, TransactionAuthenticatorVariant as cE, AccountAuthenticatorVariant as cF, PrivateKeyVariants as cG, AnyPublicKeyVariant as cH, anyPublicKeyVariantToString as cI, AnySignatureVariant as cJ, EphemeralSignatureVariant as cK, type Uint8 as cL, type Uint16 as cM, type Uint32 as cN, type Uint64 as cO, type Uint128 as cP, type Uint256 as cQ, type AptosSettings as cR, type FullNodeConfig as cS, type IndexerConfig as cT, type FaucetConfig as cU, type TransactionGenerationConfig as cV, type ClientHeadersType as cW, type PluginConfig as cX, type PluginSettings as cY, type TransactionSubmitter as cZ, TransactionResponseType as c_, TypeTagVector as ca, TypeTagStruct as cb, StructTag as cc, aptosCoinStructTag as cd, stringStructTag as ce, optionStructTag as cf, objectStructTag as cg, type ScriptFunctionArgumentTypes as ch, type InputGenerateSequenceNumberTransactionOptions as ci, type InputGenerateOrderlessTransactionOptions as cj, type InputEntryFunctionData as ck, type InputGenerateTransactionPayloadDataWithABI as cl, type InputMultiSigData as cm, type ViewFunctionJsonPayload as cn, type InputGenerateRawTransactionArgs as co, type InputGenerateSingleSignerRawTransactionData as cp, type InputGenerateMultiAgentRawTransactionData as cq, type InputGenerateTransactionData as cr, type GetAccountAddressesForAuthKeyResponse as cs, type GetEventsResponse as ct, type OrderBy as cu, type OrderByValue as cv, type TokenStandard as cw, TypeTagVariants as cx, ScriptTransactionArgumentVariants as cy, TransactionPayloadVariants as cz, Signature as d, type MoveStruct as d$, isUserTransactionResponse as d0, isGenesisTransactionResponse as d1, isBlockMetadataTransactionResponse as d2, isStateCheckpointTransactionResponse as d3, isValidatorTransactionResponse as d4, isBlockEpilogueTransactionResponse as d5, type GenesisTransactionResponse as d6, type BlockMetadataTransactionResponse as d7, type StateCheckpointTransactionResponse as d8, type ValidatorTransactionResponse as d9, type TransactionSecp256k1Signature as dA, type TransactionSingleSenderSignature as dB, type TransactionMultiEd25519Signature as dC, type TransactionMultiAgentSignature as dD, type TransactionFeePayerSignature as dE, type AccountSignature as dF, type WriteSet as dG, type ScriptWriteSet as dH, type DirectWriteSet as dI, type EventGuid as dJ, type Event as dK, type MoveUint8Type as dL, type MoveUint16Type as dM, type MoveUint32Type as dN, type MoveUint64Type as dO, type MoveUint128Type as dP, type MoveUint256Type as dQ, type MoveAddressType as dR, type MoveObjectType as dS, type MoveOptionType as dT, type MoveStructType as dU, type MoveType as dV, type MoveModuleId as dW, MoveFunctionVisibility as dX, MoveAbility as dY, type MoveFunctionGenericTypeParam as dZ, type MoveStructField as d_, type BlockEndInfo as da, type BlockEpilogueTransactionResponse as db, type WriteSetChange as dc, type WriteSetChangeDeleteModule as dd, type WriteSetChangeDeleteResource as de, type WriteSetChangeDeleteTableItem as df, type WriteSetChangeWriteModule as dg, type WriteSetChangeWriteResource as dh, type WriteSetChangeWriteTableItem as di, type DecodedTableData as dj, type DeletedTableData as dk, type TransactionPayloadResponse as dl, type EntryFunctionPayloadResponse as dm, type ScriptPayloadResponse as dn, type MultisigPayloadResponse as dp, type GenesisPayload as dq, type MoveScriptBytecode as dr, type TransactionSignature as ds, isEd25519Signature as dt, isSecp256k1Signature as du, isMultiAgentSignature as dv, isFeePayerSignature as dw, isMultiEd25519Signature as dx, isSingleSenderSignature as dy, type TransactionEd25519Signature as dz, AptosConfig as e, RoleType as e0, type AuthenticationKeyScheme as e1, DeriveScheme as e2, type GenerateAccountWithEd25519 as e3, type GenerateAccountWithSingleSignerSecp256k1Key as e4, type GenerateAccount as e5, NetworkToIndexerAPI as e6, NetworkToNodeAPI as e7, NetworkToFaucetAPI as e8, NetworkToPepperAPI as e9, NetworkToProverAPI as ea, Network as eb, NetworkToChainId as ec, NetworkToNetworkName as ed, DEFAULT_MAX_GAS_AMOUNT as ee, DEFAULT_TXN_EXP_SEC_FROM_NOW as ef, DEFAULT_TXN_TIMEOUT_SEC as eg, APTOS_COIN as eh, APTOS_FA as ei, RAW_TRANSACTION_SALT as ej, RAW_TRANSACTION_WITH_DATA_SALT as ek, ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT as el, FIREBASE_AUTH_ISS_PATTERN as em, Serializable as f, EphemeralCertificateVariant as g, type AccountAddressInput as h, PrivateKey as i, Hex as j, Ed25519PublicKey as k, AnyPublicKey as l, MultiEd25519PublicKey as m, Ed25519Signature as n, MultiEd25519Signature as o, AccountAuthenticator as p, MoveString as q, MoveVector as r, U64 as s, type AnyNumber as t, type SimpleEntryFunctionArgumentTypes as u, type EntryFunctionArgumentTypes as v, U16 as w, U32 as x, U128 as y, U256 as z };
+export { type InputViewFunctionDataWithABI as $, AccountAddress as A, Bool as B, type InputGenerateTransactionPayloadData as C, Deserializer as D, EphemeralPublicKeyVariant as E, FixedBytes as F, type InputScriptData as G, type HexInput as H, type InputGenerateTransactionPayloadDataWithRemoteABI as I, type MoveFunction as J, type InputEntryFunctionDataWithRemoteABI as K, type LedgerVersionArg as L, MultiKey as M, TransactionPayloadEntryFunction as N, type InputMultiSigDataWithRemoteABI as O, PublicKey as P, TransactionPayloadMultiSig as Q, RawTransaction as R, Serializer as S, TransactionPayloadScript as T, U8 as U, type VerifySignatureArgs as V, type InputEntryFunctionDataWithABI as W, type InputMultiSigDataWithABI as X, type InputViewFunctionDataWithRemoteABI as Y, ZkpVariant as Z, EntryFunction as _, AccountPublicKey as a, type GasEstimation as a$, type AnyTransactionPayloadInstance as a0, type InputGenerateTransactionOptions as a1, TransactionInnerPayload as a2, type InputGenerateSingleSignerRawTransactionArgs as a3, SimpleTransaction as a4, type InputGenerateMultiAgentRawTransactionArgs as a5, MultiAgentTransaction as a6, type InputSimulateTransactionData as a7, AccountAuthenticatorNoAccountAuthenticator as a8, AccountAuthenticatorEd25519 as a9, type PrivateKeyInput as aA, type GetCollectionDataResponse as aB, type GetTokenDataResponse as aC, type GetCurrentTokenOwnershipResponse as aD, type GetOwnedTokensResponse as aE, type GetTokenActivityResponse as aF, type WaitForTransactionOptions as aG, type UserTransactionResponse as aH, type GetFungibleAssetMetadataResponse as aI, type GetFungibleAssetActivitiesResponse as aJ, type GetCurrentFungibleAssetBalancesResponse as aK, type LedgerInfo as aL, type Block as aM, type MoveValue as aN, type InputViewFunctionData as aO, type InputViewFunctionJsonData as aP, type GetChainTopUserTransactionsResponse as aQ, type GraphqlQuery as aR, ProcessorType as aS, type GetProcessorStatusResponse as aT, type GetANSNameResponse as aU, type GetNumberOfDelegatorsResponse as aV, type GetDelegatedStakingActivitiesResponse as aW, type InputSimulateTransactionOptions as aX, type InputTransactionPluginData as aY, type PendingTransactionResponse as aZ, type CommittedTransactionResponse as a_, AccountAuthenticatorSingleKey as aa, AccountAuthenticatorMultiKey as ab, type InputSubmitTransactionData as ac, type TypeArgument as ad, TypeTag as ae, type MoveModule as af, type FunctionABI as ag, type EntryFunctionABI as ah, type ViewFunctionABI as ai, type AnyRawTransaction as aj, type AnyRawTransactionInstance as ak, type AccountData as al, type MoveModuleBytecode as am, type CursorPaginationArgs as an, type PaginationArgs as ao, type TransactionResponse as ap, type MoveResource as aq, type MoveStructId as ar, type TokenStandardArg as as, type OrderByArg as at, type GetAccountOwnedTokensQueryResponse as au, type GetAccountOwnedTokensFromCollectionResponse as av, type GetAccountCollectionsWithOwnedTokenResponse as aw, type GetAccountCoinsDataResponse as ax, type WhereArg as ay, type GetObjectDataQueryResponse as az, AuthenticationKey as b, TypeTagBool as b$, Ed25519PrivateKey as b0, type TableItemRequest as b1, type GetTableItemsDataResponse as b2, type GetTableItemsMetadataResponse as b3, SigningScheme as b4, SigningSchemeInput as b5, AnySignature as b6, type EntryFunctionArgument as b7, MultiKeySignature as b8, AccountAuthenticatorMultiEd25519 as b9, AbstractMultiKey as bA, Secp256k1PublicKey as bB, Secp256k1PrivateKey as bC, Secp256k1Signature as bD, HexInvalidReason as bE, hexToAsciiString as bF, AccountAbstractionMessage as bG, ChainId as bH, Identifier as bI, ModuleId as bJ, RawTransactionWithData as bK, MultiAgentRawTransaction as bL, FeePayerRawTransaction as bM, type TransactionArgument as bN, type ScriptFunctionArgument as bO, deserializeFromScriptArgument as bP, TransactionPayload as bQ, Script as bR, MultiSig as bS, MultiSigTransactionPayload as bT, TransactionInnerPayloadV1 as bU, TransactionExecutable as bV, TransactionExecutableScript as bW, TransactionExecutableEntryFunction as bX, TransactionExecutableEmpty as bY, TransactionExtraConfig as bZ, TransactionExtraConfigV1 as b_, AccountAuthenticatorAbstraction as ba, type MoveFunctionId as bb, type ClientRequest as bc, type Client as bd, type ClientResponse as be, type AptosRequest as bf, AptosApiType as bg, type AptosResponse as bh, MimeType as bi, type ClientConfig as bj, type Deserializable as bk, ensureBoolean as bl, outOfRangeErrorMessage as bm, validateNumberInRange as bn, I8 as bo, I16 as bp, I32 as bq, I64 as br, I128 as bs, I256 as bt, Serialized as bu, MoveOption as bv, AddressInvalidReason as bw, ParsingError as bx, type ParsingResult as by, isCanonicalEd25519Signature as bz, type VerifySignatureAsyncArgs as c, type Int128 as c$, TypeTagU8 as c0, TypeTagI8 as c1, TypeTagU16 as c2, TypeTagI16 as c3, TypeTagU32 as c4, TypeTagI32 as c5, TypeTagU64 as c6, TypeTagI64 as c7, TypeTagU128 as c8, TypeTagI128 as c9, type OrderBy as cA, type OrderByValue as cB, type TokenStandard as cC, TypeTagVariants as cD, ScriptTransactionArgumentVariants as cE, TransactionPayloadVariants as cF, TransactionInnerPayloadVariants as cG, TransactionExecutableVariants as cH, TransactionExtraConfigVariants as cI, TransactionVariants as cJ, TransactionAuthenticatorVariant as cK, AccountAuthenticatorVariant as cL, PrivateKeyVariants as cM, AnyPublicKeyVariant as cN, anyPublicKeyVariantToString as cO, AnySignatureVariant as cP, EphemeralSignatureVariant as cQ, type Uint8 as cR, type Uint16 as cS, type Uint32 as cT, type Uint64 as cU, type Uint128 as cV, type Uint256 as cW, type Int8 as cX, type Int16 as cY, type Int32 as cZ, type Int64 as c_, TypeTagU256 as ca, TypeTagI256 as cb, TypeTagAddress as cc, TypeTagSigner as cd, TypeTagReference as ce, TypeTagGeneric as cf, TypeTagVector as cg, TypeTagStruct as ch, StructTag as ci, aptosCoinStructTag as cj, stringStructTag as ck, optionStructTag as cl, objectStructTag as cm, type ScriptFunctionArgumentTypes as cn, type InputGenerateSequenceNumberTransactionOptions as co, type InputGenerateOrderlessTransactionOptions as cp, type InputEntryFunctionData as cq, type InputGenerateTransactionPayloadDataWithABI as cr, type InputMultiSigData as cs, type ViewFunctionJsonPayload as ct, type InputGenerateRawTransactionArgs as cu, type InputGenerateSingleSignerRawTransactionData as cv, type InputGenerateMultiAgentRawTransactionData as cw, type InputGenerateTransactionData as cx, type GetAccountAddressesForAuthKeyResponse as cy, type GetEventsResponse as cz, Signature as d, type MoveUint128Type as d$, type Int256 as d0, type AptosSettings as d1, type FullNodeConfig as d2, type IndexerConfig as d3, type FaucetConfig as d4, type TransactionGenerationConfig as d5, type ClientHeadersType as d6, type PluginConfig as d7, type PluginSettings as d8, type TransactionSubmitter as d9, type ScriptPayloadResponse as dA, type MultisigPayloadResponse as dB, type GenesisPayload as dC, type MoveScriptBytecode as dD, type TransactionSignature as dE, isEd25519Signature as dF, isSecp256k1Signature as dG, isMultiAgentSignature as dH, isFeePayerSignature as dI, isMultiEd25519Signature as dJ, isSingleSenderSignature as dK, type TransactionEd25519Signature as dL, type TransactionSecp256k1Signature as dM, type TransactionSingleSenderSignature as dN, type TransactionMultiEd25519Signature as dO, type TransactionMultiAgentSignature as dP, type TransactionFeePayerSignature as dQ, type AccountSignature as dR, type WriteSet as dS, type ScriptWriteSet as dT, type DirectWriteSet as dU, type EventGuid as dV, type Event as dW, type MoveUint8Type as dX, type MoveUint16Type as dY, type MoveUint32Type as dZ, type MoveUint64Type as d_, TransactionResponseType as da, isPendingTransactionResponse as db, isUserTransactionResponse as dc, isGenesisTransactionResponse as dd, isBlockMetadataTransactionResponse as de, isStateCheckpointTransactionResponse as df, isValidatorTransactionResponse as dg, isBlockEpilogueTransactionResponse as dh, type GenesisTransactionResponse as di, type BlockMetadataTransactionResponse as dj, type StateCheckpointTransactionResponse as dk, type ValidatorTransactionResponse as dl, type BlockEndInfo as dm, type BlockEpilogueTransactionResponse as dn, type WriteSetChange as dp, type WriteSetChangeDeleteModule as dq, type WriteSetChangeDeleteResource as dr, type WriteSetChangeDeleteTableItem as ds, type WriteSetChangeWriteModule as dt, type WriteSetChangeWriteResource as du, type WriteSetChangeWriteTableItem as dv, type DecodedTableData as dw, type DeletedTableData as dx, type TransactionPayloadResponse as dy, type EntryFunctionPayloadResponse as dz, AptosConfig as e, type MoveUint256Type as e0, type MoveAddressType as e1, type MoveObjectType as e2, type MoveOptionType as e3, type MoveStructType as e4, type MoveType as e5, type MoveModuleId as e6, MoveFunctionVisibility as e7, MoveAbility as e8, type MoveFunctionGenericTypeParam as e9, type MoveStructField as ea, type MoveStruct as eb, RoleType as ec, type AuthenticationKeyScheme as ed, DeriveScheme as ee, type GenerateAccountWithEd25519 as ef, type GenerateAccountWithSingleSignerSecp256k1Key as eg, type GenerateAccount as eh, NetworkToIndexerAPI as ei, NetworkToNodeAPI as ej, NetworkToFaucetAPI as ek, NetworkToPepperAPI as el, NetworkToProverAPI as em, Network as en, NetworkToChainId as eo, NetworkToNetworkName as ep, DEFAULT_MAX_GAS_AMOUNT as eq, DEFAULT_TXN_EXP_SEC_FROM_NOW as er, DEFAULT_TXN_TIMEOUT_SEC as es, APTOS_COIN as et, APTOS_FA as eu, RAW_TRANSACTION_SALT as ev, RAW_TRANSACTION_WITH_DATA_SALT as ew, ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT as ex, FIREBASE_AUTH_ISS_PATTERN as ey, Serializable as f, EphemeralCertificateVariant as g, type AccountAddressInput as h, PrivateKey as i, Hex as j, Ed25519PublicKey as k, AnyPublicKey as l, MultiEd25519PublicKey as m, Ed25519Signature as n, MultiEd25519Signature as o, AccountAuthenticator as p, MoveString as q, MoveVector as r, U64 as s, type AnyNumber as t, type SimpleEntryFunctionArgumentTypes as u, type EntryFunctionArgumentTypes as v, U16 as w, U32 as x, U128 as y, U256 as z };

package/dist/common/chunk-HO5ESTN4.js

@@ -0,0 +1,4 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var L=Object.defineProperty;var $=Object.getOwnPropertyDescriptor;var d=(r,e,t,n)=>{for(var s=n>1?void 0:n?$(e,t):e,o=r.length-1,c;o>=0;o--)(c=r[o])&&(s=(n?c(e,t,s):c(s))||s);return n&&s&&L(e,t,s),s};var u=class extends Error{constructor(e,t){super(e),this.invalidReason=t}};var _utils = require('@noble/hashes/utils');var j=(n=>(n.TOO_SHORT="too_short",n.INVALID_LENGTH="invalid_length",n.INVALID_HEX_CHARS="invalid_hex_chars",n))(j||{}),x= exports.v =class r{constructor(e){this.data=e}toUint8Array(){return this.data}toStringWithoutPrefix(){return _utils.bytesToHex.call(void 0, this.data)}toString(){return`0x${this.toStringWithoutPrefix()}`}static fromHexString(e){let t=e;if(t.startsWith("0x")&&(t=t.slice(2)),t.length===0)throw new u("Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.","too_short");if(t.length%2!==0)throw new u("Hex string must be an even number of hex characters.","invalid_length");try{return new r(_utils.hexToBytes.call(void 0, t))}catch(n){throw new u(`Hex string contains invalid hex characters: ${_optionalChain([n, 'optionalAccess', _2 => _2.message])}`,"invalid_hex_chars")}}static fromHexInput(e){return e instanceof Uint8Array?new r(e):r.fromHexString(e)}static hexInputToUint8Array(e){return e instanceof Uint8Array?e:r.fromHexString(e).toUint8Array()}static hexInputToString(e){return r.fromHexInput(e).toString()}static hexInputToStringWithoutPrefix(e){return r.fromHexInput(e).toStringWithoutPrefix()}static isValid(e){try{return r.fromHexString(e),{valid:!0}}catch(t){return{valid:!1,invalidReason:_optionalChain([t, 'optionalAccess', _3 => _3.invalidReason]),invalidReasonMessage:_optionalChain([t, 'optionalAccess', _4 => _4.message])}}}equals(e){return this.data.length!==e.data.length?!1:this.data.every((t,n)=>t===e.data[n])}},Be= exports.w =r=>new TextDecoder().decode(x.fromHexInput(r).toUint8Array());var U=255,M= exports.c =65535,f= exports.d =4294967295,m= exports.e =18446744073709551615n,I= exports.f =340282366920938463463374607431768211455n,T= exports.g =115792089237316195423570985008687907853269984665640564039457584007913129639935n,v= exports.h =-128,B= exports.i =127,N= exports.j =-32768,E= exports.k =32767,C= exports.l =-2147483648,w= exports.m =2147483647,k= exports.n =-9223372036854775808n,O= exports.o =9223372036854775807n,G= exports.p =-170141183460469231731687303715884105728n,D= exports.q =170141183460469231731687303715884105727n,z= exports.r =-57896044618658097711785492504343953926634992332820282019728792003956564819968n,F= exports.s =57896044618658097711785492504343953926634992332820282019728792003956564819967n;var b=class{bcsToBytes(){let e=new g;return this.serialize(e),e.toUint8Array()}bcsToHex(){let e=this.bcsToBytes();return x.fromHexInput(e)}toStringWithoutPrefix(){return this.bcsToHex().toStringWithoutPrefix()}toString(){return`0x${this.toStringWithoutPrefix()}`}},g= exports.y =class{constructor(e=64){if(e<=0)throw new Error("Length needs to be greater than 0");this.buffer=new ArrayBuffer(e),this.offset=0}ensureBufferWillHandleSize(e){for(;this.buffer.byteLength<this.offset+e;){let t=new ArrayBuffer(this.buffer.byteLength*2);new Uint8Array(t).set(new Uint8Array(this.buffer)),this.buffer=t}}appendToBuffer(e){this.ensureBufferWillHandleSize(e.length),new Uint8Array(this.buffer,this.offset).set(e),this.offset+=e.length}serializeWithFunction(e,t,n){this.ensureBufferWillHandleSize(t);let s=new DataView(this.buffer,this.offset);e.apply(s,[0,n,!0]),this.offset+=t}serializeStr(e){let t=new TextEncoder;this.serializeBytes(t.encode(e))}serializeBytes(e){this.serializeU32AsUleb128(e.length),this.appendToBuffer(e)}serializeFixedBytes(e){this.appendToBuffer(e)}serializeBool(e){K(e);let t=e?1:0;this.appendToBuffer(new Uint8Array([t]))}serializeU8(e){this.appendToBuffer(new Uint8Array([e]))}serializeU16(e){this.serializeWithFunction(DataView.prototype.setUint16,2,e)}serializeU32(e){this.serializeWithFunction(DataView.prototype.setUint32,4,e)}serializeU64(e){let t=BigInt(e)&BigInt(f),n=BigInt(e)>>BigInt(32);this.serializeU32(Number(t)),this.serializeU32(Number(n))}serializeU128(e){let t=BigInt(e)&m,n=BigInt(e)>>BigInt(64);this.serializeU64(t),this.serializeU64(n)}serializeU256(e){let t=BigInt(e)&I,n=BigInt(e)>>BigInt(128);this.serializeU128(t),this.serializeU128(n)}serializeI8(e){this.serializeWithFunction(DataView.prototype.setInt8,1,e)}serializeI16(e){this.serializeWithFunction(DataView.prototype.setInt16,2,e)}serializeI32(e){this.serializeWithFunction(DataView.prototype.setInt32,4,e)}serializeI64(e){let t=BigInt(e),n=t<0?(BigInt(1)<<BigInt(64))+t:t,s=n&BigInt(f),o=n>>BigInt(32);this.serializeU32(Number(s)),this.serializeU32(Number(o))}serializeI128(e){let t=BigInt(e),n=t<0?(BigInt(1)<<BigInt(128))+t:t,s=n&m,o=n>>BigInt(64);this.serializeU64(s),this.serializeU64(o)}serializeI256(e){let t=BigInt(e),n=t<0?(BigInt(1)<<BigInt(256))+t:t,s=n&I,o=n>>BigInt(128);this.serializeU128(s),this.serializeU128(o)}serializeU32AsUleb128(e){let t=e,n=[];for(;t>>>7;)n.push(t&127|128),t>>>=7;n.push(t),this.appendToBuffer(new Uint8Array(n))}toUint8Array(){return new Uint8Array(this.buffer).slice(0,this.offset)}serialize(e){e.serialize(this)}serializeVector(e){this.serializeU32AsUleb128(e.length),e.forEach(t=>{t.serialize(this)})}serializeOption(e,t){let n=e!==void 0;this.serializeBool(n),n&&(typeof e=="string"?this.serializeStr(e):e instanceof Uint8Array?t!==void 0?this.serializeFixedBytes(e):this.serializeBytes(e):e.serialize(this))}serializeOptionStr(e){e===void 0?this.serializeU32AsUleb128(0):(this.serializeU32AsUleb128(1),this.serializeStr(e))}};d([l(0,U)],g.prototype,"serializeU8",1),d([l(0,M)],g.prototype,"serializeU16",1),d([l(0,f)],g.prototype,"serializeU32",1),d([l(BigInt(0),m)],g.prototype,"serializeU64",1),d([l(BigInt(0),I)],g.prototype,"serializeU128",1),d([l(BigInt(0),T)],g.prototype,"serializeU256",1),d([l(v,B)],g.prototype,"serializeI8",1),d([l(N,E)],g.prototype,"serializeI16",1),d([l(C,w)],g.prototype,"serializeI32",1),d([l(k,O)],g.prototype,"serializeI64",1),d([l(G,D)],g.prototype,"serializeI128",1),d([l(z,F)],g.prototype,"serializeI256",1),d([l(0,f)],g.prototype,"serializeU32AsUleb128",1);function K(r){if(typeof r!="boolean")throw new Error(`${r} is not a boolean value`)}var Y=(r,e,t)=>`${r} is out of range: [${e}, ${t}]`;function Z(r,e,t){let n=BigInt(r);if(n>BigInt(t)||n<BigInt(e))throw new Error(Y(r,e,t))}function l(r,e){return(t,n,s)=>{let o=s.value;return s.value=function(_){return Z(_,r,e),o.apply(this,[_])},s}}var Q=(s=>(s.JSON="application/json",s.BCS="application/x-bcs",s.BCS_SIGNED_TRANSACTION="application/x.aptos.signed_transaction+bcs",s.BCS_VIEW_FUNCTION="application/x.aptos.view_function+bcs",s))(Q||{}),J= exports.D =(i=>(i[i.Bool=0]="Bool",i[i.U8=1]="U8",i[i.U64=2]="U64",i[i.U128=3]="U128",i[i.Address=4]="Address",i[i.Signer=5]="Signer",i[i.Vector=6]="Vector",i[i.Struct=7]="Struct",i[i.U16=8]="U16",i[i.U32=9]="U32",i[i.U256=10]="U256",i[i.I8=11]="I8",i[i.I16=12]="I16",i[i.I32=13]="I32",i[i.I64=14]="I64",i[i.I128=15]="I128",i[i.I256=16]="I256",i[i.Reference=254]="Reference",i[i.Generic=255]="Generic",i))(J||{}),H= exports.E =(p=>(p[p.U8=0]="U8",p[p.U64=1]="U64",p[p.U128=2]="U128",p[p.Address=3]="Address",p[p.U8Vector=4]="U8Vector",p[p.Bool=5]="Bool",p[p.U16=6]="U16",p[p.U32=7]="U32",p[p.U256=8]="U256",p[p.Serialized=9]="Serialized",p))(H||{}),V= exports.F =(s=>(s[s.Script=0]="Script",s[s.EntryFunction=2]="EntryFunction",s[s.Multisig=3]="Multisig",s[s.Payload=4]="Payload",s))(V||{}),ee= exports.G =(e=>(e[e.V1=0]="V1",e))(ee||{}),te= exports.H =(n=>(n[n.Script=0]="Script",n[n.EntryFunction=1]="EntryFunction",n[n.Empty=2]="Empty",n))(te||{}),re= exports.I =(e=>(e[e.V1=0]="V1",e))(re||{}),ne= exports.J =(t=>(t[t.MultiAgentTransaction=0]="MultiAgentTransaction",t[t.FeePayerTransaction=1]="FeePayerTransaction",t))(ne||{}),se= exports.K =(o=>(o[o.Ed25519=0]="Ed25519",o[o.MultiEd25519=1]="MultiEd25519",o[o.MultiAgent=2]="MultiAgent",o[o.FeePayer=3]="FeePayer",o[o.SingleSender=4]="SingleSender",o))(se||{}),oe= exports.L =(c=>(c[c.Ed25519=0]="Ed25519",c[c.MultiEd25519=1]="MultiEd25519",c[c.SingleKey=2]="SingleKey",c[c.MultiKey=3]="MultiKey",c[c.NoAccountAuthenticator=4]="NoAccountAuthenticator",c[c.Abstraction=5]="Abstraction",c))(oe||{}),ie= exports.M =(n=>(n.Ed25519="ed25519",n.Secp256k1="secp256k1",n.Secp256r1="secp256r1",n))(ie||{}),ae= exports.N =(o=>(o[o.Ed25519=0]="Ed25519",o[o.Secp256k1=1]="Secp256k1",o[o.Secp256r1=2]="Secp256r1",o[o.Keyless=3]="Keyless",o[o.FederatedKeyless=4]="FederatedKeyless",o))(ae||{});function Ge(r){switch(r){case 0:return"ed25519";case 1:return"secp256k1";case 2:return"secp256r1";case 3:return"keyless";case 4:return"federated_keyless";default:throw new Error("Unknown public key variant")}}var pe=(s=>(s[s.Ed25519=0]="Ed25519",s[s.Secp256k1=1]="Secp256k1",s[s.WebAuthn=2]="WebAuthn",s[s.Keyless=3]="Keyless",s))(pe||{}),ce= exports.Q =(e=>(e[e.Ed25519=0]="Ed25519",e))(ce||{}),ue= exports.R =(e=>(e[e.Ed25519=0]="Ed25519",e))(ue||{}),ge= exports.S =(e=>(e[e.ZkProof=0]="ZkProof",e))(ge||{}),de= exports.T =(e=>(e[e.Groth16=0]="Groth16",e))(de||{}),le= exports.U =(_=>(_.Pending="pending_transaction",_.User="user_transaction",_.Genesis="genesis_transaction",_.BlockMetadata="block_metadata_transaction",_.StateCheckpoint="state_checkpoint_transaction",_.Validator="validator_transaction",_.BlockEpilogue="block_epilogue_transaction",_))(le||{});function De(r){return r.type==="pending_transaction"}function ze(r){return r.type==="user_transaction"}function Fe(r){return r.type==="genesis_transaction"}function He(r){return r.type==="block_metadata_transaction"}function We(r){return r.type==="state_checkpoint_transaction"}function Pe(r){return r.type==="validator_transaction"}function Le(r){return r.type==="block_epilogue_transaction"}function $e(r){return"signature"in r&&r.type==="ed25519_signature"}function Xe(r){return"signature"in r&&r.signature==="secp256k1_ecdsa_signature"}function qe(r){return r.type==="multi_agent_signature"}function je(r){return r.type==="fee_payer_signature"}function Ke(r){return r.type==="multi_ed25519_signature"}function Ye(r){return r.type==="single_sender"}var ye=(n=>(n.PRIVATE="private",n.PUBLIC="public",n.FRIEND="friend",n))(ye||{}),_e= exports.ha =(s=>(s.STORE="store",s.DROP="drop",s.KEY="key",s.COPY="copy",s))(_e||{}),he= exports.ia =(t=>(t.VALIDATOR="validator",t.FULL_NODE="full_node",t))(he||{}),xe= exports.ja =(s=>(s[s.Ed25519=0]="Ed25519",s[s.MultiEd25519=1]="MultiEd25519",s[s.SingleKey=2]="SingleKey",s[s.MultiKey=3]="MultiKey",s))(xe||{}),fe= exports.ka =(t=>(t[t.Ed25519=0]="Ed25519",t[t.Secp256k1Ecdsa=2]="Secp256k1Ecdsa",t))(fe||{}),W= exports.la =(o=>(o[o.DeriveAuid=251]="DeriveAuid",o[o.DeriveObjectAddressFromObject=252]="DeriveObjectAddressFromObject",o[o.DeriveObjectAddressFromGuid=253]="DeriveObjectAddressFromGuid",o[o.DeriveObjectAddressFromSeed=254]="DeriveObjectAddressFromSeed",o[o.DeriveResourceAccountAddress=255]="DeriveResourceAccountAddress",o))(W||{});var Ie=(h=>(h.INCORRECT_NUMBER_OF_BYTES="incorrect_number_of_bytes",h.INVALID_HEX_CHARS="invalid_hex_chars",h.TOO_SHORT="too_short",h.TOO_LONG="too_long",h.LEADING_ZERO_X_REQUIRED="leading_zero_x_required",h.LONG_FORM_REQUIRED_UNLESS_SPECIAL="long_form_required_unless_special",h.INVALID_PADDING_ZEROES="INVALID_PADDING_ZEROES",h.INVALID_PADDING_STRICTNESS="INVALID_PADDING_STRICTNESS",h))(Ie||{}),a=class a extends b{constructor(e){if(super(),e.length!==a.LENGTH)throw new u("AccountAddress data should be exactly 32 bytes long","incorrect_number_of_bytes");this.data=e}isSpecial(){return this.data.slice(0,this.data.length-1).every(e=>e===0)&&this.data[this.data.length-1]<16}toString(){return`0x${this.toStringWithoutPrefix()}`}toStringWithoutPrefix(){let e=_utils.bytesToHex.call(void 0, this.data);return this.isSpecial()&&(e=e[e.length-1]),e}toStringLong(){return`0x${this.toStringLongWithoutPrefix()}`}toStringLongWithoutPrefix(){return _utils.bytesToHex.call(void 0, this.data)}toStringShort(){return`0x${this.toStringShortWithoutPrefix()}`}toStringShortWithoutPrefix(){let e=_utils.bytesToHex.call(void 0, this.data).replace(/^0+/,"");return e===""?"0":e}toUint8Array(){return this.data}serialize(e){e.serializeFixedBytes(this.data)}serializeForEntryFunction(e){let t=this.bcsToBytes();e.serializeBytes(t)}serializeForScriptFunction(e){e.serializeU32AsUleb128(3),e.serialize(this)}static deserialize(e){let t=e.deserializeFixedBytes(a.LENGTH);return new a(t)}static fromStringStrict(e){if(!e.startsWith("0x"))throw new u("Hex string must start with a leading 0x.","leading_zero_x_required");let t=a.fromString(e);if(e.length!==a.LONG_STRING_LENGTH+2)if(t.isSpecial()){if(e.length!==3)throw new u(`The given hex string ${e} is a special address not in LONG form, it must be 0x0 to 0xf without padding zeroes.`,"INVALID_PADDING_ZEROES")}else throw new u(`The given hex string ${e} is not a special address, it must be represented as 0x + 64 chars.`,"long_form_required_unless_special");return t}static fromString(e,{maxMissingChars:t=4}={}){let n=e;if(e.startsWith("0x")&&(n=e.slice(2)),n.length===0)throw new u("Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.","too_short");if(n.length>64)throw new u("Hex string is too long, must be 1 to 64 chars long, excluding the leading 0x.","too_long");if(t>63||t<0)throw new u(`maxMissingChars must be between or equal to 0 and 63. Received ${t}`,"INVALID_PADDING_STRICTNESS");let s;try{s=_utils.hexToBytes.call(void 0, n.padStart(64,"0"))}catch(c){throw new u(`Hex characters are invalid: ${_optionalChain([c, 'optionalAccess', _5 => _5.message])}`,"invalid_hex_chars")}let o=new a(s);if(n.length<64-t&&!o.isSpecial())throw new u(`Hex string is too short, must be ${64-t} to 64 chars long, excluding the leading 0x. You may need to fix 
+the addresss by padding it with 0s before passing it to \`fromString\` (e.g. <addressString>.padStart(64, '0')). 
+Received ${e}`,"too_short");return o}static from(e,{maxMissingChars:t=4}={}){return typeof e=="string"?a.fromString(e,{maxMissingChars:t}):e instanceof Uint8Array?new a(e):e}static fromStrict(e){return typeof e=="string"?a.fromStringStrict(e):e instanceof Uint8Array?new a(e):e}static isValid(e){try{return e.strict?a.fromStrict(e.input):a.from(e.input),{valid:!0}}catch(t){return{valid:!1,invalidReason:_optionalChain([t, 'optionalAccess', _6 => _6.invalidReason]),invalidReasonMessage:_optionalChain([t, 'optionalAccess', _7 => _7.message])}}}equals(e){return this.data.length!==e.data.length?!1:this.data.every((t,n)=>t===e.data[n])}};a.LENGTH=32,a.LONG_STRING_LENGTH=64,a.ZERO=a.from("0x0"),a.ONE=a.from("0x1"),a.TWO=a.from("0x2"),a.THREE=a.from("0x3"),a.FOUR=a.from("0x4"),a.A=a.from("0xA");var y=a;var _sha3 = require('@noble/hashes/sha3');var R=(r,e)=>{let t=r.bcsToBytes(),n=typeof e=="string"?Buffer.from(e,"utf8"):e,s=new Uint8Array([...t,...n,254]);return new y(_sha3.sha3_256.call(void 0, s))},gt= exports.pa =(r,e)=>{let t=r.bcsToBytes(),n=typeof e=="string"?Buffer.from(e,"utf8"):e,s=new Uint8Array([...t,...n,255]);return new y(_sha3.sha3_256.call(void 0, s))},dt= exports.qa =(r,e)=>{let t=r.bcsToBytes(),n=e.bcsToBytes(),s=new Uint8Array([...t,...n,252]);return new y(_sha3.sha3_256.call(void 0, s))},lt= exports.ra =(r,e,t)=>{let n=`${e}::${t}`;return R(r,n)};var _jsbase64 = require('js-base64');async function ft(r){return new Promise(e=>{setTimeout(e,r)})}function mt(r){return r instanceof Error?r.message:String(r)}var It=()=>Math.floor(Date.now()/1e3);function bt(r){let e=new Date(r*1e3);return e.setMinutes(0),e.setSeconds(0),e.setMilliseconds(0),Math.floor(e.getTime()/1e3)}function At(r){let e=r.replace(/-/g,"+").replace(/_/g,"/"),t=e+"==".substring(0,(3-e.length%3)%3);return _jsbase64.decode.call(void 0, t)}function St(r){let e=r.replace(/-/g,"+").replace(/_/g,"/");for(;e.length%4!==0;)e+="=";return new Uint8Array(Buffer.from(e,"base64"))}var Rt=(r,e)=>r*10**e,Ut= exports.za =(r,e)=>r/10**e,P=r=>{let e="";for(let t=2;t<r.length;t+=2)e+=String.fromCharCode(parseInt(r.substring(t,t+2),16));return e},Mt= exports.Aa =r=>{let{account_address:e,module_name:t,struct_name:n}=r,s=P(t),o=P(n);return`${e}::${s}::${o}`},Tt= exports.Ba =r=>typeof r=="object"&&!Array.isArray(r)&&r!==null&&"account_address"in r&&"module_name"in r&&"struct_name"in r&&typeof r.account_address=="string"&&typeof r.module_name=="string"&&typeof r.struct_name=="string";function vt(r){let e=r.split("::");if(e.length!==3)throw new Error(`Invalid function ${r}`);let t=e[0],n=e[1],s=e[2];return{moduleAddress:t,moduleName:n,functionName:s}}function Bt(r){let e=r.split("::");return e.length===3&&y.isValid({input:e[0]}).valid}function Nt(r,e=6,t=5){return`${r.slice(0,e)}...${r.slice(-t)}`}var Ae="0x1::aptos_coin::AptosCoin",Et=y.A.toStringLong();function Se(r){let e=/0x[0-9a-fA-F]+/g;return r.replace(e,t=>y.from(t,{maxMissingChars:63}).toStringShort())}function Ct(r){let e=Se(r);return e===Ae?y.A:R(y.A,e)}exports.a = d; exports.b = U; exports.c = M; exports.d = f; exports.e = m; exports.f = I; exports.g = T; exports.h = v; exports.i = B; exports.j = N; exports.k = E; exports.l = C; exports.m = w; exports.n = k; exports.o = O; exports.p = G; exports.q = D; exports.r = z; exports.s = F; exports.t = u; exports.u = j; exports.v = x; exports.w = Be; exports.x = b; exports.y = g; exports.z = K; exports.A = Y; exports.B = Z; exports.C = Q; exports.D = J; exports.E = H; exports.F = V; exports.G = ee; exports.H = te; exports.I = re; exports.J = ne; exports.K = se; exports.L = oe; exports.M = ie; exports.N = ae; exports.O = Ge; exports.P = pe; exports.Q = ce; exports.R = ue; exports.S = ge; exports.T = de; exports.U = le; exports.V = De; exports.W = ze; exports.X = Fe; exports.Y = He; exports.Z = We; exports._ = Pe; exports.$ = Le; exports.aa = $e; exports.ba = Xe; exports.ca = qe; exports.da = je; exports.ea = Ke; exports.fa = Ye; exports.ga = ye; exports.ha = _e; exports.ia = he; exports.ja = xe; exports.ka = fe; exports.la = W; exports.ma = Ie; exports.na = y; exports.oa = R; exports.pa = gt; exports.qa = dt; exports.ra = lt; exports.sa = ft; exports.ta = mt; exports.ua = It; exports.va = bt; exports.wa = At; exports.xa = St; exports.ya = Rt; exports.za = Ut; exports.Aa = Mt; exports.Ba = Tt; exports.Ca = vt; exports.Da = Bt; exports.Ea = Nt; exports.Fa = Ct;
+//# sourceMappingURL=chunk-HO5ESTN4.js.map