@aptos-labs/ts-sdk 6.0.0 → 6.1.0

package/src/utils/helpers.ts

@@ -6,6 +6,48 @@ import { MoveFunctionId, MoveStructId } from "../types";
 import { AccountAddress } from "../core/accountAddress";
 import { createObjectAddress } from "../core/account/utils/address";
 
+/**
+ * Checks if the current runtime environment is Bun.
+ * This is useful for detecting Bun-specific compatibility issues.
+ *
+ * @returns true if running in Bun, false otherwise.
+ * @group Implementation
+ * @category Utils
+ */
+export function isBun(): boolean {
+  try {
+    // Bun exposes a global `Bun` object.
+    return typeof globalThis !== "undefined" && "Bun" in globalThis;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Logs a warning message to the console only in development environments.
+ * This function helps reduce information leakage in production while maintaining
+ * helpful warnings during development.
+ *
+ * @param message - The warning message to log.
+ * @group Implementation
+ * @category Utils
+ */
+export function warnIfDevelopment(message: string): void {
+  // Check common environment variables to determine if we're in development
+  // This works in Node.js, bundlers like webpack/vite, and most build systems
+  const isDevelopment =
+    typeof process !== "undefined" &&
+    process.env &&
+    (process.env.NODE_ENV === "development" ||
+      process.env.NODE_ENV === "test" ||
+      process.env.APTOS_SDK_WARNINGS === "true");
+
+  if (isDevelopment) {
+    // eslint-disable-next-line no-console
+    console.warn(message);
+  }
+}
+
 /**
  * Sleep for the specified amount of time in milliseconds.
  * This function can be used to introduce delays in asynchronous operations.
@@ -154,7 +196,6 @@ export const parseEncodedStruct = (structObj: {
   module_name: string;
   struct_name: string;
 }): MoveStructId => {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
   const { account_address, module_name, struct_name } = structObj;
   const moduleName = hexToAscii(module_name);
   const structName = hexToAscii(struct_name);
@@ -241,7 +282,6 @@ export function truncateAddress(address: string, start: number = 6, end: number
  * Constants for metadata address calculation
  */
 const APTOS_COIN_TYPE_STR = "0x1::aptos_coin::AptosCoin";
-const APT_METADATA_ADDRESS_HEX = AccountAddress.A.toStringLong();
 
 /**
  * Helper function to standardize Move type string by converting all addresses to short form,
@@ -252,10 +292,10 @@ function standardizeMoveTypeString(input: string): string {
   // This regex matches "0x" followed by hex digits, handling both standalone addresses and those within <>
   const addressRegex = /0x[0-9a-fA-F]+/g;
 
-  return input.replace(addressRegex, (match) => {
+  return input.replace(addressRegex, (match) =>
     // Use AccountAddress to handle the address
-    return AccountAddress.from(match, { maxMissingChars: 63 }).toStringShort();
-  });
+    AccountAddress.from(match, { maxMissingChars: 63 }).toStringShort(),
+  );
 }
 
 /**

package/src/utils/memoize.ts

@@ -2,18 +2,130 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * The global cache Map shared across all functions.  Must keep care to ensure that the
- * cache keys are unique across all functions.
+ * Maximum number of entries to keep in the cache to prevent unbounded memory growth.
+ * When this limit is exceeded, the oldest entries are evicted.
+ */
+const MAX_CACHE_SIZE = 1000;
+
+/**
+ * Interval in milliseconds for periodic cleanup of expired cache entries.
+ */
+const CLEANUP_INTERVAL_MS = 60000; // 1 minute
+
+/**
+ * Minimum required key length to help ensure uniqueness.
+ * Keys should include a namespace prefix (e.g., "module-abi-", "ledger-info-").
+ */
+const MIN_KEY_LENGTH = 10;
+
+/**
+ * Set of known cache key prefixes to help detect potential collisions.
+ * Each caller should use a unique prefix.
+ */
+const knownKeyPrefixes = new Set<string>();
+
+/**
+ * Validates a cache key for basic security requirements.
+ * @param key - The cache key to validate
+ * @throws Error if the key is invalid
+ */
+function validateCacheKey(key: string): void {
+  if (!key || typeof key !== "string") {
+    throw new Error("Cache key must be a non-empty string");
+  }
+  if (key.length < MIN_KEY_LENGTH) {
+    throw new Error(
+      `Cache key "${key}" is too short. Keys should be at least ${MIN_KEY_LENGTH} characters and include a namespace prefix.`,
+    );
+  }
+  // Extract prefix (everything before the last hyphen or the first 10 chars)
+  const prefixMatch = key.match(/^([a-z]+-[a-z]+-)/i);
+  if (prefixMatch) {
+    knownKeyPrefixes.add(prefixMatch[1]);
+  }
+}
+
+/**
+ * Cache entry structure with value, timestamp, and last access time for LRU eviction.
+ */
+interface CacheEntry<T> {
+  value: T;
+  timestamp: number;
+  lastAccess: number;
+  ttlMs?: number;
+}
+
+/**
+ * The global cache Map shared across all functions with LRU eviction support.
+ * SECURITY: All cache keys should include a unique namespace prefix to prevent
+ * collisions between different caching use cases (e.g., "module-abi-", "ledger-info-").
  * @group Implementation
  * @category Utils
  */
-const cache = new Map<string, { value: any; timestamp: number }>();
+const cache = new Map<string, CacheEntry<any>>();
+
+/**
+ * Track whether cleanup interval is set up.
+ */
+let cleanupIntervalId: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Sets up periodic cleanup of expired cache entries if not already running.
+ * This prevents memory leaks from accumulating expired entries.
+ */
+function ensureCleanupInterval(): void {
+  if (cleanupIntervalId === null) {
+    cleanupIntervalId = setInterval(() => {
+      const now = Date.now();
+      const keysToDelete: string[] = [];
+
+      cache.forEach((entry, key) => {
+        // Remove entries that have expired
+        if (entry.ttlMs !== undefined && now - entry.timestamp > entry.ttlMs) {
+          keysToDelete.push(key);
+        }
+      });
+
+      keysToDelete.forEach((key) => cache.delete(key));
+
+      // If cache is empty, stop the cleanup interval to avoid unnecessary overhead
+      if (cache.size === 0 && cleanupIntervalId !== null) {
+        clearInterval(cleanupIntervalId);
+        cleanupIntervalId = null;
+      }
+    }, CLEANUP_INTERVAL_MS);
+
+    // Ensure the interval doesn't prevent Node.js from exiting
+    if (typeof cleanupIntervalId === "object" && "unref" in cleanupIntervalId) {
+      cleanupIntervalId.unref();
+    }
+  }
+}
+
+/**
+ * Evicts the least recently used entries when cache exceeds maximum size.
+ */
+function evictIfNeeded(): void {
+  if (cache.size >= MAX_CACHE_SIZE) {
+    // Find and remove the least recently accessed entries (remove ~10% of cache)
+    const entriesToRemove = Math.ceil(MAX_CACHE_SIZE * 0.1);
+    const entries = Array.from(cache.entries()).sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+
+    for (let i = 0; i < entriesToRemove && i < entries.length; i += 1) {
+      cache.delete(entries[i][0]);
+    }
+  }
+}
 
 /**
  * A memoize higher-order function to cache the response of an async function.
  * This function helps to improve performance by avoiding repeated calls to the same async function with the same arguments
  * within a specified time-to-live (TTL).
  *
+ * Features:
+ * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries
+ * - Periodic cleanup of expired entries to prevent memory leaks
+ *
  * @param func The async function to cache the result of.
  * @param key The cache key used to store the result.
  * @param ttlMs The time-to-live in milliseconds for cached data.
@@ -26,20 +138,35 @@ export function memoizeAsync<T>(
   key: string,
   ttlMs?: number,
 ): (...args: any[]) => Promise<T> {
+  // Validate key format on first call to catch misuse early
+  validateCacheKey(key);
+
   return async (...args: any[]) => {
+    const now = Date.now();
+
     // Check if the cached result exists and is within TTL
     if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key)!;
-      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
-        return value;
+      const entry = cache.get(key)!;
+      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {
+        // Update last access time for LRU
+        entry.lastAccess = now;
+        return entry.value;
       }
+      // Entry expired, remove it
+      cache.delete(key);
     }
 
     // If not cached or TTL expired, compute the result
     const result = await func(...args);
 
+    // Evict old entries if needed before adding new one
+    evictIfNeeded();
+
     // Cache the result with a timestamp
-    cache.set(key, { value: result, timestamp: Date.now() });
+    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });
+
+    // Ensure cleanup is running
+    ensureCleanupInterval();
 
     return result;
   };
@@ -48,6 +175,10 @@ export function memoizeAsync<T>(
 /**
  * Caches the result of a function call to improve performance on subsequent calls with the same arguments.
  *
+ * Features:
+ * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries
+ * - Periodic cleanup of expired entries to prevent memory leaks
+ *
  * @param key - The key to cache on, all accesses by this key will return the cached value.
  * @param func - The function whose result will be cached.
  * @param ttlMs - The time-to-live in milliseconds for cached data.
@@ -56,21 +187,56 @@ export function memoizeAsync<T>(
  * @category Utils
  */
 export function memoize<T>(func: (...args: any[]) => T, key: string, ttlMs?: number): (...args: any[]) => T {
+  // Validate key format on first call to catch misuse early
+  validateCacheKey(key);
+
   return (...args: any[]) => {
+    const now = Date.now();
+
     // Check if the cached result exists and is within TTL
     if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key)!;
-      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
-        return value;
+      const entry = cache.get(key)!;
+      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {
+        // Update last access time for LRU
+        entry.lastAccess = now;
+        return entry.value;
       }
+      // Entry expired, remove it
+      cache.delete(key);
     }
 
     // If not cached or TTL expired, compute the result
     const result = func(...args);
 
+    // Evict old entries if needed before adding new one
+    evictIfNeeded();
+
     // Cache the result with a timestamp
-    cache.set(key, { value: result, timestamp: Date.now() });
+    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });
+
+    // Ensure cleanup is running
+    ensureCleanupInterval();
 
     return result;
   };
 }
+
+/**
+ * Clears all entries from the memoization cache.
+ * Useful for testing or when you need to force fresh data.
+ * @group Implementation
+ * @category Utils
+ */
+export function clearMemoizeCache(): void {
+  cache.clear();
+}
+
+/**
+ * Returns the current size of the memoization cache.
+ * Useful for monitoring and debugging.
+ * @group Implementation
+ * @category Utils
+ */
+export function getMemoizeCacheSize(): number {
+  return cache.size;
+}

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "6.0.0";
+export const VERSION = "6.1.0";

package/dist/common/chunk-4RHBBU7C.js

@@ -1,4 +0,0 @@
-"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 g=(n,e,t,r)=>{for(var s=r>1?void 0:r?$(e,t):e,o=n.length-1,c;o>=0;o--)(c=n[o])&&(s=(r?c(e,t,s):c(s))||s);return r&&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=(r=>(r.TOO_SHORT="too_short",r.INVALID_LENGTH="invalid_length",r.INVALID_HEX_CHARS="invalid_hex_chars",r))(j||{}),x= exports.v =class n{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 n(_utils.hexToBytes.call(void 0, t))}catch(r){throw new u(`Hex string contains invalid hex characters: ${_optionalChain([r, 'optionalAccess', _2 => _2.message])}`,"invalid_hex_chars")}}static fromHexInput(e){return e instanceof Uint8Array?new n(e):n.fromHexString(e)}static hexInputToUint8Array(e){return e instanceof Uint8Array?e:n.fromHexString(e).toUint8Array()}static hexInputToString(e){return n.fromHexInput(e).toString()}static hexInputToStringWithoutPrefix(e){return n.fromHexInput(e).toStringWithoutPrefix()}static isValid(e){try{return n.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,r)=>t===e.data[r])}},Ee= exports.w =n=>new TextDecoder().decode(x.fromHexInput(n).toUint8Array());var M=255,v= exports.c =65535,f= exports.d =4294967295,m= exports.e =18446744073709551615n,I= exports.f =340282366920938463463374607431768211455n,U= exports.g =115792089237316195423570985008687907853269984665640564039457584007913129639935n,T= exports.h =-128,N= exports.i =127,B= exports.j =-32768,E= exports.k =32767,w= exports.l =-2147483648,k= exports.m =2147483647,C= 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 d;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()}`}},d= 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,r){this.ensureBufferWillHandleSize(t);let s=new DataView(this.buffer,this.offset);e.apply(s,[0,r,!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),r=BigInt(e)>>BigInt(32);this.serializeU32(Number(t)),this.serializeU32(Number(r))}serializeU128(e){let t=BigInt(e)&m,r=BigInt(e)>>BigInt(64);this.serializeU64(t),this.serializeU64(r)}serializeU256(e){let t=BigInt(e)&I,r=BigInt(e)>>BigInt(128);this.serializeU128(t),this.serializeU128(r)}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),r=t<0?(BigInt(1)<<BigInt(64))+t:t,s=r&BigInt(f),o=r>>BigInt(32);this.serializeU32(Number(s)),this.serializeU32(Number(o))}serializeI128(e){let t=BigInt(e),r=t<0?(BigInt(1)<<BigInt(128))+t:t,s=r&m,o=r>>BigInt(64);this.serializeU64(s),this.serializeU64(o)}serializeI256(e){let t=BigInt(e),r=t<0?(BigInt(1)<<BigInt(256))+t:t,s=r&I,o=r>>BigInt(128);this.serializeU128(s),this.serializeU128(o)}serializeU32AsUleb128(e){let t=e,r=[];for(;t>>>7;)r.push(t&127|128),t>>>=7;r.push(t),this.appendToBuffer(new Uint8Array(r))}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 r=e!==void 0;this.serializeBool(r),r&&(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))}};g([l(0,M)],d.prototype,"serializeU8",1),g([l(0,v)],d.prototype,"serializeU16",1),g([l(0,f)],d.prototype,"serializeU32",1),g([l(BigInt(0),m)],d.prototype,"serializeU64",1),g([l(BigInt(0),I)],d.prototype,"serializeU128",1),g([l(BigInt(0),U)],d.prototype,"serializeU256",1),g([l(T,N)],d.prototype,"serializeI8",1),g([l(B,E)],d.prototype,"serializeI16",1),g([l(w,k)],d.prototype,"serializeI32",1),g([l(C,O)],d.prototype,"serializeI64",1),g([l(G,D)],d.prototype,"serializeI128",1),g([l(z,F)],d.prototype,"serializeI256",1),g([l(0,f)],d.prototype,"serializeU32AsUleb128",1);function K(n){if(typeof n!="boolean")throw new Error(`${n} is not a boolean value`)}var Y=(n,e,t)=>`${n} is out of range: [${e}, ${t}]`;function Z(n,e,t){let r=BigInt(n);if(r>BigInt(t)||r<BigInt(e))throw new Error(Y(n,e,t))}function l(n,e){return(t,r,s)=>{let o=s.value;return s.value=function(_){return Z(_,n,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 =(a=>(a[a.U8=0]="U8",a[a.U64=1]="U64",a[a.U128=2]="U128",a[a.Address=3]="Address",a[a.U8Vector=4]="U8Vector",a[a.Bool=5]="Bool",a[a.U16=6]="U16",a[a.U32=7]="U32",a[a.U256=8]="U256",a[a.Serialized=9]="Serialized",a[a.I8=10]="I8",a[a.I16=11]="I16",a[a.I32=12]="I32",a[a.I64=13]="I64",a[a.I128=14]="I128",a[a.I256=15]="I256",a))(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 =(r=>(r[r.Script=0]="Script",r[r.EntryFunction=1]="EntryFunction",r[r.Empty=2]="Empty",r))(te||{}),ne= exports.I =(e=>(e[e.V1=0]="V1",e))(ne||{}),re= exports.J =(t=>(t[t.MultiAgentTransaction=0]="MultiAgentTransaction",t[t.FeePayerTransaction=1]="FeePayerTransaction",t))(re||{}),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 =(r=>(r.Ed25519="ed25519",r.Secp256k1="secp256k1",r.Secp256r1="secp256r1",r))(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 ze(n){switch(n){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||{}),de= exports.S =(e=>(e[e.ZkProof=0]="ZkProof",e))(de||{}),ge= exports.T =(e=>(e[e.Groth16=0]="Groth16",e))(ge||{}),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 Fe(n){return n.type==="pending_transaction"}function He(n){return n.type==="user_transaction"}function We(n){return n.type==="genesis_transaction"}function Pe(n){return n.type==="block_metadata_transaction"}function Le(n){return n.type==="state_checkpoint_transaction"}function $e(n){return n.type==="validator_transaction"}function Xe(n){return n.type==="block_epilogue_transaction"}function qe(n){return"signature"in n&&n.type==="ed25519_signature"}function je(n){return"signature"in n&&n.signature==="secp256k1_ecdsa_signature"}function Ke(n){return n.type==="multi_agent_signature"}function Ye(n){return n.type==="fee_payer_signature"}function Ze(n){return n.type==="multi_ed25519_signature"}function Qe(n){return n.type==="single_sender"}var ye=(r=>(r.PRIVATE="private",r.PUBLIC="public",r.FRIEND="friend",r))(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 me=(t=>(t[t.Independent=0]="Independent",t[t.FollowsDomain=1]="FollowsDomain",t))(me||{}),Ie= exports.na =(r=>(r.Expired="expired",r.InGracePeriod="in_grace_period",r.Active="active",r))(Ie||{});var Ae=(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))(Ae||{}),p=class p extends b{constructor(e){if(super(),e.length!==p.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(p.LENGTH);return new p(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=p.fromString(e);if(e.length!==p.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 r=e;if(e.startsWith("0x")&&(r=e.slice(2)),r.length===0)throw new u("Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.","too_short");if(r.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, r.padStart(64,"0"))}catch(c){throw new u(`Hex characters are invalid: ${_optionalChain([c, 'optionalAccess', _5 => _5.message])}`,"invalid_hex_chars")}let o=new p(s);if(r.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"?p.fromString(e,{maxMissingChars:t}):e instanceof Uint8Array?new p(e):e}static fromStrict(e){return typeof e=="string"?p.fromStringStrict(e):e instanceof Uint8Array?new p(e):e}static isValid(e){try{return e.strict?p.fromStrict(e.input):p.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,r)=>t===e.data[r])}};p.LENGTH=32,p.LONG_STRING_LENGTH=64,p.ZERO=p.from("0x0"),p.ONE=p.from("0x1"),p.TWO=p.from("0x2"),p.THREE=p.from("0x3"),p.FOUR=p.from("0x4"),p.A=p.from("0xA");var y=p;var _sha3 = require('@noble/hashes/sha3');var R=(n,e)=>{let t=n.bcsToBytes(),r=typeof e=="string"?Buffer.from(e,"utf8"):e,s=new Uint8Array([...t,...r,254]);return new y(_sha3.sha3_256.call(void 0, s))},_t= exports.ra =(n,e)=>{let t=n.bcsToBytes(),r=typeof e=="string"?Buffer.from(e,"utf8"):e,s=new Uint8Array([...t,...r,255]);return new y(_sha3.sha3_256.call(void 0, s))},ht= exports.sa =(n,e)=>{let t=n.bcsToBytes(),r=e.bcsToBytes(),s=new Uint8Array([...t,...r,252]);return new y(_sha3.sha3_256.call(void 0, s))},xt= exports.ta =(n,e,t)=>{let r=`${e}::${t}`;return R(n,r)};var _jsbase64 = require('js-base64');async function At(n){return new Promise(e=>{setTimeout(e,n)})}function St(n){return n instanceof Error?n.message:String(n)}var Rt=()=>Math.floor(Date.now()/1e3);function Mt(n){let e=new Date(n*1e3);return e.setMinutes(0),e.setSeconds(0),e.setMilliseconds(0),Math.floor(e.getTime()/1e3)}function vt(n){let e=n.replace(/-/g,"+").replace(/_/g,"/"),t=e+"==".substring(0,(3-e.length%3)%3);return _jsbase64.decode.call(void 0, t)}function Ut(n){let e=n.replace(/-/g,"+").replace(/_/g,"/");for(;e.length%4!==0;)e+="=";return new Uint8Array(Buffer.from(e,"base64"))}var Tt=(n,e)=>n*10**e,Nt= exports.Ba =(n,e)=>n/10**e,P=n=>{let e="";for(let t=2;t<n.length;t+=2)e+=String.fromCharCode(parseInt(n.substring(t,t+2),16));return e},Bt= exports.Ca =n=>{let{account_address:e,module_name:t,struct_name:r}=n,s=P(t),o=P(r);return`${e}::${s}::${o}`},Et= exports.Da =n=>typeof n=="object"&&!Array.isArray(n)&&n!==null&&"account_address"in n&&"module_name"in n&&"struct_name"in n&&typeof n.account_address=="string"&&typeof n.module_name=="string"&&typeof n.struct_name=="string";function wt(n){let e=n.split("::");if(e.length!==3)throw new Error(`Invalid function ${n}`);let t=e[0],r=e[1],s=e[2];return{moduleAddress:t,moduleName:r,functionName:s}}function kt(n){let e=n.split("::");return e.length===3&&y.isValid({input:e[0]}).valid}function Ct(n,e=6,t=5){return`${n.slice(0,e)}...${n.slice(-t)}`}var Re="0x1::aptos_coin::AptosCoin",Ot=y.A.toStringLong();function Me(n){let e=/0x[0-9a-fA-F]+/g;return n.replace(e,t=>y.from(t,{maxMissingChars:63}).toStringShort())}function Gt(n){let e=Me(n);return e===Re?y.A:R(y.A,e)}exports.a = g; exports.b = M; exports.c = v; exports.d = f; exports.e = m; exports.f = I; exports.g = U; exports.h = T; exports.i = N; exports.j = B; exports.k = E; exports.l = w; exports.m = k; exports.n = C; 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 = Ee; exports.x = b; exports.y = d; 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 = ne; exports.J = re; exports.K = se; exports.L = oe; exports.M = ie; exports.N = ae; exports.O = ze; exports.P = pe; exports.Q = ce; exports.R = ue; exports.S = de; exports.T = ge; exports.U = le; exports.V = Fe; exports.W = He; exports.X = We; exports.Y = Pe; exports.Z = Le; exports._ = $e; exports.$ = Xe; exports.aa = qe; exports.ba = je; exports.ca = Ke; exports.da = Ye; exports.ea = Ze; exports.fa = Qe; exports.ga = ye; exports.ha = _e; exports.ia = he; exports.ja = xe; exports.ka = fe; exports.la = W; exports.ma = me; exports.na = Ie; exports.oa = Ae; exports.pa = y; exports.qa = R; exports.ra = _t; exports.sa = ht; exports.ta = xt; exports.ua = At; exports.va = St; exports.wa = Rt; exports.xa = Mt; exports.ya = vt; exports.za = Ut; exports.Aa = Tt; exports.Ba = Nt; exports.Ca = Bt; exports.Da = Et; exports.Ea = wt; exports.Fa = kt; exports.Ga = Ct; exports.Ha = Gt;
-//# sourceMappingURL=chunk-4RHBBU7C.js.map

package/dist/common/chunk-4RHBBU7C.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kent/aptos-ts-sdk/dist/common/chunk-4RHBBU7C.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;ACkVsB;AAnWV,SAAA","file":"/Users/kent/aptos-ts-sdk/dist/common/chunk-4RHBBU7C.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 Uint8Array) return new Hex(hexInput);\n    return Hex.fromHexString(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   * Convert the account address to a string in SHORT format, which is 0x followed by the shortest\n   * possible representation (no leading zeros).\n   *\n   * @returns AccountAddress as a string in SHORT form.\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringShort(): `0x${string}` {\n    return `0x${this.toStringShortWithoutPrefix()}`;\n  }\n\n  /**\n   * Returns a lossless short string representation of the address by trimming leading zeros.\n   * If the address consists of all zeros, returns \"0\".\n   *\n   * @returns A string representation of the address without leading zeros\n   * @group Implementation\n   * @category Serialization\n   */\n  toStringShortWithoutPrefix(): string {\n    const hex = bytesToHex(this.data).replace(/^0+/, \"\");\n    return hex === \"\" ? \"0\" : hex;\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"]}