@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/common/{accountAddress-Ce4Cv60D.d.ts → accountAddress-jrha_M3l.d.ts}

@@ -1,14 +1,14 @@
 type GetAccountCoinsDataQuery = {
     current_fungible_asset_balances: Array<{
-        amount: any;
-        asset_type: string;
+        amount?: any | null;
+        asset_type?: string | null;
         is_frozen: boolean;
-        is_primary: boolean;
+        is_primary?: boolean | null;
         last_transaction_timestamp?: any | null;
         last_transaction_version?: any | null;
         owner_address: string;
         storage_id: string;
-        token_standard: string;
+        token_standard?: string | null;
         metadata?: {
             token_standard: string;
             symbol: string;
@@ -185,15 +185,15 @@ type GetCollectionDataQuery = {
 };
 type GetCurrentFungibleAssetBalancesQuery = {
     current_fungible_asset_balances: Array<{
-        amount: any;
-        asset_type: string;
+        amount?: any | null;
+        asset_type?: string | null;
         is_frozen: boolean;
-        is_primary: boolean;
+        is_primary?: boolean | null;
         last_transaction_timestamp?: any | null;
         last_transaction_version?: any | null;
         owner_address: string;
         storage_id: string;
-        token_standard: string;
+        token_standard?: string | null;
     }>;
 };
 type GetDelegatedStakingActivitiesQuery = {
@@ -257,15 +257,6 @@ type GetFungibleAssetMetadataQuery = {
         maximum_v2?: any | null;
     }>;
 };
-type GetMultiKeyForAuthKeyQuery = {
-    auth_key_multikey_layout: Array<{
-        auth_key: string;
-        last_transaction_version: any;
-        multikey_layout_with_prefixes: any;
-        multikey_type: string;
-        signatures_required: any;
-    }>;
-};
 type GetNamesQuery = {
     current_aptos_names: Array<{
         domain?: string | null;
@@ -303,18 +294,6 @@ type GetProcessorStatusQuery = {
         last_updated: any;
     }>;
 };
-type GetSignaturesQuery = {
-    signatures: Array<{
-        signature: string;
-        public_key: string;
-        public_key_indices: any;
-        type: string;
-        signer: string;
-        transaction_version: any;
-        threshold: any;
-        is_sender_primary: boolean;
-    }>;
-};
 type GetTableItemsDataQuery = {
     table_items: Array<{
         decoded_key: any;
@@ -573,18 +552,6 @@ type GetTableItemsDataResponse = GetTableItemsDataQuery["table_items"];
  * @category Types
  */
 type GetTableItemsMetadataResponse = GetTableItemsMetadataQuery["table_metadatas"];
-/**
- * The response containing the multikey for an authentication key.
- * @group Implementation
- * @category Types
- */
-type GetMultiKeyForAuthKeyResponse = GetMultiKeyForAuthKeyQuery["auth_key_multikey_layout"][0];
-/**
- * The response containing the account transactions for an account.
- * @group Implementation
- * @category Types
- */
-type GetSignaturesResponse = GetSignaturesQuery["signatures"][0];
 /**
  * The response containing the current Aptos names from the GetNamesQuery.
  * @group Implementation
@@ -1509,7 +1476,7 @@ type MoveScriptBytecode = {
 /**
  * JSON representations of transaction signatures returned from the node API.
  */
-type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature | TransactionMultiAgentSignature | TransactionFeePayerSignature | TransactionSingleSenderSignature;
+type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature | TransactionMultiAgentSignature | TransactionFeePayerSignature;
 /**
  * Determine if the provided signature is an Ed25519 signature.
  * This function checks for the presence of the "signature" property
@@ -1518,7 +1485,7 @@ type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Si
  * @param signature - The transaction signature to be checked.
  * @returns A boolean indicating whether the signature is an Ed25519 signature.
  */
-declare function isEd25519Signature(signature: TransactionSignature): signature is TransactionEd25519Signature;
+declare function isEd25519Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
 /**
  * Determine if the provided signature is a valid secp256k1 ECDSA signature.
  *
@@ -1547,27 +1514,6 @@ declare function isFeePayerSignature(signature: TransactionSignature): signature
  * @returns A boolean indicating whether the signature is a multi-ed25519 signature.
  */
 declare function isMultiEd25519Signature(signature: TransactionSignature): signature is TransactionMultiEd25519Signature;
-/**
- * Determine if the provided signature is of type "single_sender".
- *
- * @param signature - The transaction signature to check.
- * @returns A boolean indicating whether the signature is a single-sender signature.
- */
-declare function isSingleSenderSignature(signature: TransactionSignature): signature is TransactionSingleSenderSignature;
-/**
- * Determine if the provided signature is of type "single_sender".
- *
- * @param signature - The transaction signature to check.
- * @returns A boolean indicating whether the signature is a single-sender signature.
- */
-declare function isSingleSenderSingleKeySignature(signature: TransactionSignature): signature is TransactionSingleSenderSingleKeySignature;
-/**
- * Determine if the provided signature is of type "single_sender".
- *
- * @param signature - The transaction signature to check.
- * @returns A boolean indicating whether the signature is a single-sender signature.
- */
-declare function isSingleSenderMultiKeySignature(signature: TransactionSignature): signature is TransactionSingleSenderMultiKeySignature;
 /**
  * The signature for a transaction using the Ed25519 algorithm.
  */
@@ -1584,40 +1530,6 @@ type TransactionSecp256k1Signature = {
     public_key: string;
     signature: "secp256k1_ecdsa_signature";
 };
-/**
- * The structure for a multi-signature transaction using Ed25519.
- */
-type TransactionSingleSenderSignature = TransactionSingleSenderSingleKeySignature | TransactionSingleSenderMultiKeySignature;
-type TransactionSingleSenderSingleKeySignature = {
-    type: "single_sender";
-    public_key: {
-        value: string;
-        type: string;
-    };
-    signature: {
-        value: string;
-        type: string;
-    };
-    signatures_required: never;
-};
-/**
- * The structure for a multi-signature transaction using Ed25519.
- */
-type TransactionSingleSenderMultiKeySignature = {
-    type: "single_sender";
-    public_keys: {
-        value: string;
-        type: string;
-    }[];
-    signatures: {
-        index: number;
-        signature: {
-            value: string;
-            type: string;
-        };
-    }[];
-    signatures_required: number;
-};
 /**
  * The structure for a multi-signature transaction using Ed25519.
  */
@@ -3217,4 +3129,4 @@ declare class AccountAddress extends Serializable implements TransactionArgument
     equals(other: AccountAddress): boolean;
 }
 
-export { type GetOwnedTokensResponse as $, type AnyNumber as A, type MoveResource as B, type Client as C, Deserializer as D, type EntryFunctionArgument as E, type FullNodeConfig as F, type TokenStandardArg as G, type HexInput as H, type IndexerConfig as I, type GetAccountOwnedTokensQueryResponse as J, type GetAccountOwnedTokensFromCollectionResponse as K, type LedgerVersionArg as L, type MoveModuleId as M, Network as N, type OrderByArg as O, PrivateKeyVariants as P, type GetAccountCollectionsWithOwnedTokenResponse as Q, type GetAccountCoinsDataResponse as R, Serializable as S, type TransactionArgument as T, type Uint8 as U, type GetObjectDataQueryResponse as V, type WhereArg as W, type GetCollectionDataResponse as X, type GetTokenDataResponse as Y, ZkpVariant as Z, type GetCurrentTokenOwnershipResponse as _, Serializer as a, type BlockEndInfo as a$, type GetTokenActivityResponse as a0, type GetEventsResponse as a1, type WaitForTransactionOptions as a2, type UserTransactionResponse as a3, type GetFungibleAssetMetadataResponse as a4, type GetFungibleAssetActivitiesResponse as a5, type GetCurrentFungibleAssetBalancesResponse as a6, type LedgerInfo as a7, type Block as a8, type GetChainTopUserTransactionsResponse as a9, type OrderBy as aA, type OrderByValue as aB, type TokenStandard as aC, TypeTagVariants as aD, ScriptTransactionArgumentVariants as aE, TransactionPayloadVariants as aF, TransactionVariants as aG, TransactionAuthenticatorVariant as aH, AccountAuthenticatorVariant as aI, AnySignatureVariant as aJ, EphemeralSignatureVariant as aK, type Uint64 as aL, type Uint128 as aM, type Uint256 as aN, type ClientHeadersType as aO, TransactionResponseType as aP, isPendingTransactionResponse as aQ, isUserTransactionResponse as aR, isGenesisTransactionResponse as aS, isBlockMetadataTransactionResponse as aT, isStateCheckpointTransactionResponse as aU, isValidatorTransactionResponse as aV, isBlockEpilogueTransactionResponse as aW, type GenesisTransactionResponse as aX, type BlockMetadataTransactionResponse as aY, type StateCheckpointTransactionResponse as aZ, type ValidatorTransactionResponse as a_, type GraphqlQuery as aa, type GetProcessorStatusResponse as ab, type GetANSNameResponse as ac, type GetNumberOfDelegatorsResponse as ad, type GetDelegatedStakingActivitiesResponse as ae, type PendingTransactionResponse as af, type CommittedTransactionResponse as ag, type GasEstimation as ah, type TableItemRequest as ai, type GetTableItemsDataResponse as aj, type GetTableItemsMetadataResponse as ak, type ClientRequest as al, type ClientResponse as am, type AptosRequest as an, type AptosResponse as ao, MimeType as ap, ensureBoolean as aq, outOfRangeErrorMessage as ar, validateNumberInRange as as, AddressInvalidReason as at, ParsingError as au, type ParsingResult as av, HexInvalidReason as aw, hexToAsciiString as ax, type GetMultiKeyForAuthKeyResponse as ay, type GetSignaturesResponse as az, type Uint16 as b, NetworkToPepperAPI as b$, type BlockEpilogueTransactionResponse as b0, type WriteSetChange as b1, type WriteSetChangeDeleteModule as b2, type WriteSetChangeDeleteResource as b3, type WriteSetChangeDeleteTableItem as b4, type WriteSetChangeWriteModule as b5, type WriteSetChangeWriteResource as b6, type WriteSetChangeWriteTableItem as b7, type DecodedTableData as b8, type DeletedTableData as b9, type DirectWriteSet as bA, type EventGuid as bB, type Event as bC, type MoveUint8Type as bD, type MoveUint16Type as bE, type MoveUint32Type as bF, type MoveUint64Type as bG, type MoveUint128Type as bH, type MoveUint256Type as bI, type MoveAddressType as bJ, type MoveObjectType as bK, type MoveOptionType as bL, type MoveStructType as bM, type MoveType as bN, MoveFunctionVisibility as bO, MoveAbility as bP, type MoveStructField as bQ, type MoveModule as bR, type MoveStruct as bS, RoleType as bT, DeriveScheme as bU, type GenerateAccountWithEd25519 as bV, type GenerateAccountWithSingleSignerSecp256k1Key as bW, type GenerateAccount as bX, NetworkToIndexerAPI as bY, NetworkToNodeAPI as bZ, NetworkToFaucetAPI as b_, type TransactionPayloadResponse as ba, type EntryFunctionPayloadResponse as bb, type ScriptPayloadResponse as bc, type MultisigPayloadResponse as bd, type GenesisPayload as be, type MoveScriptBytecode as bf, type TransactionSignature as bg, isEd25519Signature as bh, isSecp256k1Signature as bi, isMultiAgentSignature as bj, isFeePayerSignature as bk, isMultiEd25519Signature as bl, isSingleSenderSignature as bm, isSingleSenderSingleKeySignature as bn, isSingleSenderMultiKeySignature as bo, type TransactionEd25519Signature as bp, type TransactionSecp256k1Signature as bq, type TransactionSingleSenderSignature as br, type TransactionSingleSenderSingleKeySignature as bs, type TransactionSingleSenderMultiKeySignature as bt, type TransactionMultiEd25519Signature as bu, type TransactionMultiAgentSignature as bv, type TransactionFeePayerSignature as bw, type AccountSignature as bx, type WriteSet as by, type ScriptWriteSet as bz, type Uint32 as c, NetworkToProverAPI as c0, NetworkToChainId as c1, NetworkToNetworkName as c2, type Deserializable as d, Hex as e, type AuthenticationKeyScheme as f, AccountAddress as g, AnyPublicKeyVariant as h, EphemeralPublicKeyVariant as i, type ClientConfig as j, type FaucetConfig as k, type AptosSettings as l, EphemeralCertificateVariant as m, type AccountAddressInput as n, type ScriptFunctionArgument as o, type MoveFunctionId as p, type MoveStructId as q, type MoveValue as r, type MoveFunctionGenericTypeParam as s, SigningSchemeInput as t, SigningScheme as u, type MoveFunction as v, type AccountData as w, type PaginationArgs as x, type MoveModuleBytecode as y, type TransactionResponse as z };
+export { type GetCurrentTokenOwnershipResponse as $, type AnyNumber as A, type TransactionResponse as B, type Client as C, Deserializer as D, type EntryFunctionArgument as E, type FullNodeConfig as F, type MoveResource as G, type HexInput as H, type IndexerConfig as I, type TokenStandardArg as J, type GetAccountOwnedTokensQueryResponse as K, type LedgerVersionArg as L, type MoveModuleId as M, Network as N, type OrderByArg as O, PrivateKeyVariants as P, type GetAccountOwnedTokensFromCollectionResponse as Q, type GetAccountCollectionsWithOwnedTokenResponse as R, Serializable as S, type TransactionArgument as T, type Uint8 as U, type GetAccountCoinsDataResponse as V, type WhereArg as W, type GetObjectDataQueryResponse as X, type GetCollectionDataResponse as Y, ZkpVariant as Z, type GetTokenDataResponse as _, Serializer as a, type BlockEpilogueTransactionResponse as a$, type GetOwnedTokensResponse as a0, type GetTokenActivityResponse as a1, type GetEventsResponse as a2, type WaitForTransactionOptions as a3, type UserTransactionResponse as a4, type GetFungibleAssetMetadataResponse as a5, type GetFungibleAssetActivitiesResponse as a6, type GetCurrentFungibleAssetBalancesResponse as a7, type LedgerInfo as a8, type Block as a9, type OrderByValue as aA, type TokenStandard as aB, TypeTagVariants as aC, ScriptTransactionArgumentVariants as aD, TransactionPayloadVariants as aE, TransactionVariants as aF, TransactionAuthenticatorVariant as aG, AccountAuthenticatorVariant as aH, AnySignatureVariant as aI, EphemeralSignatureVariant as aJ, type Uint64 as aK, type Uint128 as aL, type Uint256 as aM, type ClientHeadersType as aN, TransactionResponseType as aO, isPendingTransactionResponse as aP, isUserTransactionResponse as aQ, isGenesisTransactionResponse as aR, isBlockMetadataTransactionResponse as aS, isStateCheckpointTransactionResponse as aT, isValidatorTransactionResponse as aU, isBlockEpilogueTransactionResponse as aV, type GenesisTransactionResponse as aW, type BlockMetadataTransactionResponse as aX, type StateCheckpointTransactionResponse as aY, type ValidatorTransactionResponse as aZ, type BlockEndInfo as a_, type GetChainTopUserTransactionsResponse as aa, type GraphqlQuery as ab, type GetProcessorStatusResponse as ac, type GetANSNameResponse as ad, type GetNumberOfDelegatorsResponse as ae, type GetDelegatedStakingActivitiesResponse as af, type PendingTransactionResponse as ag, type CommittedTransactionResponse as ah, type GasEstimation as ai, type TableItemRequest as aj, type GetTableItemsDataResponse as ak, type GetTableItemsMetadataResponse as al, type ClientRequest as am, type ClientResponse as an, type AptosRequest as ao, type AptosResponse as ap, MimeType as aq, ensureBoolean as ar, outOfRangeErrorMessage as as, validateNumberInRange as at, AddressInvalidReason as au, ParsingError as av, type ParsingResult as aw, HexInvalidReason as ax, hexToAsciiString as ay, type OrderBy as az, type Uint16 as b, type WriteSetChange as b0, type WriteSetChangeDeleteModule as b1, type WriteSetChangeDeleteResource as b2, type WriteSetChangeDeleteTableItem as b3, type WriteSetChangeWriteModule as b4, type WriteSetChangeWriteResource as b5, type WriteSetChangeWriteTableItem as b6, type DecodedTableData as b7, type DeletedTableData as b8, type TransactionPayloadResponse as b9, type MoveUint128Type as bA, type MoveUint256Type as bB, type MoveAddressType as bC, type MoveObjectType as bD, type MoveOptionType as bE, type MoveStructType as bF, type MoveType as bG, MoveFunctionVisibility as bH, MoveAbility as bI, type MoveStructField as bJ, type MoveStruct as bK, RoleType as bL, DeriveScheme as bM, type GenerateAccountWithEd25519 as bN, type GenerateAccountWithSingleSignerSecp256k1Key as bO, type GenerateAccount as bP, NetworkToIndexerAPI as bQ, NetworkToNodeAPI as bR, NetworkToFaucetAPI as bS, NetworkToPepperAPI as bT, NetworkToProverAPI as bU, NetworkToChainId as bV, NetworkToNetworkName as bW, type EntryFunctionPayloadResponse as ba, type ScriptPayloadResponse as bb, type MultisigPayloadResponse as bc, type GenesisPayload as bd, type MoveScriptBytecode as be, type TransactionSignature as bf, isEd25519Signature as bg, isSecp256k1Signature as bh, isMultiAgentSignature as bi, isFeePayerSignature as bj, isMultiEd25519Signature as bk, type TransactionEd25519Signature as bl, type TransactionSecp256k1Signature as bm, type TransactionMultiEd25519Signature as bn, type TransactionMultiAgentSignature as bo, type TransactionFeePayerSignature as bp, type AccountSignature as bq, type WriteSet as br, type ScriptWriteSet as bs, type DirectWriteSet as bt, type EventGuid as bu, type Event as bv, type MoveUint8Type as bw, type MoveUint16Type as bx, type MoveUint32Type as by, type MoveUint64Type as bz, type Uint32 as c, type Deserializable as d, Hex as e, type AuthenticationKeyScheme as f, AccountAddress as g, AnyPublicKeyVariant as h, EphemeralPublicKeyVariant as i, type ClientConfig as j, type FaucetConfig as k, type AptosSettings as l, EphemeralCertificateVariant as m, type AccountAddressInput as n, type ScriptFunctionArgument as o, type MoveFunctionId as p, type MoveStructId as q, type MoveValue as r, type MoveFunctionGenericTypeParam as s, SigningSchemeInput as t, SigningScheme as u, type MoveFunction as v, type MoveModule as w, type AccountData as x, type PaginationArgs as y, type MoveModuleBytecode as z };

package/dist/common/chunk-PA2XFIP3.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 M=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var y=(r,e,t,n)=>{for(var s=n>1?void 0:n?E(e,t):e,i=r.length-1,u;i>=0;i--)(u=r[i])&&(s=(n?u(e,t,s):u(s))||s);return n&&s&&M(e,t,s),s};var g=class extends Error{constructor(e,t){super(e),this.invalidReason=t}};var _utils = require('@noble/hashes/utils');var k=(n=>(n.TOO_SHORT="too_short",n.INVALID_LENGTH="invalid_length",n.INVALID_HEX_CHARS="invalid_hex_chars",n))(k||{}),_= exports.j =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 g("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 g("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 g(`Hex string contains invalid hex characters: ${_optionalChain([n, 'optionalAccess', _2 => _2.message])}`,"invalid_hex_chars")}}static fromHexInput(e){if(e instanceof Buffer)return new r(new Uint8Array(e));if(e instanceof Uint8Array)return new r(e);if(typeof e=="string")return r.fromHexString(e);throw new Error(`Invalid hex input type: ${typeof 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])}},ge= exports.k =r=>new TextDecoder().decode(_.fromHexInput(r).toUint8Array());var S=255,U= exports.c =65535,f= exports.d =4294967295,b= exports.e =18446744073709551615n,R= exports.f =340282366920938463463374607431768211455n,v= exports.g =115792089237316195423570985008687907853269984665640564039457584007913129639935n;var x=class{bcsToBytes(){let e=new c;return this.serialize(e),e.toUint8Array()}bcsToHex(){let e=this.bcsToBytes();return _.fromHexInput(e)}toStringWithoutPrefix(){return this.bcsToHex().toStringWithoutPrefix()}toString(){return`0x${this.toStringWithoutPrefix()}`}},c= exports.m =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){C(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)&b,n=BigInt(e)>>BigInt(64);this.serializeU64(t),this.serializeU64(n)}serializeU256(e){let t=BigInt(e)&R,n=BigInt(e)>>BigInt(128);this.serializeU128(t),this.serializeU128(n)}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))}};y([h(0,S)],c.prototype,"serializeU8",1),y([h(0,U)],c.prototype,"serializeU16",1),y([h(0,f)],c.prototype,"serializeU32",1),y([h(BigInt(0),b)],c.prototype,"serializeU64",1),y([h(BigInt(0),R)],c.prototype,"serializeU128",1),y([h(BigInt(0),v)],c.prototype,"serializeU256",1),y([h(0,f)],c.prototype,"serializeU32AsUleb128",1);function C(r){if(typeof r!="boolean")throw new Error(`${r} is not a boolean value`)}var w=(r,e,t)=>`${r} is out of range: [${e}, ${t}]`;function H(r,e,t){let n=BigInt(r);if(n>BigInt(t)||n<BigInt(e))throw new Error(w(r,e,t))}function h(r,e){return(t,n,s)=>{let i=s.value;return s.value=function(d){return H(d,r,e),i.apply(this,[d])},s}}var O=(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))(O||{}),W= exports.r =(a=>(a[a.Bool=0]="Bool",a[a.U8=1]="U8",a[a.U64=2]="U64",a[a.U128=3]="U128",a[a.Address=4]="Address",a[a.Signer=5]="Signer",a[a.Vector=6]="Vector",a[a.Struct=7]="Struct",a[a.U16=8]="U16",a[a.U32=9]="U32",a[a.U256=10]="U256",a[a.Reference=254]="Reference",a[a.Generic=255]="Generic",a))(W||{}),T= exports.s =(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))(T||{}),z= exports.t =(n=>(n[n.Script=0]="Script",n[n.EntryFunction=2]="EntryFunction",n[n.Multisig=3]="Multisig",n))(z||{}),D= exports.u =(t=>(t[t.MultiAgentTransaction=0]="MultiAgentTransaction",t[t.FeePayerTransaction=1]="FeePayerTransaction",t))(D||{}),F= exports.v =(i=>(i[i.Ed25519=0]="Ed25519",i[i.MultiEd25519=1]="MultiEd25519",i[i.MultiAgent=2]="MultiAgent",i[i.FeePayer=3]="FeePayer",i[i.SingleSender=4]="SingleSender",i))(F||{}),G= exports.w =(u=>(u[u.Ed25519=0]="Ed25519",u[u.MultiEd25519=1]="MultiEd25519",u[u.SingleKey=2]="SingleKey",u[u.MultiKey=3]="MultiKey",u[u.NoAccountAuthenticator=4]="NoAccountAuthenticator",u[u.Abstraction=5]="Abstraction",u))(G||{}),P= exports.x =(t=>(t.Ed25519="ed25519",t.Secp256k1="secp256k1",t))(P||{}),L= exports.y =(s=>(s[s.Ed25519=0]="Ed25519",s[s.Secp256k1=1]="Secp256k1",s[s.Keyless=3]="Keyless",s[s.FederatedKeyless=4]="FederatedKeyless",s))(L||{}),$= exports.z =(n=>(n[n.Ed25519=0]="Ed25519",n[n.Secp256k1=1]="Secp256k1",n[n.Keyless=3]="Keyless",n))($||{}),q= exports.A =(e=>(e[e.Ed25519=0]="Ed25519",e))(q||{}),X= exports.B =(e=>(e[e.Ed25519=0]="Ed25519",e))(X||{}),Y= exports.C =(e=>(e[e.ZkProof=0]="ZkProof",e))(Y||{}),Z= exports.D =(e=>(e[e.Groth16=0]="Groth16",e))(Z||{}),Q= exports.E =(d=>(d.Pending="pending_transaction",d.User="user_transaction",d.Genesis="genesis_transaction",d.BlockMetadata="block_metadata_transaction",d.StateCheckpoint="state_checkpoint_transaction",d.Validator="validator_transaction",d.BlockEpilogue="block_epilogue_transaction",d))(Q||{});function fe(r){return r.type==="pending_transaction"}function xe(r){return r.type==="user_transaction"}function me(r){return r.type==="genesis_transaction"}function be(r){return r.type==="block_metadata_transaction"}function Re(r){return r.type==="state_checkpoint_transaction"}function Se(r){return r.type==="validator_transaction"}function Ue(r){return r.type==="block_epilogue_transaction"}function ve(r){return"signature"in r&&r.signature==="ed25519_signature"}function Te(r){return"signature"in r&&r.signature==="secp256k1_ecdsa_signature"}function Ae(r){return r.type==="multi_agent_signature"}function Ie(r){return r.type==="fee_payer_signature"}function Me(r){return r.type==="multi_ed25519_signature"}var j=(n=>(n.PRIVATE="private",n.PUBLIC="public",n.FRIEND="friend",n))(j||{}),K= exports.S =(s=>(s.STORE="store",s.DROP="drop",s.KEY="key",s.COPY="copy",s))(K||{}),J= exports.T =(t=>(t.VALIDATOR="validator",t.FULL_NODE="full_node",t))(J||{}),V= exports.U =(s=>(s[s.Ed25519=0]="Ed25519",s[s.MultiEd25519=1]="MultiEd25519",s[s.SingleKey=2]="SingleKey",s[s.MultiKey=3]="MultiKey",s))(V||{}),ee= exports.V =(t=>(t[t.Ed25519=0]="Ed25519",t[t.Secp256k1Ecdsa=2]="Secp256k1Ecdsa",t))(ee||{}),te= exports.W =(i=>(i[i.DeriveAuid=251]="DeriveAuid",i[i.DeriveObjectAddressFromObject=252]="DeriveObjectAddressFromObject",i[i.DeriveObjectAddressFromGuid=253]="DeriveObjectAddressFromGuid",i[i.DeriveObjectAddressFromSeed=254]="DeriveObjectAddressFromSeed",i[i.DeriveResourceAccountAddress=255]="DeriveResourceAccountAddress",i))(te||{});var _scriptcomposerpack = require('@aptos-labs/script-composer-pack');var ne=(l=>(l.INCORRECT_NUMBER_OF_BYTES="incorrect_number_of_bytes",l.INVALID_HEX_CHARS="invalid_hex_chars",l.TOO_SHORT="too_short",l.TOO_LONG="too_long",l.LEADING_ZERO_X_REQUIRED="leading_zero_x_required",l.LONG_FORM_REQUIRED_UNLESS_SPECIAL="long_form_required_unless_special",l.INVALID_PADDING_ZEROES="INVALID_PADDING_ZEROES",l.INVALID_PADDING_STRICTNESS="INVALID_PADDING_STRICTNESS",l))(ne||{}),o=class o extends x{constructor(e){if(super(),e.length!==o.LENGTH)throw new g("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)}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(o.LENGTH);return new o(t)}static fromStringStrict(e){if(!e.startsWith("0x"))throw new g("Hex string must start with a leading 0x.","leading_zero_x_required");let t=o.fromString(e);if(e.length!==o.LONG_STRING_LENGTH+2)if(t.isSpecial()){if(e.length!==3)throw new g(`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 g(`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 g("Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.","too_short");if(n.length>64)throw new g("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 g(`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(u){throw new g(`Hex characters are invalid: ${_optionalChain([u, 'optionalAccess', _5 => _5.message])}`,"invalid_hex_chars")}let i=new o(s);if(n.length<64-t&&!i.isSpecial())throw new g(`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 i}static from(e,{maxMissingChars:t=4}={}){return typeof e=="string"?o.fromString(e,{maxMissingChars:t}):e instanceof Uint8Array?new o(e):e}static fromStrict(e){return typeof e=="string"?o.fromStringStrict(e):e instanceof Uint8Array?new o(e):e}static isValid(e){try{return e.strict?o.fromStrict(e.input):o.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])}};o.LENGTH=32,o.LONG_STRING_LENGTH=64,o.ZERO=o.from("0x0"),o.ONE=o.from("0x1"),o.TWO=o.from("0x2"),o.THREE=o.from("0x3"),o.FOUR=o.from("0x4"),o.A=o.from("0xA");var m=o;var _jsbase64 = require('js-base64');async function qe(r){return new Promise(e=>{setTimeout(e,r)})}function Xe(r){return r instanceof Error?r.message:String(r)}var Ye=()=>Math.floor(Date.now()/1e3);function Ze(r){let e=new Date(r*1e3);return e.setMinutes(0),e.setSeconds(0),e.setMilliseconds(0),Math.floor(e.getTime()/1e3)}function Qe(r){let e=r.replace(/-/g,"+").replace(/_/g,"/"),t=e+"==".substring(0,(3-e.length%3)%3);return _jsbase64.decode.call(void 0, t)}var je=(r,e)=>r*10**e,Ke= exports.ea =(r,e)=>r/10**e,I=r=>{let e="";for(let t=2;t<r.length;t+=2)e+=String.fromCharCode(parseInt(r.substring(t,t+2),16));return e},Je= exports.fa =r=>{let{account_address:e,module_name:t,struct_name:n}=r,s=I(t),i=I(n);return`${e}::${s}::${i}`},Ve= exports.ga =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 et(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 tt(r){let e=r.split("::");return e.length===3&&m.isValid({input:e[0]}).valid}function rt(r,e=6,t=5){return`${r.slice(0,e)}...${r.slice(-t)}`}exports.a = y; exports.b = S; exports.c = U; exports.d = f; exports.e = b; exports.f = R; exports.g = v; exports.h = g; exports.i = k; exports.j = _; exports.k = ge; exports.l = x; exports.m = c; exports.n = C; exports.o = w; exports.p = H; exports.q = O; exports.r = W; exports.s = T; exports.t = z; exports.u = D; exports.v = F; exports.w = G; exports.x = P; exports.y = L; exports.z = $; exports.A = q; exports.B = X; exports.C = Y; exports.D = Z; exports.E = Q; exports.F = fe; exports.G = xe; exports.H = me; exports.I = be; exports.J = Re; exports.K = Se; exports.L = Ue; exports.M = ve; exports.N = Te; exports.O = Ae; exports.P = Ie; exports.Q = Me; exports.R = j; exports.S = K; exports.T = J; exports.U = V; exports.V = ee; exports.W = te; exports.X = _scriptcomposerpack.CallArgument; exports.Y = ne; exports.Z = m; exports._ = qe; exports.$ = Xe; exports.aa = Ye; exports.ba = Ze; exports.ca = Qe; exports.da = je; exports.ea = Ke; exports.fa = Je; exports.ga = Ve; exports.ha = et; exports.ia = tt; exports.ja = rt;
+//# sourceMappingURL=chunk-PA2XFIP3.js.map

package/dist/common/chunk-PA2XFIP3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/maayansavir/work/aptos_repos/aptos-ts-sdk/dist/common/chunk-PA2XFIP3.js","../../src/core/common.ts","../../src/core/hex.ts","../../src/core/accountAddress.ts"],"names":["ParsingError","message","invalidReason","HexInvalidReason","Hex","_Hex","data","bytesToHex"],"mappings":"AAAA,ilBAAI,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CCQhM,IAAMA,CAAAA,CAAN,MAAA,QAA8B,KAAM,CAkBzC,WAAA,CAAYC,CAAAA,CAAiBC,CAAAA,CAAkB,CAC7C,KAAA,CAAMD,CAAO,CAAA,CACb,IAAA,CAAK,aAAA,CAAgBC,CACvB,CACF,CAAA,CC3BA,4CAAuC,IAS3BC,CAAAA,CAAAA,CAAAA,CAAAA,EAAAA,CACVA,CAAAA,CAAA,SAAA,CAAY,WAAA,CACZA,CAAAA,CAAA,cAAA,CAAiB,gBAAA,CACjBA,CAAAA,CAAA,iBAAA,CAAoB,mBAAA,CAHVA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAAA,CAAA,CAAA,CAAA,CAgCCC,CAAAA,aAAN,MAAMC,CAAI,CAUf,WAAA,CAAYC,CAAAA,CAAkB,CAC5B,IAAA,CAAK,IAAA,CAAOA,CACd,CAaA,YAAA,CAAA,CAA2B,CACzB,OAAO,IAAA,CAAK,IACd,CASA,qBAAA,CAAA,CAAgC,CAC9B,OAAOC,+BAAAA,IAAW,CAAK,IAAI,CAC7B,CASA,QAAA,CAAA,CAAmB,CACjB,MAAO,CAAA,EAAA,EAAK,IAAA,CAAK,qBAAA,CAAsB,CAAC,CAAA,CAAA;ACyTsB;AA1UV,SAAA","file":"/Users/maayansavir/work/aptos_repos/aptos-ts-sdk/dist/common/chunk-PA2XFIP3.js","sourcesContent":[null,"// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This error is used to explain why parsing failed.\n * @group Implementation\n * @category Serialization\n */\nexport class ParsingError<T> extends Error {\n  /**\n   * This provides a programmatic way to access why parsing failed. Downstream devs\n   * might want to use this to build their own error messages if the default error\n   * messages are not suitable for their use case. This should be an enum.\n   * @group Implementation\n   * @category Serialization\n   */\n  public invalidReason: T;\n\n  /**\n   * Creates an instance of the error with a specified message and invalid reason.\n   *\n   * @param message The error message that describes the issue.\n   * @param invalidReason The reason why the input is considered invalid.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(message: string, invalidReason: T) {\n    super(message);\n    this.invalidReason = invalidReason;\n  }\n}\n\n/**\n * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,\n * this type is returned from \"defensive\" functions like isValid.\n * @group Implementation\n * @category Serialization\n */\nexport type ParsingResult<T> = {\n  /**\n   * True if valid, false otherwise.\n   * @group Implementation\n   * @category Serialization\n   */\n  valid: boolean;\n\n  /**\n   * If valid is false, this will be a code explaining why parsing failed.\n   * @group Implementation\n   * @category Serialization\n   */\n  invalidReason?: T;\n\n  /**\n   * If valid is false, this will be a string explaining why parsing failed.\n   * @group Implementation\n   * @category Serialization\n   */\n  invalidReasonMessage?: string;\n};\n","// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { HexInput } from \"../types\";\n\n/**\n * Provides reasons for parsing failures related to hexadecimal values.\n * @group Implementation\n * @category Serialization\n */\nexport enum HexInvalidReason {\n  TOO_SHORT = \"too_short\",\n  INVALID_LENGTH = \"invalid_length\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n}\n\n/**\n * NOTE: Do not use this class when working with account addresses; use AccountAddress instead.\n * When accepting hex data as input to a function, prefer to accept HexInput and\n *\n * A helper class for working with hex data. Hex data, when represented as a string,\n * generally looks like this, for example: 0xaabbcc, 45cd32, etc.\n *\n * then use the static helper methods of this class to convert it into the desired\n * format. This enables the greatest flexibility for the developer.\n *\n * Example usage:\n * ```typescript\n * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {\n *   const txnHashString = Hex.fromHexInput(txnHash).toString();\n *   return await getTransactionByHashInner(txnHashString);\n * }\n * ```\n * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string\n * with a leading 0x prefix, regardless of what the input format was.\n *\n * Other ways to chain the functions together:\n * - `Hex.fromHexString({ hexInput: \"0x1f\" }).toUint8Array()`\n * - `new Hex([1, 3]).toStringWithoutPrefix()`\n * @group Implementation\n * @category Serialization\n */\nexport class Hex {\n  private readonly data: Uint8Array;\n\n  /**\n   * Create a new Hex instance from a Uint8Array.\n   *\n   * @param data - The Uint8Array containing the data to initialize the Hex instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  // ===\n  // Methods for representing an instance of Hex as other types.\n  // ===\n\n  /**\n   * Get the inner hex data as a Uint8Array. The inner data is already a Uint8Array, so no conversion takes place.\n   *\n   * @returns Hex data as Uint8Array\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Get the hex data as a string without the 0x prefix.\n   *\n   * @returns Hex string without 0x prefix\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the hex data as a string with the 0x prefix.\n   *\n   * @returns Hex string with 0x prefix\n   * @group Implementation\n   * @category Serialization\n   */\n  toString(): string {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  // ===\n  // Methods for creating an instance of Hex from other types.\n  // ===\n\n  /**\n   * Converts a hex string into a Hex instance, allowing for both prefixed and non-prefixed formats.\n   *\n   * @param str - A hex string, with or without the 0x prefix.\n   *\n   * @throws ParsingError - If the hex string is too short, has an odd number of characters, or contains invalid hex characters.\n   *\n   * @returns Hex - The resulting Hex instance created from the provided string.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromHexString(str: string): Hex {\n    let input = str;\n\n    if (input.startsWith(\"0x\")) {\n      input = input.slice(2);\n    }\n\n    if (input.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.\",\n        HexInvalidReason.TOO_SHORT,\n      );\n    }\n\n    if (input.length % 2 !== 0) {\n      throw new ParsingError(\"Hex string must be an even number of hex characters.\", HexInvalidReason.INVALID_LENGTH);\n    }\n\n    try {\n      return new Hex(hexToBytes(input));\n    } catch (error: any) {\n      throw new ParsingError(\n        `Hex string contains invalid hex characters: ${error?.message}`,\n        HexInvalidReason.INVALID_HEX_CHARS,\n      );\n    }\n  }\n\n  /**\n   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance.\n   * This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.\n   *\n   * @param hexInput - A HexInput which can be a string or Uint8Array.\n   * @returns A Hex instance created from the provided hexInput.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromHexInput(hexInput: HexInput): Hex {\n    if (hexInput instanceof Buffer) return new Hex(new Uint8Array(hexInput));\n    if (hexInput instanceof Uint8Array) return new Hex(hexInput);\n    if (typeof hexInput === \"string\") return Hex.fromHexString(hexInput);\n    throw new Error(`Invalid hex input type: ${typeof hexInput}`);\n  }\n\n  /**\n   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Uint8Array.\n   *\n   * @param hexInput - A HexInput which can be a string or Uint8Array.\n   * @returns A Uint8Array created from the provided hexInput.\n   */\n  static hexInputToUint8Array(hexInput: HexInput): Uint8Array {\n    if (hexInput instanceof Uint8Array) return hexInput;\n    return Hex.fromHexString(hexInput).toUint8Array();\n  }\n\n  /**\n   * Converts a HexInput (string or Uint8Array) to a hex string with '0x' prefix.\n   *\n   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array\n   * @returns A hex string with '0x' prefix (e.g., \"0x1234\")\n   *\n   * @example\n   * ```typescript\n   * Hex.hexInputToString(\"1234\")        // returns \"0x1234\"\n   * Hex.hexInputToString(\"0x1234\")      // returns \"0x1234\"\n   * Hex.hexInputToString(new Uint8Array([0x12, 0x34])) // returns \"0x1234\"\n   * ```\n   */\n  static hexInputToString(hexInput: HexInput): string {\n    return Hex.fromHexInput(hexInput).toString();\n  }\n\n  /**\n   * Converts a HexInput (string or Uint8Array) to a hex string without '0x' prefix.\n   *\n   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array\n   * @returns A hex string without '0x' prefix (e.g., \"1234\")\n   *\n   * @example\n   * ```typescript\n   * Hex.hexInputToStringWithoutPrefix(\"1234\")        // returns \"1234\"\n   * Hex.hexInputToStringWithoutPrefix(\"0x1234\")      // returns \"1234\"\n   * Hex.hexInputToStringWithoutPrefix(new Uint8Array([0x12, 0x34])) // returns \"1234\"\n   * ```\n   */\n  static hexInputToStringWithoutPrefix(hexInput: HexInput): string {\n    return Hex.fromHexInput(hexInput).toStringWithoutPrefix();\n  }\n\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the provided string is a valid hexadecimal representation.\n   *\n   * @param str - A hex string representing byte data.\n   *\n   * @returns An object containing:\n   *  - valid: A boolean indicating whether the string is valid.\n   *  - invalidReason: The reason for invalidity if the string is not valid.\n   *  - invalidReasonMessage: A message explaining why the string is invalid.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isValid(str: string): ParsingResult<HexInvalidReason> {\n    try {\n      Hex.fromHexString(str);\n      return { valid: true };\n    } catch (error: any) {\n      return {\n        valid: false,\n        invalidReason: error?.invalidReason,\n        invalidReasonMessage: error?.message,\n      };\n    }\n  }\n\n  /**\n   * Determine if two Hex instances are equal by comparing their underlying byte data.\n   *\n   * @param other The Hex instance to compare to.\n   * @returns true if the Hex instances are equal, false if not.\n   * @group Implementation\n   * @category Serialization\n   */\n  equals(other: Hex): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n\nexport const hexToAsciiString = (hex: string) => new TextDecoder().decode(Hex.fromHexInput(hex).toUint8Array());\n","// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { Serializable, Serializer } from \"../bcs/serializer\";\nimport { Deserializer } from \"../bcs/deserializer\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { TransactionArgument } from \"../transactions/instances/transactionArgument\";\nimport { HexInput, ScriptTransactionArgumentVariants } from \"../types\";\n\n/**\n * Provides reasons for an address was invalid.\n * @group Implementation\n * @category Serialization\n */\nexport enum AddressInvalidReason {\n  INCORRECT_NUMBER_OF_BYTES = \"incorrect_number_of_bytes\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n  TOO_SHORT = \"too_short\",\n  TOO_LONG = \"too_long\",\n  LEADING_ZERO_X_REQUIRED = \"leading_zero_x_required\",\n  LONG_FORM_REQUIRED_UNLESS_SPECIAL = \"long_form_required_unless_special\",\n  INVALID_PADDING_ZEROES = \"INVALID_PADDING_ZEROES\",\n  INVALID_PADDING_STRICTNESS = \"INVALID_PADDING_STRICTNESS\",\n}\n\n/**\n * The input for an account address, which can be either a hexadecimal string or a standard account address.\n * @group Implementation\n * @category Serialization\n */\nexport type AccountAddressInput = HexInput | AccountAddress;\n\n/**\n * NOTE: Only use this class for account addresses. For other hex data, e.g. transaction\n * hashes, use the Hex class.\n *\n * AccountAddress is used for working with account addresses. Account addresses, when\n * represented as a string, generally look like these examples:\n * - 0x1\n * - 0xaa86fe99004361f747f91342ca13c426ca0cccb0c1217677180c9493bad6ef0c\n *\n * Proper formatting and parsing of account addresses is defined by AIP-40.\n * To learn more about the standard, read the AIP here:\n * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.\n *\n * The comments in this class make frequent reference to the LONG and SHORT formats,\n * as well as \"special\" addresses. To learn what these refer to see AIP-40.\n * @group Implementation\n * @category Serialization\n */\nexport class AccountAddress extends Serializable implements TransactionArgument {\n  /**\n   * This is the internal representation of an account address.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly data: Uint8Array;\n\n  /**\n   * The number of bytes that make up an account address.\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The length of an address string in LONG form without a leading 0x.\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly LONG_STRING_LENGTH: number = 64;\n\n  static ZERO: AccountAddress = AccountAddress.from(\"0x0\");\n\n  static ONE: AccountAddress = AccountAddress.from(\"0x1\");\n\n  static TWO: AccountAddress = AccountAddress.from(\"0x2\");\n\n  static THREE: AccountAddress = AccountAddress.from(\"0x3\");\n\n  static FOUR: AccountAddress = AccountAddress.from(\"0x4\");\n\n  static A: AccountAddress = AccountAddress.from(\"0xA\");\n\n  /**\n   * Creates an instance of AccountAddress from a Uint8Array.\n   *\n   * This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.\n   *\n   * @param input A Uint8Array representing an account address.\n   * @throws ParsingError if the input length is not equal to 32 bytes.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(input: Uint8Array) {\n    super();\n    if (input.length !== AccountAddress.LENGTH) {\n      throw new ParsingError(\n        \"AccountAddress data should be exactly 32 bytes long\",\n        AddressInvalidReason.INCORRECT_NUMBER_OF_BYTES,\n      );\n    }\n    this.data = input;\n  }\n\n  /**\n   * Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive.\n   * In other words, the last byte of the address must be < 0b10000 (16)\n   * and every other byte must be zero.\n   *\n   * For more information on how special addresses are defined, see AIP-40:\n   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.\n   *\n   * @returns true if the address is special, false otherwise.\n   * @group Implementation\n   * @category Serialization\n   */\n  isSpecial(): boolean {\n    return (\n      this.data.slice(0, this.data.length - 1).every((byte) => byte === 0) && this.data[this.data.length - 1] < 0b10000\n    );\n  }\n  // ===\n  // Methods for representing an instance of AccountAddress as other types.\n  // ===\n\n  /**\n   * Return the AccountAddress as a string as per AIP-40.\n   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.\n   * This representation returns special addresses in SHORT form (0xf)\n   * and other addresses in LONG form (0x + 64 characters).\n   *\n   * @returns AccountAddress as a string conforming to AIP-40.\n   * @group Implementation\n   * @category Serialization\n   */\n  toString(): `0x${string}` {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  /**\n   * Return the AccountAddress as a string conforming to AIP-40 but without the leading 0x.\n   *\n   * NOTE: Prefer to use `toString` where possible.\n   *\n   * @returns AccountAddress as a string without the leading 0x.\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringWithoutPrefix(): string {\n    let hex = bytesToHex(this.data);\n    if (this.isSpecial()) {\n      hex = hex[hex.length - 1];\n    }\n    return hex;\n  }\n\n  /**\n   * Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.\n   *\n   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).\n   *\n   * @returns AccountAddress as a string in LONG form.\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringLong(): `0x${string}` {\n    return `0x${this.toStringLongWithoutPrefix()}`;\n  }\n\n  /**\n   * Returns the account address as a string in LONG form without a leading 0x.\n   * This function will include leading zeroes and will produce a string of 64 hex characters.\n   *\n   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).\n   *\n   * @returns {string} The account address in LONG form.\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringLongWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the inner data as a Uint8Array.\n   * The inner data is already a Uint8Array, so no conversion takes place.\n   *\n   * @returns Hex data as Uint8Array\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Serialize the AccountAddress to a Serializer instance's data buffer.\n   * @param serializer The serializer to serialize the AccountAddress to.\n   * @returns void\n   * @example\n   * const serializer = new Serializer();\n   * const address = AccountAddress.fromString(\"0x1\");\n   * address.serialize(serializer);\n   * const bytes = serializer.toUint8Array();\n   * // `bytes` is now the BCS-serialized address.\n   * @group Implementation\n   * @category Serialization\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data);\n  }\n\n  /**\n   * Serializes the current instance into a byte sequence suitable for entry functions.\n   * This allows for the proper encoding of data when interacting with entry functions in the blockchain.\n   *\n   * @param serializer - The serializer instance used to convert the data into bytes.\n   * @group Implementation\n   * @category Serialization\n   */\n  serializeForEntryFunction(serializer: Serializer): void {\n    const bcsBytes = this.bcsToBytes();\n    serializer.serializeBytes(bcsBytes);\n  }\n\n  /**\n   * Serializes the current instance for use in a script function by encoding it into a byte sequence.\n   * This process involves serializing the variant index and the instance data, making it suitable for transmission.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @group Implementation\n   * @category Serialization\n   */\n  serializeForScriptFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Address);\n    serializer.serialize(this);\n  }\n\n  /**\n   * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.\n   * This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.\n   * @param deserializer The deserializer to deserialize the AccountAddress from.\n   * @returns An instance of AccountAddress.\n   * @example\n   * const bytes = hexToBytes(\"0x0102030405060708091011121314151617181920212223242526272829303132\");\n   * const deserializer = new Deserializer(bytes);\n   * const address = AccountAddress.deserialize(deserializer);\n   * // `address` is now an instance of AccountAddress.\n   * @group Implementation\n   * @category Serialization\n   */\n  static deserialize(deserializer: Deserializer): AccountAddress {\n    const bytes = deserializer.deserializeFixedBytes(AccountAddress.LENGTH);\n    return new AccountAddress(bytes);\n  }\n\n  // ===\n  // Methods for creating an instance of AccountAddress from other types.\n  // ===\n\n  /**\n   * NOTE: This function has strict parsing behavior. For relaxed behavior, please use\n   * the `fromString` function.\n   *\n   * Creates an instance of AccountAddress from a hex string.\n   *\n   * This function allows only the strictest formats defined by AIP-40. In short this\n   * means only the following formats are accepted:\n   *\n   * - LONG\n   * - SHORT for special addresses\n   *\n   * Where:\n   * - LONG is defined as 0x + 64 hex characters.\n   * - SHORT for special addresses is 0x0 to 0xf inclusive without padding zeroes.\n   *\n   * This means the following are not accepted:\n   * - SHORT for non-special addresses.\n   * - Any address without a leading 0x.\n   *\n   * @param input - A hex string representing an account address.\n   *\n   * @throws {ParsingError} If the hex string does not start with 0x or is not in a valid format.\n   *\n   * @remarks\n   *\n   * This function has strict parsing behavior. For relaxed behavior, please use the `fromString` function.\n   *\n   * @see AIP-40 documentation for more details on address formats:\n   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.\n   *\n   * @returns An instance of AccountAddress.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromStringStrict(input: string): AccountAddress {\n    // Assert the string starts with 0x.\n    if (!input.startsWith(\"0x\")) {\n      throw new ParsingError(\"Hex string must start with a leading 0x.\", AddressInvalidReason.LEADING_ZERO_X_REQUIRED);\n    }\n\n    const address = AccountAddress.fromString(input);\n\n    // Check if the address is in LONG form. If it is not, this is only allowed for\n    // special addresses, in which case we check it is in proper SHORT form.\n    if (input.length !== AccountAddress.LONG_STRING_LENGTH + 2) {\n      if (!address.isSpecial()) {\n        throw new ParsingError(\n          `The given hex string ${input} is not a special address, it must be represented as 0x + 64 chars.`,\n          AddressInvalidReason.LONG_FORM_REQUIRED_UNLESS_SPECIAL,\n        );\n      } else if (input.length !== 3) {\n        // 0x + one hex char is the only valid SHORT form for special addresses.\n        throw new ParsingError(\n          // eslint-disable-next-line max-len\n          `The given hex string ${input} is a special address not in LONG form, it must be 0x0 to 0xf without padding zeroes.`,\n          AddressInvalidReason.INVALID_PADDING_ZEROES,\n        );\n      }\n    }\n\n    return address;\n  }\n\n  /**\n   * NOTE: This function has relaxed parsing behavior. For strict behavior, please use\n   * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this\n   * function, `fromString`.\n   *\n   * Creates an instance of AccountAddress from a hex string.\n   *\n   * This function allows all formats defined by AIP-40. In short this means the\n   * following formats are accepted:\n   *\n   * - LONG, with or without leading 0x\n   * - SHORT*, with or without leading 0x\n   *\n   * Where:\n   * - LONG is 64 hex characters.\n   * - SHORT* is 1 to 63 hex characters inclusive. The address can have missing values up to `maxMissingChars` before it is padded.\n   * - Padding zeroes are allowed, e.g. 0x0123 is valid.\n   *\n   * Learn more about the different address formats by reading AIP-40:\n   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.\n   *\n   * @param input A hex string representing an account address.\n   * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.\n   *\n   * @returns An instance of AccountAddress.\n   *\n   * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromString(input: string, { maxMissingChars = 4 }: { maxMissingChars?: number } = {}): AccountAddress {\n    let parsedInput = input;\n    // Remove leading 0x for parsing.\n    if (input.startsWith(\"0x\")) {\n      parsedInput = input.slice(2);\n    }\n\n    // Ensure the address string is at least 1 character long.\n    if (parsedInput.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.\",\n        AddressInvalidReason.TOO_SHORT,\n      );\n    }\n\n    // Ensure the address string is not longer than 64 characters.\n    if (parsedInput.length > 64) {\n      throw new ParsingError(\n        \"Hex string is too long, must be 1 to 64 chars long, excluding the leading 0x.\",\n        AddressInvalidReason.TOO_LONG,\n      );\n    }\n\n    // Ensure that the maxMissingChars is between or equal to 0 and 63.\n    if (maxMissingChars > 63 || maxMissingChars < 0) {\n      throw new ParsingError(\n        `maxMissingChars must be between or equal to 0 and 63. Received ${maxMissingChars}`,\n        AddressInvalidReason.INVALID_PADDING_STRICTNESS,\n      );\n    }\n\n    let addressBytes: Uint8Array;\n    try {\n      // Pad the address with leading zeroes, so it is 64 chars long and then convert\n      // the hex string to bytes. Every two characters in a hex string constitutes a\n      // single byte. So a 64 length hex string becomes a 32 byte array.\n      addressBytes = hexToBytes(parsedInput.padStart(64, \"0\"));\n    } catch (error: any) {\n      // At this point the only way this can fail is if the hex string contains\n      // invalid characters.\n      throw new ParsingError(`Hex characters are invalid: ${error?.message}`, AddressInvalidReason.INVALID_HEX_CHARS);\n    }\n\n    const address = new AccountAddress(addressBytes);\n\n    // Cannot pad the address if it has more than maxMissingChars missing.\n    if (parsedInput.length < 64 - maxMissingChars) {\n      if (!address.isSpecial()) {\n        throw new ParsingError(\n          `Hex string is too short, must be ${64 - maxMissingChars} to 64 chars long, excluding the leading 0x. You may need to fix \nthe addresss by padding it with 0s before passing it to \\`fromString\\` (e.g. <addressString>.padStart(64, '0')). \nReceived ${input}`,\n          AddressInvalidReason.TOO_SHORT,\n        );\n      }\n    }\n\n    return address;\n  }\n\n  /**\n   * Convenience method for creating an AccountAddress from various input types.\n   * This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding\n   * AccountAddress.\n   *\n   * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,\n   * or an existing AccountAddress.\n   * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.\n   * @group Implementation\n   * @category Serialization\n   */\n  static from(input: AccountAddressInput, { maxMissingChars = 4 }: { maxMissingChars?: number } = {}): AccountAddress {\n    if (typeof input === \"string\") {\n      return AccountAddress.fromString(input, { maxMissingChars });\n    }\n    if (input instanceof Uint8Array) {\n      return new AccountAddress(input);\n    }\n    return input;\n  }\n\n  /**\n   * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.\n   *\n   * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromStrict(input: AccountAddressInput): AccountAddress {\n    if (typeof input === \"string\") {\n      return AccountAddress.fromStringStrict(input);\n    }\n    if (input instanceof Uint8Array) {\n      return new AccountAddress(input);\n    }\n    return input;\n  }\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the provided input is a valid AccountAddress.\n   *\n   * @param args - The arguments for validation.\n   * @param args.input - A hex string representing an account address.\n   * @param args.strict - If true, use strict parsing behavior; if false, use relaxed parsing behavior.\n   *\n   * @returns An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details.\n   * If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isValid(args: { input: AccountAddressInput; strict?: boolean }): ParsingResult<AddressInvalidReason> {\n    try {\n      if (args.strict) {\n        AccountAddress.fromStrict(args.input);\n      } else {\n        AccountAddress.from(args.input);\n      }\n      return { valid: true };\n    } catch (error: any) {\n      return {\n        valid: false,\n        invalidReason: error?.invalidReason,\n        invalidReasonMessage: error?.message,\n      };\n    }\n  }\n\n  /**\n   * Determine if two AccountAddresses are equal based on their underlying byte data.\n   *\n   * @param other - The AccountAddress to compare to.\n   * @returns true if the AccountAddresses are equal, false if not.\n   * @group Implementation\n   * @category Serialization\n   */\n  equals(other: AccountAddress): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n"]}

package/dist/common/cli/index.d.ts

@@ -1,5 +1,5 @@
 import { ChildProcessWithoutNullStreams } from 'child_process';
-import { N as Network, g as AccountAddress } from '../accountAddress-Ce4Cv60D.js';
+import { N as Network, g as AccountAddress } from '../accountAddress-jrha_M3l.js';
 
 /**
  * Represents a local node for running a localnet environment.