@aptos-labs/ts-sdk 0.0.1 → 0.0.3

package/dist/esm/index.mjs

@@ -24,7 +24,7 @@ var AptosApiError = class extends Error {
 };
 
 // src/version.ts
-var VERSION = "0.0.0";
+var VERSION = "2.0.0";
 
 // src/types/index.ts
 var MimeType = /* @__PURE__ */ ((MimeType2) => {
@@ -45,6 +45,8 @@ var TypeTagVariants = /* @__PURE__ */ ((TypeTagVariants2) => {
   TypeTagVariants2[TypeTagVariants2["U16"] = 8] = "U16";
   TypeTagVariants2[TypeTagVariants2["U32"] = 9] = "U32";
   TypeTagVariants2[TypeTagVariants2["U256"] = 10] = "U256";
+  TypeTagVariants2[TypeTagVariants2["Reference"] = 254] = "Reference";
+  TypeTagVariants2[TypeTagVariants2["Generic"] = 255] = "Generic";
   return TypeTagVariants2;
 })(TypeTagVariants || {});
 var ScriptTransactionArgumentVariants = /* @__PURE__ */ ((ScriptTransactionArgumentVariants2) => {
@@ -75,15 +77,26 @@ var TransactionAuthenticatorVariant = /* @__PURE__ */ ((TransactionAuthenticator
   TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["MultiEd25519"] = 1] = "MultiEd25519";
   TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["MultiAgent"] = 2] = "MultiAgent";
   TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["FeePayer"] = 3] = "FeePayer";
-  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["Secp256k1Ecdsa"] = 4] = "Secp256k1Ecdsa";
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["SingleSender"] = 4] = "SingleSender";
   return TransactionAuthenticatorVariant2;
 })(TransactionAuthenticatorVariant || {});
 var AccountAuthenticatorVariant = /* @__PURE__ */ ((AccountAuthenticatorVariant2) => {
   AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["Ed25519"] = 0] = "Ed25519";
   AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["MultiEd25519"] = 1] = "MultiEd25519";
-  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["Secp256k1"] = 2] = "Secp256k1";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["SingleKey"] = 2] = "SingleKey";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["MultiKey"] = 3] = "MultiKey";
   return AccountAuthenticatorVariant2;
 })(AccountAuthenticatorVariant || {});
+var AnyPublicKeyVariant = /* @__PURE__ */ ((AnyPublicKeyVariant2) => {
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["Ed25519"] = 0] = "Ed25519";
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["Secp256k1"] = 1] = "Secp256k1";
+  return AnyPublicKeyVariant2;
+})(AnyPublicKeyVariant || {});
+var AnySignatureVariant = /* @__PURE__ */ ((AnySignatureVariant2) => {
+  AnySignatureVariant2[AnySignatureVariant2["Ed25519"] = 0] = "Ed25519";
+  AnySignatureVariant2[AnySignatureVariant2["Secp256k1"] = 1] = "Secp256k1";
+  return AnySignatureVariant2;
+})(AnySignatureVariant || {});
 var TransactionResponseType = /* @__PURE__ */ ((TransactionResponseType2) => {
   TransactionResponseType2["Pending"] = "pending_transaction";
   TransactionResponseType2["User"] = "user_transaction";
@@ -113,9 +126,15 @@ var RoleType = /* @__PURE__ */ ((RoleType2) => {
 var SigningScheme = /* @__PURE__ */ ((SigningScheme2) => {
   SigningScheme2[SigningScheme2["Ed25519"] = 0] = "Ed25519";
   SigningScheme2[SigningScheme2["MultiEd25519"] = 1] = "MultiEd25519";
-  SigningScheme2[SigningScheme2["Secp256k1Ecdsa"] = 2] = "Secp256k1Ecdsa";
+  SigningScheme2[SigningScheme2["SingleKey"] = 2] = "SingleKey";
+  SigningScheme2[SigningScheme2["MultiKey"] = 3] = "MultiKey";
   return SigningScheme2;
 })(SigningScheme || {});
+var SigningSchemeInput = /* @__PURE__ */ ((SigningSchemeInput2) => {
+  SigningSchemeInput2[SigningSchemeInput2["Ed25519"] = 0] = "Ed25519";
+  SigningSchemeInput2[SigningSchemeInput2["Secp256k1Ecdsa"] = 2] = "Secp256k1Ecdsa";
+  return SigningSchemeInput2;
+})(SigningSchemeInput || {});
 var DeriveScheme = /* @__PURE__ */ ((DeriveScheme2) => {
   DeriveScheme2[DeriveScheme2["DeriveAuid"] = 251] = "DeriveAuid";
   DeriveScheme2[DeriveScheme2["DeriveObjectAddressFromObject"] = 252] = "DeriveObjectAddressFromObject";
@@ -170,14 +189,15 @@ async function aptosRequest(options, aptosConfig) {
     url: fullUrl
   };
   if (aptosConfig.isIndexerRequest(url)) {
-    if (result.data.errors) {
+    const indexerResponse = result.data;
+    if (indexerResponse.errors) {
       throw new AptosApiError(
         options,
         result,
-        (_a = response.data.errors[0].message) != null ? _a : `Unhandled Error ${response.status} : ${response.statusText}`
+        (_a = indexerResponse.errors[0].message) != null ? _a : `Unhandled Error ${response.status} : ${response.statusText}`
       );
     }
-    result.data = result.data.data;
+    result.data = indexerResponse.data;
   }
   if (result.status >= 200 && result.status < 300) {
     return result;
@@ -245,7 +265,7 @@ async function get(options) {
       acceptType: acceptType == null ? void 0 : acceptType.valueOf(),
       params,
       overrides: {
-        ...aptosConfig,
+        ...aptosConfig.clientConfig,
         ...overrides
       }
     },
@@ -293,7 +313,7 @@ async function post(options) {
       acceptType: acceptType == null ? void 0 : acceptType.valueOf(),
       params,
       overrides: {
-        ...aptosConfig,
+        ...aptosConfig.clientConfig,
         ...overrides
       }
     },
@@ -692,6 +712,7 @@ var _AccountAddress = class extends Serializable {
 var AccountAddress = _AccountAddress;
 AccountAddress.LENGTH = 32;
 AccountAddress.LONG_STRING_LENGTH = 64;
+AccountAddress.ZERO = _AccountAddress.fromString("0x0");
 AccountAddress.ONE = _AccountAddress.fromString("0x1");
 AccountAddress.TWO = _AccountAddress.fromString("0x2");
 AccountAddress.THREE = _AccountAddress.fromString("0x3");
@@ -1120,29 +1141,6 @@ var MoveOption = class extends Serializable {
     return new MoveOption(vector.values[0]);
   }
 };
-var MoveObject = class extends Serializable {
-  constructor(value) {
-    super();
-    if (value instanceof AccountAddress) {
-      this.value = value;
-    } else {
-      this.value = AccountAddress.fromHexInputRelaxed(value);
-    }
-  }
-  serialize(serializer) {
-    serializer.serialize(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    this.value.serializeForEntryFunction(serializer);
-  }
-  serializeForScriptFunction(serializer) {
-    this.value.serializeForScriptFunction(serializer);
-  }
-  static deserialize(deserializer) {
-    const address = deserializer.deserialize(AccountAddress);
-    return new MoveObject(address);
-  }
-};
 
 // src/core/crypto/asymmetricCrypto.ts
 var PublicKey = class extends Serializable {
@@ -1181,6 +1179,10 @@ var _Ed25519PublicKey = class extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new _Ed25519PublicKey(bytes);
   }
+  static load(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    return new _Ed25519PublicKey(bytes);
+  }
 };
 var Ed25519PublicKey = _Ed25519PublicKey;
 Ed25519PublicKey.LENGTH = 32;
@@ -1244,6 +1246,10 @@ var _Ed25519Signature = class extends Signature {
     const bytes = deserializer.deserializeBytes();
     return new _Ed25519Signature(bytes);
   }
+  static load(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    return new _Ed25519Signature(bytes);
+  }
 };
 var Ed25519Signature = _Ed25519Signature;
 Ed25519Signature.LENGTH = 64;
@@ -1394,6 +1400,10 @@ var _Secp256k1PublicKey = class extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new _Secp256k1PublicKey(bytes);
   }
+  static load(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    return new _Secp256k1PublicKey(bytes);
+  }
 };
 var Secp256k1PublicKey = _Secp256k1PublicKey;
 Secp256k1PublicKey.LENGTH = 65;
@@ -1441,7 +1451,7 @@ var _Secp256k1Signature = class extends Signature {
     super();
     const hex = Hex.fromHexInput(hexInput);
     if (hex.toUint8Array().length !== _Secp256k1Signature.LENGTH) {
-      throw new Error(`Signature length should be ${_Secp256k1Signature.LENGTH}`);
+      throw new Error(`Signature length should be ${_Secp256k1Signature.LENGTH}, recieved ${hex.toUint8Array().length}`);
     }
     this.data = hex;
   }
@@ -1458,13 +1468,122 @@ var _Secp256k1Signature = class extends Signature {
     const hex = deserializer.deserializeBytes();
     return new _Secp256k1Signature(hex);
   }
+  static load(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    return new _Secp256k1Signature(bytes);
+  }
 };
 var Secp256k1Signature = _Secp256k1Signature;
 Secp256k1Signature.LENGTH = 64;
 
+// src/core/crypto/anyPublicKey.ts
+var AnyPublicKey = class extends PublicKey {
+  constructor(publicKey) {
+    super();
+    this.publicKey = publicKey;
+  }
+  toUint8Array() {
+    return this.publicKey.toUint8Array();
+  }
+  toString() {
+    return this.publicKey.toString();
+  }
+  verifySignature(args) {
+    const { message, signature } = args;
+    return this.publicKey.verifySignature({ message, signature });
+  }
+  serialize(serializer) {
+    if (this.publicKey instanceof Ed25519PublicKey) {
+      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
+      this.publicKey.serialize(serializer);
+    } else if (this.publicKey instanceof Secp256k1PublicKey) {
+      serializer.serializeU32AsUleb128(1 /* Secp256k1 */);
+      this.publicKey.serialize(serializer);
+    } else {
+      throw new Error("Unknown public key type");
+    }
+  }
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case 0 /* Ed25519 */:
+        return new AnyPublicKey(Ed25519PublicKey.load(deserializer));
+      case 1 /* Secp256k1 */:
+        return new AnyPublicKey(Secp256k1PublicKey.load(deserializer));
+      default:
+        throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);
+    }
+  }
+};
+
+// src/core/crypto/multiKey.ts
+var MultiKey = class extends PublicKey {
+  constructor(args) {
+    super();
+    const { publicKeys, signaturesRequired } = args;
+    if (signaturesRequired < 1) {
+      throw new Error("The number of required signatures needs to be greater then 0");
+    }
+    if (publicKeys.length < signaturesRequired) {
+      throw new Error(
+        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`
+      );
+    }
+    const keys = [];
+    publicKeys.forEach((publicKey) => {
+      if (publicKey instanceof AnyPublicKey) {
+        keys.push(publicKey);
+      } else {
+        keys.push(new AnyPublicKey(publicKey));
+      }
+    });
+    this.publicKeys = keys;
+    this.signaturesRequired = signaturesRequired;
+  }
+  toUint8Array() {
+    return this.bcsToBytes();
+  }
+  createBitmap(args) {
+    const { bits } = args;
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+    const dupCheckSet = /* @__PURE__ */ new Set();
+    bits.forEach((bit, idx) => {
+      if (idx + 1 > this.publicKeys.length) {
+        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
+      }
+      if (dupCheckSet.has(bit)) {
+        throw new Error(`Duplicate bit ${bit} detected.`);
+      }
+      dupCheckSet.add(bit);
+      const byteOffset = Math.floor(bit / 8);
+      let byte = bitmap[byteOffset];
+      byte |= firstBitInByte >> bit % 8;
+      bitmap[byteOffset] = byte;
+    });
+    return bitmap;
+  }
+  toString() {
+    return Hex.fromHexInput(this.toUint8Array()).toString();
+  }
+  verifySignature(args) {
+    throw new Error("not implemented");
+  }
+  serialize(serializer) {
+    serializer.serializeVector(this.publicKeys);
+    serializer.serializeU8(this.signaturesRequired);
+  }
+  static deserialize(deserializer) {
+    const keys = deserializer.deserializeVector(AnyPublicKey);
+    const signaturesRequired = deserializer.deserializeU8();
+    return new MultiKey({ publicKeys: keys, signaturesRequired });
+  }
+};
+
 // src/core/authenticationKey.ts
-var _AuthenticationKey = class {
+var _AuthenticationKey = class extends Serializable {
   constructor(args) {
+    super();
     const { data } = args;
     const hex = Hex.fromHexInput(data);
     if (hex.toUint8Array().length !== _AuthenticationKey.LENGTH) {
@@ -1472,21 +1591,43 @@ var _AuthenticationKey = class {
     }
     this.data = hex;
   }
+  serialize(serializer) {
+    serializer.serializeFixedBytes(this.data.toUint8Array());
+  }
+  static deserialize(deserializer) {
+    const bytes = deserializer.deserializeFixedBytes(_AuthenticationKey.LENGTH);
+    return new _AuthenticationKey({ data: bytes });
+  }
   toString() {
     return this.data.toString();
   }
   toUint8Array() {
     return this.data.toUint8Array();
   }
-  static fromBytesAndScheme(args) {
-    const { bytes, scheme } = args;
-    const inputBytes = Hex.fromHexInput(bytes).toUint8Array();
-    const authKeyBytes = new Uint8Array(inputBytes.length + 1);
-    authKeyBytes.set(inputBytes);
-    authKeyBytes.set([scheme], inputBytes.length);
+  static fromPublicKeyAndScheme(args) {
+    const { publicKey, scheme } = args;
+    let authKeyBytes;
+    switch (scheme) {
+      case 3 /* MultiKey */:
+      case 2 /* SingleKey */: {
+        const singleKeyBytes = publicKey.bcsToBytes();
+        authKeyBytes = new Uint8Array([...singleKeyBytes, scheme]);
+        break;
+      }
+      case 0 /* Ed25519 */:
+      case 1 /* MultiEd25519 */: {
+        const ed25519PublicKeyBytes = publicKey.toUint8Array();
+        const inputBytes = Hex.fromHexInput(ed25519PublicKeyBytes).toUint8Array();
+        authKeyBytes = new Uint8Array([...inputBytes, scheme]);
+        break;
+      }
+      default:
+        throw new Error(`Scheme ${scheme} is not supported`);
+    }
     const hash = sha3Hash.create();
     hash.update(authKeyBytes);
-    return new _AuthenticationKey({ data: hash.digest() });
+    const hashDigest = hash.digest();
+    return new _AuthenticationKey({ data: hashDigest });
   }
   static fromPublicKey(args) {
     const { publicKey } = args;
@@ -1495,13 +1636,14 @@ var _AuthenticationKey = class {
       scheme = 0 /* Ed25519 */.valueOf();
     } else if (publicKey instanceof MultiEd25519PublicKey) {
       scheme = 1 /* MultiEd25519 */.valueOf();
-    } else if (publicKey instanceof Secp256k1PublicKey) {
-      scheme = 2 /* Secp256k1Ecdsa */.valueOf();
+    } else if (publicKey instanceof AnyPublicKey) {
+      scheme = 2 /* SingleKey */.valueOf();
+    } else if (publicKey instanceof MultiKey) {
+      scheme = 3 /* MultiKey */.valueOf();
     } else {
       throw new Error("No supported authentication scheme for public key");
     }
-    const pubKeyBytes = publicKey.toUint8Array();
-    return _AuthenticationKey.fromBytesAndScheme({ bytes: pubKeyBytes, scheme });
+    return _AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme });
   }
   derivedAddress() {
     return new AccountAddress({ data: this.data.toUint8Array() });
@@ -1559,50 +1701,58 @@ var derivePrivateKeyFromMnemonic = (keyType, path, seedPhrase, offset = HARDENED
 // src/core/account.ts
 var Account = class {
   constructor(args) {
-    const { privateKey, address } = args;
+    const { privateKey, address, legacy } = args;
     this.publicKey = privateKey.publicKey();
     if (this.publicKey instanceof Ed25519PublicKey) {
-      this.signingScheme = 0 /* Ed25519 */;
+      if (legacy) {
+        this.signingScheme = 0 /* Ed25519 */;
+      } else {
+        this.publicKey = new AnyPublicKey(this.publicKey);
+        this.signingScheme = 2 /* SingleKey */;
+      }
     } else if (this.publicKey instanceof MultiEd25519PublicKey) {
       this.signingScheme = 1 /* MultiEd25519 */;
     } else if (this.publicKey instanceof Secp256k1PublicKey) {
-      this.signingScheme = 2 /* Secp256k1Ecdsa */;
+      this.publicKey = new AnyPublicKey(this.publicKey);
+      this.signingScheme = 2 /* SingleKey */;
     } else {
       throw new Error("Can not create new Account, unsupported public key type");
     }
     this.privateKey = privateKey;
     this.accountAddress = address;
   }
-  static generate(scheme) {
+  static generate(args) {
     let privateKey;
-    switch (scheme) {
+    switch (args == null ? void 0 : args.scheme) {
       case 2 /* Secp256k1Ecdsa */:
         privateKey = Secp256k1PrivateKey.generate();
         break;
       default:
         privateKey = Ed25519PrivateKey.generate();
     }
+    let publicKey = privateKey.publicKey();
+    if (!(args == null ? void 0 : args.legacy)) {
+      publicKey = new AnyPublicKey(privateKey.publicKey());
+    }
     const address = new AccountAddress({
       data: Account.authKey({
-        publicKey: privateKey.publicKey()
+        publicKey
       }).toUint8Array()
     });
-    return new Account({ privateKey, address });
-  }
-  static fromPrivateKey(privateKey) {
-    const publicKey = privateKey.publicKey();
-    const authKey = Account.authKey({ publicKey });
-    const address = new AccountAddress({ data: authKey.toUint8Array() });
-    return Account.fromPrivateKeyAndAddress({ privateKey, address });
+    return new Account({ privateKey, address, legacy: args == null ? void 0 : args.legacy });
   }
   static fromPrivateKeyAndAddress(args) {
-    return new Account(args);
+    const { privateKey, address, legacy } = args;
+    return new Account({ privateKey, address, legacy });
   }
   static fromDerivationPath(args) {
     const { path, mnemonic } = args;
     const { key } = derivePrivateKeyFromMnemonic("ed25519 seed" /* ED25519 */, path, mnemonic);
     const privateKey = new Ed25519PrivateKey(key);
-    return Account.fromPrivateKey(privateKey);
+    const publicKey = privateKey.publicKey();
+    const authKey = Account.authKey({ publicKey });
+    const address = new AccountAddress({ data: authKey.toUint8Array() });
+    return new Account({ privateKey, address, legacy: true });
   }
   static authKey(args) {
     const { publicKey } = args;
@@ -2099,7 +2249,7 @@ async function view(args) {
     body: {
       function: payload.function,
       type_arguments: (_a = payload.typeArguments) != null ? _a : [],
-      arguments: (_b = payload.arguments) != null ? _b : []
+      arguments: (_b = payload.functionArguments) != null ? _b : []
     }
   });
   return data;
@@ -2237,7 +2387,7 @@ async function getResource(args) {
     path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/resource/${resourceType}`,
     params: { ledger_version: options == null ? void 0 : options.ledgerVersion }
   });
-  return data;
+  return data.data;
 }
 async function lookupOriginalAccountAddress(args) {
   const { aptosConfig, authenticationKey, options } = args;
@@ -2249,7 +2399,7 @@ async function lookupOriginalAccountAddress(args) {
   });
   const {
     address_map: { handle }
-  } = resource.data;
+  } = resource;
   try {
     const originalAddress = await getTableItem({
       aptosConfig,
@@ -2455,6 +2605,55 @@ async function getAccountOwnedObjects(args) {
   });
   return data.current_objects;
 }
+async function deriveAccountFromPrivateKey(args) {
+  const { aptosConfig, privateKey } = args;
+  const publicKey = new AnyPublicKey(privateKey.publicKey());
+  if (privateKey instanceof Secp256k1PrivateKey) {
+    const authKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: 2 /* SingleKey */ });
+    const address = new AccountAddress({ data: authKey.toUint8Array() });
+    return Account.fromPrivateKeyAndAddress({ privateKey, address });
+  }
+  if (privateKey instanceof Ed25519PrivateKey) {
+    const SingleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+      publicKey,
+      scheme: 2 /* SingleKey */
+    });
+    const isSingleSenderTransactionAuthenticator = await isAccountExist({
+      authKey: SingleSenderTransactionAuthenticatorAuthKey,
+      aptosConfig
+    });
+    if (isSingleSenderTransactionAuthenticator) {
+      const address = new AccountAddress({ data: SingleSenderTransactionAuthenticatorAuthKey.toUint8Array() });
+      return Account.fromPrivateKeyAndAddress({ privateKey, address });
+    }
+    const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: 0 /* Ed25519 */ });
+    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
+    if (isLegacyEd25519) {
+      const address = new AccountAddress({ data: legacyAuthKey.toUint8Array() });
+      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: true });
+    }
+  }
+  throw new Error(`Can't derive account from private key ${privateKey}`);
+}
+async function isAccountExist(args) {
+  const { aptosConfig, authKey } = args;
+  const accountAddress = await lookupOriginalAccountAddress({
+    aptosConfig,
+    authenticationKey: authKey.toString()
+  });
+  try {
+    await getInfo({
+      aptosConfig,
+      accountAddress: accountAddress.toString()
+    });
+    return true;
+  } catch (error) {
+    if (error.status === 404) {
+      return false;
+    }
+    throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);
+  }
+}
 
 // src/api/account.ts
 var Account2 = class {
@@ -2530,6 +2729,9 @@ var Account2 = class {
       ...args
     });
   }
+  async deriveAccountFromPrivateKey(args) {
+    return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });
+  }
 };
 
 // src/api/aptosConfig.ts
@@ -2573,445 +2775,105 @@ var AptosConfig = class {
   }
 };
 
-// src/transactions/instances/identifier.ts
-var Identifier = class extends Serializable {
-  constructor(identifier) {
+// src/transactions/transactionBuilder/transactionBuilder.ts
+import { sha3_256 as sha3Hash2 } from "@noble/hashes/sha3";
+
+// src/core/crypto/anySignature.ts
+var AnySignature = class extends Signature {
+  constructor(signature) {
     super();
-    this.identifier = identifier;
+    this.signature = signature;
   }
-  serialize(serializer) {
-    serializer.serializeStr(this.identifier);
+  toUint8Array() {
+    return this.signature.toUint8Array();
   }
-  static deserialize(deserializer) {
-    const identifier = deserializer.deserializeStr();
-    return new Identifier(identifier);
+  toString() {
+    return this.signature.toString();
+  }
+  serialize(serializer) {
+    if (this.signature instanceof Ed25519Signature) {
+      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
+      this.signature.serialize(serializer);
+    } else if (this.signature instanceof Secp256k1Signature) {
+      serializer.serializeU32AsUleb128(1 /* Secp256k1 */);
+      this.signature.serialize(serializer);
+    } else {
+      throw new Error("Unknown signature type");
+    }
   }
-};
-
-// src/transactions/typeTag/typeTag.ts
-var TypeTag = class extends Serializable {
   static deserialize(deserializer) {
     const index = deserializer.deserializeUleb128AsU32();
     switch (index) {
-      case 0 /* Bool */:
-        return TypeTagBool.load(deserializer);
-      case 1 /* U8 */:
-        return TypeTagU8.load(deserializer);
-      case 2 /* U64 */:
-        return TypeTagU64.load(deserializer);
-      case 3 /* U128 */:
-        return TypeTagU128.load(deserializer);
-      case 4 /* Address */:
-        return TypeTagAddress.load(deserializer);
-      case 5 /* Signer */:
-        return TypeTagSigner.load(deserializer);
-      case 6 /* Vector */:
-        return TypeTagVector.load(deserializer);
-      case 7 /* Struct */:
-        return TypeTagStruct.load(deserializer);
-      case 8 /* U16 */:
-        return TypeTagU16.load(deserializer);
-      case 9 /* U32 */:
-        return TypeTagU32.load(deserializer);
-      case 10 /* U256 */:
-        return TypeTagU256.load(deserializer);
+      case 0 /* Ed25519 */:
+        return new AnySignature(Ed25519Signature.load(deserializer));
+      case 1 /* Secp256k1 */:
+        return new AnySignature(Secp256k1Signature.load(deserializer));
       default:
-        throw new Error(`Unknown variant index for TypeTag: ${index}`);
+        throw new Error(`Unknown variant index for AnySignature: ${index}`);
     }
   }
 };
-var TypeTagBool = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Bool */);
-  }
-  static load(_deserializer) {
-    return new TypeTagBool();
-  }
-};
-var TypeTagU8 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* U8 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU8();
-  }
-};
-var TypeTagU16 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(8 /* U16 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU16();
-  }
-};
-var TypeTagU32 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(9 /* U32 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU32();
-  }
-};
-var TypeTagU64 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* U64 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU64();
-  }
-};
-var TypeTagU128 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* U128 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU128();
-  }
-};
-var TypeTagU256 = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(10 /* U256 */);
-  }
-  static load(_deserializer) {
-    return new TypeTagU256();
-  }
-};
-var TypeTagAddress = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* Address */);
-  }
-  static load(_deserializer) {
-    return new TypeTagAddress();
-  }
-};
-var TypeTagSigner = class extends TypeTag {
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(5 /* Signer */);
-  }
-  static load(_deserializer) {
-    return new TypeTagSigner();
-  }
-};
-var TypeTagVector = class extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(6 /* Vector */);
-    this.value.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = TypeTag.deserialize(deserializer);
-    return new TypeTagVector(value);
-  }
-};
-var TypeTagStruct = class extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(7 /* Struct */);
-    this.value.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = StructTag.deserialize(deserializer);
-    return new TypeTagStruct(value);
-  }
-  isStringTypeTag() {
-    return this.value.module_name.identifier === "string" && this.value.name.identifier === "String" && this.value.address.toString() === AccountAddress.ONE.toString();
-  }
-};
-var StructTag = class extends Serializable {
-  constructor(address, module_name, name, type_args) {
-    super();
-    this.address = address;
-    this.module_name = module_name;
-    this.name = name;
-    this.type_args = type_args;
-  }
-  static fromString(structTag) {
-    const typeTagStruct = new TypeTagParser(structTag).parseTypeTag();
-    return new StructTag(
-      typeTagStruct.value.address,
-      typeTagStruct.value.module_name,
-      typeTagStruct.value.name,
-      typeTagStruct.value.type_args
-    );
-  }
-  serialize(serializer) {
-    serializer.serialize(this.address);
-    serializer.serialize(this.module_name);
-    serializer.serialize(this.name);
-    serializer.serializeVector(this.type_args);
-  }
-  static deserialize(deserializer) {
-    const address = AccountAddress.deserialize(deserializer);
-    const moduleName = Identifier.deserialize(deserializer);
-    const name = Identifier.deserialize(deserializer);
-    const typeArgs = deserializer.deserializeVector(TypeTag);
-    return new StructTag(address, moduleName, name, typeArgs);
-  }
-};
-var stringStructTag = () => new StructTag(AccountAddress.ONE, new Identifier("string"), new Identifier("String"), []);
-function optionStructTag(typeArg) {
-  return new StructTag(AccountAddress.ONE, new Identifier("option"), new Identifier("Option"), [typeArg]);
-}
-function objectStructTag(typeArg) {
-  return new StructTag(AccountAddress.ONE, new Identifier("object"), new Identifier("Object"), [typeArg]);
-}
-var TypeTagParser = class {
-  constructor(tagStr, typeTags) {
-    this.typeTags = [];
-    this.tokens = tokenize(tagStr);
-    this.typeTags = typeTags || [];
-  }
-  consume(targetToken) {
-    const token = this.tokens.shift();
-    if (!token || token[1] !== targetToken) {
-      bail("Invalid type tag.");
-    }
-  }
-  consumeWholeGeneric() {
-    this.consume("<");
-    while (this.tokens[0][1] !== ">") {
-      if (this.tokens[0][1] === "<") {
-        this.consumeWholeGeneric();
-      } else {
-        this.tokens.shift();
-      }
-    }
-    this.consume(">");
-  }
-  parseCommaList(endToken, allowTrailingComma) {
-    const res = [];
-    if (this.tokens.length <= 0) {
-      bail("Invalid type tag.");
-    }
-    while (this.tokens[0][1] !== endToken) {
-      res.push(this.parseTypeTag());
-      if (this.tokens.length > 0 && this.tokens[0][1] === endToken) {
-        break;
-      }
-      this.consume(",");
-      if (this.tokens.length > 0 && this.tokens[0][1] === endToken && allowTrailingComma) {
-        break;
-      }
-      if (this.tokens.length <= 0) {
-        bail("Invalid type tag.");
-      }
-    }
-    return res;
-  }
-  parseTypeTag() {
-    if (this.tokens.length === 0) {
-      bail("Invalid type tag.");
-    }
-    const [tokenTy, tokenVal] = this.tokens.shift();
-    if (tokenVal === "u8") {
-      return new TypeTagU8();
-    }
-    if (tokenVal === "u16") {
-      return new TypeTagU16();
-    }
-    if (tokenVal === "u32") {
-      return new TypeTagU32();
-    }
-    if (tokenVal === "u64") {
-      return new TypeTagU64();
-    }
-    if (tokenVal === "u128") {
-      return new TypeTagU128();
-    }
-    if (tokenVal === "u256") {
-      return new TypeTagU256();
-    }
-    if (tokenVal === "bool") {
-      return new TypeTagBool();
-    }
-    if (tokenVal === "address") {
-      return new TypeTagAddress();
-    }
-    if (tokenVal === "vector") {
-      this.consume("<");
-      const res = this.parseTypeTag();
-      this.consume(">");
-      return new TypeTagVector(res);
-    }
-    if (tokenVal === "string") {
-      return new TypeTagStruct(stringStructTag());
-    }
-    if (tokenTy === "IDENT" && (tokenVal.startsWith("0x") || tokenVal.startsWith("0X"))) {
-      const address = AccountAddress.fromHexInput(tokenVal);
-      this.consume("::");
-      const [moduleTokenTy, module] = this.tokens.shift();
-      if (moduleTokenTy !== "IDENT") {
-        bail("Invalid type tag.");
-      }
-      this.consume("::");
-      const [nameTokenTy, name] = this.tokens.shift();
-      if (nameTokenTy !== "IDENT") {
-        bail("Invalid type tag.");
-      }
-      if (AccountAddress.ONE.toString() === address.toString() && module === "object" && name === "Object") {
-        this.consumeWholeGeneric();
-        return new TypeTagAddress();
-      }
-      let tyTags = [];
-      if (this.tokens.length > 0 && this.tokens[0][1] === "<") {
-        this.consume("<");
-        tyTags = this.parseCommaList(">", true);
-        this.consume(">");
-      }
-      const structTag = new StructTag(address, new Identifier(module), new Identifier(name), tyTags);
-      return new TypeTagStruct(structTag);
-    }
-    if (tokenTy === "GENERIC") {
-      if (this.typeTags.length === 0) {
-        bail("Can't convert generic type since no typeTags were specified.");
-      }
-      const idx = parseInt(tokenVal.substring(1), 10);
-      return new TypeTagParser(this.typeTags[idx]).parseTypeTag();
-    }
-    throw new Error("Invalid type tag.");
-  }
-};
-var TypeTagParserError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TypeTagParserError";
-  }
-};
-function tokenize(tagStr) {
-  let pos = 0;
-  const tokens = [];
-  while (pos < tagStr.length) {
-    const [token, size] = nextToken(tagStr, pos);
-    if (token[0] !== "SPACE") {
-      tokens.push(token);
-    }
-    pos += size;
-  }
-  return tokens;
-}
-function bail(message) {
-  throw new TypeTagParserError(message);
-}
-function isWhiteSpace(c) {
-  return !!c.match(/\s/);
-}
-function isValidAlphabetic(c) {
-  return !!c.match(/[_A-Za-z0-9]/g);
-}
-function isGeneric(c) {
-  return !!c.match(/T\d+/g);
-}
-function nextToken(tagStr, pos) {
-  const c = tagStr[pos];
-  if (c === ":") {
-    if (tagStr.slice(pos, pos + 2) === "::") {
-      return [["COLON", "::"], 2];
-    }
-    bail("Unrecognized token.");
-  } else if (c === "<") {
-    return [["LT", "<"], 1];
-  } else if (c === ">") {
-    return [["GT", ">"], 1];
-  } else if (c === ",") {
-    return [["COMMA", ","], 1];
-  } else if (isWhiteSpace(c)) {
-    let res = "";
-    for (let i = pos; i < tagStr.length; i += 1) {
-      const char = tagStr[i];
-      if (isWhiteSpace(char)) {
-        res = `${res}${char}`;
-      } else {
-        break;
-      }
-    }
-    return [["SPACE", res], res.length];
-  } else if (isValidAlphabetic(c)) {
-    let res = "";
-    for (let i = pos; i < tagStr.length; i += 1) {
-      const char = tagStr[i];
-      if (isValidAlphabetic(char)) {
-        res = `${res}${char}`;
-      } else {
-        break;
-      }
-    }
-    if (isGeneric(res)) {
-      return [["GENERIC", res], res.length];
-    }
-    return [["IDENT", res], res.length];
-  }
-  throw new Error("Unrecognized token.");
-}
-
-// src/transactions/transaction_builder/transaction_builder.ts
-import { sha3_256 as sha3Hash2 } from "@noble/hashes/sha3";
-
-// src/utils/helpers.ts
-async function sleep(timeMs) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeMs);
-  });
-}
-
-// src/internal/transaction.ts
-async function getTransactions2(args) {
-  const { aptosConfig, options } = args;
-  return paginateWithCursor({
-    aptosConfig,
-    originMethod: "getTransactions",
-    path: "transactions",
-    params: { start: options == null ? void 0 : options.offset, limit: options == null ? void 0 : options.limit }
-  });
-}
-async function getGasPriceEstimation(args) {
-  const { aptosConfig } = args;
-  return memoizeAsync(
-    async () => {
-      const { data } = await getAptosFullNode({
-        aptosConfig,
-        originMethod: "getGasPriceEstimation",
-        path: "estimate_gas_price"
-      });
-      return data;
-    },
-    `gas-price-${aptosConfig.network}`,
-    1e3 * 60 * 5
-  )();
-}
-async function getTransactionByVersion(args) {
-  const { aptosConfig, ledgerVersion } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getTransactionByVersion",
-    path: `transactions/by_version/${ledgerVersion}`
-  });
-  return data;
-}
-async function getTransactionByHash(args) {
-  const { aptosConfig, transactionHash } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    path: `transactions/by_hash/${transactionHash}`,
-    originMethod: "getTransactionByHash"
-  });
-  return data;
-}
-async function isTransactionPending(args) {
-  const { aptosConfig, transactionHash } = args;
-  try {
-    const transaction = await getTransactionByHash({ aptosConfig, transactionHash });
-    return transaction.type === "pending_transaction" /* Pending */;
-  } catch (e) {
-    if ((e == null ? void 0 : e.status) === 404) {
-      return true;
-    }
-    throw e;
+
+// src/utils/helpers.ts
+async function sleep(timeMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeMs);
+  });
+}
+
+// src/internal/transaction.ts
+async function getTransactions2(args) {
+  const { aptosConfig, options } = args;
+  return paginateWithCursor({
+    aptosConfig,
+    originMethod: "getTransactions",
+    path: "transactions",
+    params: { start: options == null ? void 0 : options.offset, limit: options == null ? void 0 : options.limit }
+  });
+}
+async function getGasPriceEstimation(args) {
+  const { aptosConfig } = args;
+  return memoizeAsync(
+    async () => {
+      const { data } = await getAptosFullNode({
+        aptosConfig,
+        originMethod: "getGasPriceEstimation",
+        path: "estimate_gas_price"
+      });
+      return data;
+    },
+    `gas-price-${aptosConfig.network}`,
+    1e3 * 60 * 5
+  )();
+}
+async function getTransactionByVersion(args) {
+  const { aptosConfig, ledgerVersion } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    originMethod: "getTransactionByVersion",
+    path: `transactions/by_version/${ledgerVersion}`
+  });
+  return data;
+}
+async function getTransactionByHash(args) {
+  const { aptosConfig, transactionHash } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    path: `transactions/by_hash/${transactionHash}`,
+    originMethod: "getTransactionByHash"
+  });
+  return data;
+}
+async function isTransactionPending(args) {
+  const { aptosConfig, transactionHash } = args;
+  try {
+    const transaction = await getTransactionByHash({ aptosConfig, transactionHash });
+    return transaction.type === "pending_transaction" /* Pending */;
+  } catch (e) {
+    if ((e == null ? void 0 : e.status) === 404) {
+      return true;
+    }
+    throw e;
   }
 }
 async function waitForTransaction(args) {
@@ -3126,8 +2988,10 @@ var AccountAuthenticator = class extends Serializable {
         return AccountAuthenticatorEd25519.load(deserializer);
       case 1 /* MultiEd25519 */:
         return AccountAuthenticatorMultiEd25519.load(deserializer);
-      case 2 /* Secp256k1 */:
-        return AccountAuthenticatorSecp256k1.load(deserializer);
+      case 2 /* SingleKey */:
+        return AccountAuthenticatorSingleKey.load(deserializer);
+      case 3 /* MultiKey */:
+        return AccountAuthenticatorMultiKey.load(deserializer);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -3167,26 +3031,46 @@ var AccountAuthenticatorMultiEd25519 = class extends AccountAuthenticator {
     return new AccountAuthenticatorMultiEd25519(public_key, signature);
   }
 };
-var AccountAuthenticatorSecp256k1 = class extends AccountAuthenticator {
+var AccountAuthenticatorSingleKey = class extends AccountAuthenticator {
   constructor(public_key, signature) {
     super();
     this.public_key = public_key;
     this.signature = signature;
   }
   serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* Secp256k1 */);
+    serializer.serializeU32AsUleb128(2 /* SingleKey */);
     this.public_key.serialize(serializer);
     this.signature.serialize(serializer);
   }
   static load(deserializer) {
-    const public_key = Secp256k1PublicKey.deserialize(deserializer);
-    const signature = Secp256k1Signature.deserialize(deserializer);
-    return new AccountAuthenticatorSecp256k1(public_key, signature);
+    const public_key = AnyPublicKey.deserialize(deserializer);
+    const signature = AnySignature.deserialize(deserializer);
+    return new AccountAuthenticatorSingleKey(public_key, signature);
+  }
+};
+var AccountAuthenticatorMultiKey = class extends AccountAuthenticator {
+  constructor(public_keys, signatures, signatures_bitmap) {
+    super();
+    this.public_keys = public_keys;
+    this.signatures = signatures;
+    this.signatures_bitmap = signatures_bitmap;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(3 /* MultiKey */);
+    this.public_keys.serialize(serializer);
+    serializer.serializeVector(this.signatures);
+    serializer.serializeBytes(this.signatures_bitmap);
+  }
+  static load(deserializer) {
+    const public_keys = MultiKey.deserialize(deserializer);
+    const signatures = deserializer.deserializeVector(AnySignature);
+    const signatures_bitmap = deserializer.deserializeBytes();
+    return new AccountAuthenticatorMultiKey(public_keys, signatures, signatures_bitmap);
   }
 };
 
 // src/transactions/authenticator/transaction.ts
-var TransactionAuthenticator = class {
+var TransactionAuthenticator = class extends Serializable {
   static deserialize(deserializer) {
     const index = deserializer.deserializeUleb128AsU32();
     switch (index) {
@@ -3198,8 +3082,8 @@ var TransactionAuthenticator = class {
         return TransactionAuthenticatorMultiAgent.load(deserializer);
       case 3 /* FeePayer */:
         return TransactionAuthenticatorFeePayer.load(deserializer);
-      case 4 /* Secp256k1Ecdsa */:
-        return TransactionAuthenticatorSecp256k1.load(deserializer);
+      case 4 /* SingleSender */:
+        return TransactionAuthenticatorSingleSender.load(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
     }
@@ -3285,63 +3169,362 @@ var TransactionAuthenticatorFeePayer = class extends TransactionAuthenticator {
     return new TransactionAuthenticatorFeePayer(sender, secondary_signer_addresses, secondary_signers, fee_payer);
   }
 };
-var TransactionAuthenticatorSecp256k1 = class extends TransactionAuthenticator {
-  constructor(public_key, signature) {
+var TransactionAuthenticatorSingleSender = class extends TransactionAuthenticator {
+  constructor(sender) {
+    super();
+    this.sender = sender;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(4 /* SingleSender */);
+    this.sender.serialize(serializer);
+  }
+  static load(deserializer) {
+    const sender = AccountAuthenticator.deserialize(deserializer);
+    return new TransactionAuthenticatorSingleSender(sender);
+  }
+};
+
+// src/transactions/instances/chainId.ts
+var ChainId = class extends Serializable {
+  constructor(chainId) {
+    super();
+    this.chainId = chainId;
+  }
+  serialize(serializer) {
+    serializer.serializeU8(this.chainId);
+  }
+  static deserialize(deserializer) {
+    const chainId = deserializer.deserializeU8();
+    return new ChainId(chainId);
+  }
+};
+
+// src/transactions/instances/identifier.ts
+var Identifier = class extends Serializable {
+  constructor(identifier) {
+    super();
+    this.identifier = identifier;
+  }
+  serialize(serializer) {
+    serializer.serializeStr(this.identifier);
+  }
+  static deserialize(deserializer) {
+    const identifier = deserializer.deserializeStr();
+    return new Identifier(identifier);
+  }
+};
+
+// src/transactions/instances/moduleId.ts
+var ModuleId = class extends Serializable {
+  constructor(address, name) {
+    super();
+    this.address = address;
+    this.name = name;
+  }
+  static fromStr(moduleId) {
+    const parts = moduleId.split("::");
+    if (parts.length !== 2) {
+      throw new Error("Invalid module id.");
+    }
+    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
+  }
+  serialize(serializer) {
+    this.address.serialize(serializer);
+    this.name.serialize(serializer);
+  }
+  static deserialize(deserializer) {
+    const address = AccountAddress.deserialize(deserializer);
+    const name = Identifier.deserialize(deserializer);
+    return new ModuleId(address, name);
+  }
+};
+
+// src/transactions/typeTag/index.ts
+var TypeTag = class extends Serializable {
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case 0 /* Bool */:
+        return TypeTagBool.load(deserializer);
+      case 1 /* U8 */:
+        return TypeTagU8.load(deserializer);
+      case 2 /* U64 */:
+        return TypeTagU64.load(deserializer);
+      case 3 /* U128 */:
+        return TypeTagU128.load(deserializer);
+      case 4 /* Address */:
+        return TypeTagAddress.load(deserializer);
+      case 5 /* Signer */:
+        return TypeTagSigner.load(deserializer);
+      case 6 /* Vector */:
+        return TypeTagVector.load(deserializer);
+      case 7 /* Struct */:
+        return TypeTagStruct.load(deserializer);
+      case 8 /* U16 */:
+        return TypeTagU16.load(deserializer);
+      case 9 /* U32 */:
+        return TypeTagU32.load(deserializer);
+      case 10 /* U256 */:
+        return TypeTagU256.load(deserializer);
+      case 255 /* Generic */:
+        return TypeTagGeneric.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for TypeTag: ${index}`);
+    }
+  }
+  isBool() {
+    return this instanceof TypeTagBool;
+  }
+  isAddress() {
+    return this instanceof TypeTagAddress;
+  }
+  isGeneric() {
+    return this instanceof TypeTagGeneric;
+  }
+  isSigner() {
+    return this instanceof TypeTagSigner;
+  }
+  isVector() {
+    return this instanceof TypeTagVector;
+  }
+  isStruct() {
+    return this instanceof TypeTagStruct;
+  }
+  isU8() {
+    return this instanceof TypeTagU8;
+  }
+  isU16() {
+    return this instanceof TypeTagU16;
+  }
+  isU32() {
+    return this instanceof TypeTagU32;
+  }
+  isU64() {
+    return this instanceof TypeTagU64;
+  }
+  isU128() {
+    return this instanceof TypeTagU128;
+  }
+  isU256() {
+    return this instanceof TypeTagU256;
+  }
+};
+var TypeTagBool = class extends TypeTag {
+  toString() {
+    return "bool";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(0 /* Bool */);
+  }
+  static load(_deserializer) {
+    return new TypeTagBool();
+  }
+};
+var TypeTagU8 = class extends TypeTag {
+  toString() {
+    return "u8";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(1 /* U8 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU8();
+  }
+};
+var TypeTagU16 = class extends TypeTag {
+  toString() {
+    return "u16";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(8 /* U16 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU16();
+  }
+};
+var TypeTagU32 = class extends TypeTag {
+  toString() {
+    return "u32";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(9 /* U32 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU32();
+  }
+};
+var TypeTagU64 = class extends TypeTag {
+  toString() {
+    return "u64";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(2 /* U64 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU64();
+  }
+};
+var TypeTagU128 = class extends TypeTag {
+  toString() {
+    return "u128";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(3 /* U128 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU128();
+  }
+};
+var TypeTagU256 = class extends TypeTag {
+  toString() {
+    return "u256";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(10 /* U256 */);
+  }
+  static load(_deserializer) {
+    return new TypeTagU256();
+  }
+};
+var TypeTagAddress = class extends TypeTag {
+  toString() {
+    return "address";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(4 /* Address */);
+  }
+  static load(_deserializer) {
+    return new TypeTagAddress();
+  }
+};
+var TypeTagSigner = class extends TypeTag {
+  toString() {
+    return "signer";
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(5 /* Signer */);
+  }
+  static load(_deserializer) {
+    return new TypeTagSigner();
+  }
+};
+var TypeTagReference = class extends TypeTag {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  toString() {
+    return `&${this.value.toString()}`;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(254 /* Reference */);
+  }
+  static load(deserializer) {
+    const value = TypeTag.deserialize(deserializer);
+    return new TypeTagReference(value);
+  }
+};
+var TypeTagGeneric = class extends TypeTag {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  toString() {
+    return `T${this.value}`;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(255 /* Generic */);
+    serializer.serializeU32(this.value);
+  }
+  static load(deserializer) {
+    const value = deserializer.deserializeU32();
+    return new TypeTagGeneric(value);
+  }
+};
+var TypeTagVector = class extends TypeTag {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  toString() {
+    return `vector<${this.value.toString()}>`;
+  }
+  serialize(serializer) {
+    serializer.serializeU32AsUleb128(6 /* Vector */);
+    this.value.serialize(serializer);
+  }
+  static load(deserializer) {
+    const value = TypeTag.deserialize(deserializer);
+    return new TypeTagVector(value);
+  }
+};
+var TypeTagStruct = class extends TypeTag {
+  constructor(value) {
     super();
-    this.public_key = public_key;
-    this.signature = signature;
+    this.value = value;
+  }
+  toString() {
+    let typePredicate = "";
+    if (this.value.type_args.length > 0) {
+      typePredicate = `<${this.value.type_args.map((typeArg) => typeArg.toString()).join(", ")}>`;
+    }
+    return `${this.value.address.toString()}::${this.value.module_name.identifier}::${this.value.name.identifier}${typePredicate}`;
   }
   serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* Secp256k1Ecdsa */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
+    serializer.serializeU32AsUleb128(7 /* Struct */);
+    this.value.serialize(serializer);
   }
   static load(deserializer) {
-    const public_key = Secp256k1PublicKey.deserialize(deserializer);
-    const signature = Secp256k1Signature.deserialize(deserializer);
-    return new TransactionAuthenticatorSecp256k1(public_key, signature);
+    const value = StructTag.deserialize(deserializer);
+    return new TypeTagStruct(value);
   }
-};
-
-// src/transactions/instances/chainId.ts
-var ChainId = class extends Serializable {
-  constructor(chainId) {
-    super();
-    this.chainId = chainId;
+  isTypeTag(address, moduleName, structName) {
+    return this.value.module_name.identifier === moduleName && this.value.name.identifier === structName && this.value.address.equals(address);
   }
-  serialize(serializer) {
-    serializer.serializeU8(this.chainId);
+  isString() {
+    return this.isTypeTag(AccountAddress.ONE, "string", "String");
   }
-  static deserialize(deserializer) {
-    const chainId = deserializer.deserializeU8();
-    return new ChainId(chainId);
+  isOption() {
+    return this.isTypeTag(AccountAddress.ONE, "option", "Option");
+  }
+  isObject() {
+    return this.isTypeTag(AccountAddress.ONE, "object", "Object");
   }
 };
-
-// src/transactions/instances/moduleId.ts
-var ModuleId = class extends Serializable {
-  constructor(address, name) {
+var StructTag = class extends Serializable {
+  constructor(address, module_name, name, type_args) {
     super();
     this.address = address;
+    this.module_name = module_name;
     this.name = name;
-  }
-  static fromStr(moduleId) {
-    const parts = moduleId.split("::");
-    if (parts.length !== 2) {
-      throw new Error("Invalid module id.");
-    }
-    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
+    this.type_args = type_args;
   }
   serialize(serializer) {
-    this.address.serialize(serializer);
-    this.name.serialize(serializer);
+    serializer.serialize(this.address);
+    serializer.serialize(this.module_name);
+    serializer.serialize(this.name);
+    serializer.serializeVector(this.type_args);
   }
   static deserialize(deserializer) {
     const address = AccountAddress.deserialize(deserializer);
+    const moduleName = Identifier.deserialize(deserializer);
     const name = Identifier.deserialize(deserializer);
-    return new ModuleId(address, name);
+    const typeArgs = deserializer.deserializeVector(TypeTag);
+    return new StructTag(address, moduleName, name, typeArgs);
   }
 };
+function aptosCoinStructTag() {
+  return new StructTag(AccountAddress.ONE, new Identifier("aptos_coin"), new Identifier("AptosCoin"), []);
+}
+function stringStructTag() {
+  return new StructTag(AccountAddress.ONE, new Identifier("string"), new Identifier("String"), []);
+}
+function optionStructTag(typeArg) {
+  return new StructTag(AccountAddress.ONE, new Identifier("option"), new Identifier("Option"), [typeArg]);
+}
+function objectStructTag(typeArg) {
+  return new StructTag(AccountAddress.ONE, new Identifier("object"), new Identifier("Object"), [typeArg]);
+}
 
 // src/transactions/instances/transactionPayload.ts
 function deserializeFromScriptArgument(deserializer) {
@@ -3504,12 +3687,12 @@ var MultiSig = class {
     const payloadPresent = deserializer.deserializeBool();
     let transaction_payload;
     if (payloadPresent) {
-      transaction_payload = MultiSigTransactionPayload.deserialize(deserializer);
+      transaction_payload = MultisigTransactionPayload.deserialize(deserializer);
     }
     return new MultiSig(multisig_address, transaction_payload);
   }
 };
-var MultiSigTransactionPayload = class {
+var MultisigTransactionPayload = class {
   constructor(transaction_payload) {
     this.transaction_payload = transaction_payload;
   }
@@ -3519,7 +3702,7 @@ var MultiSigTransactionPayload = class {
   }
   static deserialize(deserializer) {
     deserializer.deserializeUleb128AsU32();
-    return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
+    return new MultisigTransactionPayload(EntryFunction.deserialize(deserializer));
   }
 };
 
@@ -3632,38 +3815,535 @@ var SignedTransaction = class extends Serializable {
   }
 };
 
-// src/transactions/transaction_builder/transaction_builder.ts
-function generateTransactionPayload(args) {
-  var _a, _b, _c;
-  if ("bytecode" in args) {
-    return new TransactionPayloadScript(
-      new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), (_a = args.typeArguments) != null ? _a : [], args.arguments)
+// src/transactions/typeTag/parser.ts
+function isValidIdentifier(str) {
+  return !!str.match(/^[_a-zA-Z0-9]+$/);
+}
+function isValidWhitespaceCharacter(char) {
+  return !!char.match(/\s/);
+}
+function consumeWhitespace(tagStr, pos) {
+  let i = pos;
+  for (; i < tagStr.length; i += 1) {
+    const innerChar = tagStr[i];
+    if (!isValidWhitespaceCharacter(innerChar)) {
+      break;
+    }
+  }
+  return i;
+}
+var TypeTagParserErrorType = /* @__PURE__ */ ((TypeTagParserErrorType2) => {
+  TypeTagParserErrorType2["InvalidTypeTag"] = "unknown type";
+  TypeTagParserErrorType2["UnexpectedTypeArgumentClose"] = "unexpected '>'";
+  TypeTagParserErrorType2["UnexpectedWhitespaceCharacter"] = "unexpected whitespace character";
+  TypeTagParserErrorType2["UnexpectedComma"] = "unexpected ','";
+  TypeTagParserErrorType2["TypeArgumentCountMismatch"] = "type argument count doesn't match expected amount";
+  TypeTagParserErrorType2["MissingTypeArgumentClose"] = "no matching '>' for '<'";
+  TypeTagParserErrorType2["UnexpectedPrimitiveTypeArguments"] = "primitive types not expected to have type arguments";
+  TypeTagParserErrorType2["UnexpectedVectorTypeArgumentCount"] = "vector type expected to have exactly one type argument";
+  TypeTagParserErrorType2["UnexpectedStructFormat"] = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name";
+  TypeTagParserErrorType2["InvalidModuleNameCharacter"] = "module name must only contain alphanumeric or '_' characters";
+  TypeTagParserErrorType2["InvalidStructNameCharacter"] = "struct name must only contain alphanumeric or '_' characters";
+  return TypeTagParserErrorType2;
+})(TypeTagParserErrorType || {});
+var TypeTagParserError = class extends Error {
+  constructor(typeTagStr, invalidReason) {
+    super(`Failed to parse typeTag '${typeTagStr}', ${invalidReason}`);
+  }
+};
+function parseTypeTag(typeStr, options) {
+  var _a;
+  const allowGenerics = (_a = options == null ? void 0 : options.allowGenerics) != null ? _a : false;
+  const saved = [];
+  let innerTypes = [];
+  let curTypes = [];
+  let cur = 0;
+  let currentStr = "";
+  let expectedTypes = 1;
+  while (cur < typeStr.length) {
+    const char = typeStr[cur];
+    if (char === "<") {
+      saved.push({
+        savedExpectedTypes: expectedTypes,
+        savedStr: currentStr,
+        savedTypes: curTypes
+      });
+      currentStr = "";
+      curTypes = [];
+      expectedTypes = 1;
+    } else if (char === ">") {
+      if (currentStr !== "") {
+        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
+        curTypes.push(newType);
+      }
+      const savedPop = saved.pop();
+      if (savedPop === void 0) {
+        throw new TypeTagParserError(typeStr, "unexpected '>'" /* UnexpectedTypeArgumentClose */);
+      }
+      if (expectedTypes !== curTypes.length) {
+        throw new TypeTagParserError(typeStr, "type argument count doesn't match expected amount" /* TypeArgumentCountMismatch */);
+      }
+      const { savedStr, savedTypes, savedExpectedTypes } = savedPop;
+      innerTypes = curTypes;
+      curTypes = savedTypes;
+      currentStr = savedStr;
+      expectedTypes = savedExpectedTypes;
+    } else if (char === ",") {
+      if (currentStr.length !== 0) {
+        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
+        innerTypes = [];
+        curTypes.push(newType);
+        currentStr = "";
+        expectedTypes += 1;
+      }
+    } else if (isValidWhitespaceCharacter(char)) {
+      let parsedTypeTag = false;
+      if (currentStr.length !== 0) {
+        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
+        innerTypes = [];
+        curTypes.push(newType);
+        currentStr = "";
+        parsedTypeTag = true;
+      }
+      cur = consumeWhitespace(typeStr, cur);
+      const nextChar = typeStr[cur];
+      if (cur < typeStr.length && parsedTypeTag && nextChar !== "," && nextChar !== ">") {
+        throw new TypeTagParserError(typeStr, "unexpected whitespace character" /* UnexpectedWhitespaceCharacter */);
+      }
+      continue;
+    } else {
+      currentStr += char;
+    }
+    cur += 1;
+  }
+  if (saved.length > 0) {
+    throw new TypeTagParserError(typeStr, "no matching '>' for '<'" /* MissingTypeArgumentClose */);
+  }
+  switch (curTypes.length) {
+    case 0:
+      return parseTypeTagInner(currentStr, innerTypes, allowGenerics);
+    case 1:
+      if (currentStr === "") {
+        return curTypes[0];
+      }
+      throw new TypeTagParserError(typeStr, "unexpected ','" /* UnexpectedComma */);
+    default:
+      throw new TypeTagParserError(typeStr, "unexpected whitespace character" /* UnexpectedWhitespaceCharacter */);
+  }
+}
+function parseTypeTagInner(str, types, allowGenerics) {
+  switch (str) {
+    case "&signer":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagReference(new TypeTagSigner());
+    case "signer":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagSigner();
+    case "bool":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagBool();
+    case "address":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagAddress();
+    case "u8":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU8();
+    case "u16":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU16();
+    case "u32":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU32();
+    case "u64":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU64();
+    case "u128":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU128();
+    case "u256":
+      if (types.length > 0) {
+        throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
+      }
+      return new TypeTagU256();
+    case "vector":
+      if (types.length !== 1) {
+        throw new TypeTagParserError(str, "vector type expected to have exactly one type argument" /* UnexpectedVectorTypeArgumentCount */);
+      }
+      return new TypeTagVector(types[0]);
+    default:
+      if (allowGenerics && str.match(/^T[0-9]+$/)) {
+        return new TypeTagGeneric(Number(str.split("T")[1]));
+      }
+      if (!str.match(/.*:.*/)) {
+        throw new TypeTagParserError(str, "unknown type" /* InvalidTypeTag */);
+      }
+      const structParts = str.split("::");
+      if (structParts.length !== 3) {
+        throw new TypeTagParserError(str, "unexpected struct format, must be of the form 0xaddress::module_name::struct_name" /* UnexpectedStructFormat */);
+      }
+      if (!isValidIdentifier(structParts[1])) {
+        throw new TypeTagParserError(str, "module name must only contain alphanumeric or '_' characters" /* InvalidModuleNameCharacter */);
+      }
+      if (!isValidIdentifier(structParts[2])) {
+        throw new TypeTagParserError(str, "struct name must only contain alphanumeric or '_' characters" /* InvalidStructNameCharacter */);
+      }
+      return new TypeTagStruct(
+        new StructTag(
+          AccountAddress.fromString(structParts[0]),
+          new Identifier(structParts[1]),
+          new Identifier(structParts[2]),
+          types
+        )
+      );
+  }
+}
+
+// src/transactions/transactionBuilder/helpers.ts
+function isBool(arg) {
+  return typeof arg === "boolean";
+}
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+function isLargeNumber(arg) {
+  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
+}
+function isNull(arg) {
+  return arg === null || arg === void 0;
+}
+function isBcsBool(arg) {
+  return arg instanceof Bool;
+}
+function isBcsAddress(arg) {
+  return arg instanceof AccountAddress;
+}
+function isBcsString(arg) {
+  return arg instanceof MoveString;
+}
+function isBcsFixedBytes(arg) {
+  return arg instanceof FixedBytes;
+}
+function isBcsU8(arg) {
+  return arg instanceof U8;
+}
+function isBcsU16(arg) {
+  return arg instanceof U16;
+}
+function isBcsU32(arg) {
+  return arg instanceof U32;
+}
+function isBcsU64(arg) {
+  return arg instanceof U64;
+}
+function isBcsU128(arg) {
+  return arg instanceof U128;
+}
+function isBcsU256(arg) {
+  return arg instanceof U256;
+}
+function isScriptDataInput(arg) {
+  return "bytecode" in arg;
+}
+function throwTypeMismatch(expectedType, position) {
+  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
+}
+function findFirstNonSignerArg(functionAbi) {
+  return functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+}
+function getFunctionParts(functionArg) {
+  const funcNameParts = functionArg.split("::");
+  if (funcNameParts.length !== 3) {
+    throw new Error(`Invalid function ${functionArg}`);
+  }
+  const moduleAddress = funcNameParts[0];
+  const moduleName = funcNameParts[1];
+  const functionName = funcNameParts[2];
+  return { moduleAddress, moduleName, functionName };
+}
+
+// src/transactions/transactionBuilder/remoteAbi.ts
+function standardizeTypeTags(typeArguments) {
+  var _a;
+  return (_a = typeArguments == null ? void 0 : typeArguments.map((typeArg) => {
+    if (isString(typeArg)) {
+      return parseTypeTag(typeArg);
+    }
+    return typeArg;
+  })) != null ? _a : [];
+}
+async function fetchEntryFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig) {
+  var _a;
+  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
+  const functionAbi = (_a = module.abi) == null ? void 0 : _a.exposed_functions.find((func) => func.name === functionName);
+  if (!functionAbi) {
+    throw new Error(`Could not find entry function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+  }
+  if (!functionAbi.is_entry) {
+    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an entry function`);
+  }
+  const first = findFirstNonSignerArg(functionAbi);
+  const params = [];
+  for (let i = first; i < functionAbi.params.length; i += 1) {
+    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
+  }
+  return {
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params
+  };
+}
+function convertArgument(functionName, functionAbi, arg, position, genericTypeParams) {
+  if (position >= functionAbi.parameters.length) {
+    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);
+  }
+  if (isBcsBool(arg) || isBcsU8(arg) || isBcsU16(arg) || isBcsU32(arg) || isBcsU64(arg) || isBcsU128(arg) || isBcsU256(arg) || isBcsAddress(arg) || isBcsString(arg) || isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption) {
+    checkType(functionAbi, arg, position);
+    return arg;
+  }
+  return parseArg(arg, functionAbi.parameters[position], position, genericTypeParams);
+}
+function parseArg(arg, param, position, genericTypeParams) {
+  if (param.isBool()) {
+    if (isBool(arg)) {
+      return new Bool(arg);
+    }
+    throwTypeMismatch("boolean", position);
+  }
+  if (param.isAddress()) {
+    if (isString(arg)) {
+      return AccountAddress.fromString(arg);
+    }
+    throwTypeMismatch("string", position);
+  }
+  if (param.isU8()) {
+    if (isNumber(arg)) {
+      return new U8(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU16()) {
+    if (isNumber(arg)) {
+      return new U16(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU32()) {
+    if (isNumber(arg)) {
+      return new U32(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU64()) {
+    if (isLargeNumber(arg)) {
+      return new U64(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isU128()) {
+    if (isLargeNumber(arg)) {
+      return new U128(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isU256()) {
+    if (isLargeNumber(arg)) {
+      return new U256(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isGeneric()) {
+    const genericIndex = param.value;
+    if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {
+      throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);
+    }
+    parseArg(arg, genericTypeParams[genericIndex], position, genericTypeParams);
+  }
+  if (param.isVector()) {
+    if (param.value.isU8() && isString(arg)) {
+      return MoveVector.U8(Hex.fromHexInput(arg).toUint8Array());
+    }
+    if (Array.isArray(arg)) {
+      return new MoveVector(arg.map((item) => parseArg(item, param.value, position, genericTypeParams)));
+    }
+    throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
+  }
+  if (param.isStruct()) {
+    if (param.isString()) {
+      if (isString(arg)) {
+        return new MoveString(arg);
+      }
+      throwTypeMismatch("string", position);
+    }
+    if (param.isObject()) {
+      if (isString(arg)) {
+        return AccountAddress.fromString(arg);
+      }
+      throwTypeMismatch("string", position);
+    }
+    if (param.isOption()) {
+      if (isNull(arg)) {
+        return new MoveOption(null);
+      }
+      return new MoveOption(parseArg(arg, param.value.type_args[0], position, genericTypeParams));
+    }
+    throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);
+  }
+  throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
+}
+function checkType(functionAbi, arg, position) {
+  const param = functionAbi.parameters[position];
+  if (param.isBool()) {
+    if (isBcsBool(arg)) {
+      return;
+    }
+    throwTypeMismatch("Bool", position);
+  }
+  if (param.isAddress()) {
+    if (isBcsAddress(arg)) {
+      return;
+    }
+    throwTypeMismatch("AccountAddress", position);
+  }
+  if (param.isU8()) {
+    if (isBcsU8(arg)) {
+      return;
+    }
+    throwTypeMismatch("U8", position);
+  }
+  if (param.isU16()) {
+    if (isBcsU16(arg)) {
+      return;
+    }
+    throwTypeMismatch("U16", position);
+  }
+  if (param.isU32()) {
+    if (isBcsU32(arg)) {
+      return;
+    }
+    throwTypeMismatch("U32", position);
+  }
+  if (param.isU64()) {
+    if (isBcsU64(arg)) {
+      return;
+    }
+    throwTypeMismatch("U64", position);
+  }
+  if (param.isU128()) {
+    if (isBcsU128(arg)) {
+      return;
+    }
+    throwTypeMismatch("U128", position);
+  }
+  if (param.isU256()) {
+    if (isBcsU256(arg)) {
+      return;
+    }
+    throwTypeMismatch("U256", position);
+  }
+  if (param.isVector()) {
+    if (arg instanceof MoveVector) {
+      return;
+    }
+    throwTypeMismatch("MoveVector", position);
+  }
+  if (param instanceof TypeTagStruct) {
+    if (param.isString()) {
+      if (isBcsString(arg)) {
+        return;
+      }
+      throwTypeMismatch("MoveString", position);
+    }
+    if (param.isObject()) {
+      if (isBcsAddress(arg)) {
+        return;
+      }
+      throwTypeMismatch("AccountAddress", position);
+    }
+    if (param.isOption()) {
+      if (arg instanceof MoveOption) {
+        return;
+      }
+      throwTypeMismatch("MoveOption", position);
+    }
+  }
+  throw new Error(`Type mismatch for argument ${position}, expected '${param.toString()}'`);
+}
+
+// src/transactions/transactionBuilder/transactionBuilder.ts
+async function generateTransactionPayload(args) {
+  if (isScriptDataInput(args)) {
+    return generateTransactionPayloadScript(args);
+  }
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
+  const functionAbi = await memoizeAsync(
+    async () => fetchEntryFunctionAbi(moduleAddress, moduleName, functionName, args.aptosConfig),
+    `entry-function-${args.aptosConfig.network}-${moduleAddress}-${moduleName}-${functionName}`,
+    1e3 * 60 * 5
+  )();
+  return generateTransactionPayloadWithABI(args, functionAbi);
+}
+function generateTransactionPayloadWithABI(args, functionAbi) {
+  if (isScriptDataInput(args)) {
+    return generateTransactionPayloadScript(args);
+  }
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
+  const typeArguments = standardizeTypeTags(args.typeArguments);
+  if (typeArguments.length !== functionAbi.typeParameters.length) {
+    throw new Error(
+      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
+    );
+  }
+  const functionArguments = args.functionArguments.map(
+    (arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments)
+  );
+  if (functionArguments.length !== functionAbi.parameters.length) {
+    throw new Error(
+      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`
     );
   }
+  const entryFunctionPayload = EntryFunction.build(
+    `${moduleAddress}::${moduleName}`,
+    functionName,
+    typeArguments,
+    functionArguments
+  );
   if ("multisigAddress" in args) {
-    const funcNameParts2 = args.function.split("::");
+    let multisigAddress;
+    if (typeof args.multisigAddress === "string") {
+      multisigAddress = AccountAddress.fromString(args.multisigAddress);
+    } else {
+      multisigAddress = args.multisigAddress;
+    }
     return new TransactionPayloadMultisig(
-      new MultiSig(
-        args.multisigAddress,
-        new MultiSigTransactionPayload(
-          EntryFunction.build(
-            `${funcNameParts2[0]}::${funcNameParts2[1]}`,
-            funcNameParts2[2],
-            (_b = args.typeArguments) != null ? _b : [],
-            args.arguments
-          )
-        )
-      )
+      new MultiSig(multisigAddress, new MultisigTransactionPayload(entryFunctionPayload))
     );
   }
-  const funcNameParts = args.function.split("::");
-  return new TransactionPayloadEntryFunction(
-    EntryFunction.build(
-      `${funcNameParts[0]}::${funcNameParts[1]}`,
-      funcNameParts[2],
-      (_c = args.typeArguments) != null ? _c : [],
-      args.arguments
-    )
+  return new TransactionPayloadEntryFunction(entryFunctionPayload);
+}
+function generateTransactionPayloadScript(args) {
+  var _a;
+  return new TransactionPayloadScript(
+    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), (_a = args.typeArguments) != null ? _a : [], args.functionArguments)
   );
 }
 async function generateRawTransaction(args) {
@@ -3769,26 +4449,25 @@ function generateSignedTransactionForSimulation(args) {
       accountAuthenticator.public_key,
       accountAuthenticator.signature
     );
-  } else if (accountAuthenticator instanceof AccountAuthenticatorSecp256k1) {
-    transactionAuthenticator = new TransactionAuthenticatorSecp256k1(
-      accountAuthenticator.public_key,
-      accountAuthenticator.signature
-    );
+  } else if (accountAuthenticator instanceof AccountAuthenticatorSingleKey) {
+    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);
   } else {
     throw new Error("Invalid public key");
   }
   return new SignedTransaction(deserializedTransaction, transactionAuthenticator).bcsToBytes();
 }
 function getAuthenticatorForSimulation(publicKey) {
-  if (publicKey instanceof Ed25519PublicKey) {
-    return new AccountAuthenticatorEd25519(
-      new Ed25519PublicKey(publicKey.toUint8Array()),
-      new Ed25519Signature(new Uint8Array(64))
-    );
+  if (publicKey instanceof AnyPublicKey) {
+    if (publicKey.publicKey instanceof Ed25519PublicKey) {
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
+    }
+    if (publicKey.publicKey instanceof Secp256k1PublicKey) {
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
+    }
   }
-  return new AccountAuthenticatorSecp256k1(
-    new Secp256k1PublicKey(publicKey.toUint8Array()),
-    new Secp256k1Signature(new Uint8Array(64))
+  return new AccountAuthenticatorEd25519(
+    new Ed25519PublicKey(publicKey.toUint8Array()),
+    new Ed25519Signature(new Uint8Array(64))
   );
 }
 function sign(args) {
@@ -3802,11 +4481,8 @@ function sign(args) {
         new Ed25519PublicKey(signer.publicKey.toUint8Array()),
         new Ed25519Signature(signerSignature.toUint8Array())
       );
-    case 2 /* Secp256k1Ecdsa */:
-      return new AccountAuthenticatorSecp256k1(
-        new Secp256k1PublicKey(signer.publicKey.toUint8Array()),
-        new Secp256k1Signature(signerSignature.toUint8Array())
-      );
+    case 2 /* SingleKey */:
+      return new AccountAuthenticatorSingleKey(signer.publicKey, new AnySignature(signerSignature));
     default:
       throw new Error(`Cannot sign transaction, signing scheme ${signer.signingScheme} not supported`);
   }
@@ -3821,24 +4497,19 @@ function generateSignedTransaction(args) {
       secondarySignerAuthenticators
     );
   }
-  const deserializer = new Deserializer(senderAuthenticator.bcsToBytes());
-  const accountAuthenticator = AccountAuthenticator.deserialize(deserializer);
-  if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {
+  if (senderAuthenticator instanceof AccountAuthenticatorEd25519) {
     const transactionAuthenticator = new TransactionAuthenticatorEd25519(
-      accountAuthenticator.public_key,
-      accountAuthenticator.signature
+      senderAuthenticator.public_key,
+      senderAuthenticator.signature
     );
     return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
-  if (accountAuthenticator instanceof AccountAuthenticatorSecp256k1) {
-    const transactionAuthenticator = new TransactionAuthenticatorSecp256k1(
-      accountAuthenticator.public_key,
-      accountAuthenticator.signature
-    );
+  if (senderAuthenticator instanceof AccountAuthenticatorSingleKey || senderAuthenticator instanceof AccountAuthenticatorMultiKey) {
+    const transactionAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);
     return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
   throw new Error(
-    `Cannot generate a signed transaction, ${accountAuthenticator} is not a supported account authentication scheme`
+    `Cannot generate a signed transaction, ${senderAuthenticator} is not a supported account authentication scheme`
   );
 }
 function deriveTransactionType(transaction) {
@@ -3914,7 +4585,26 @@ function getSigningMessage(rawTxn) {
 // src/internal/transactionSubmission.ts
 async function generateTransaction(args) {
   const { aptosConfig, sender, data, options, secondarySignerAddresses, feePayerAddress } = args;
-  const payload = await generateTransactionPayload(data);
+  let generateTransactionPayloadData;
+  if ("bytecode" in data) {
+    generateTransactionPayloadData = data;
+  } else if ("multisigAddress" in data) {
+    generateTransactionPayloadData = {
+      aptosConfig,
+      multisigAddress: data.multisigAddress,
+      function: data.function,
+      functionArguments: data.functionArguments,
+      typeArguments: data.typeArguments
+    };
+  } else {
+    generateTransactionPayloadData = {
+      aptosConfig,
+      function: data.function,
+      functionArguments: data.functionArguments,
+      typeArguments: data.typeArguments
+    };
+  }
+  const payload = await generateTransactionPayload(generateTransactionPayloadData);
   return buildTransaction({
     aptosConfig,
     sender,
@@ -3973,14 +4663,15 @@ async function signAndSubmitTransaction(args) {
     senderAuthenticator: authenticator
   });
 }
-async function publishModuleTransaction(args) {
-  const { aptosConfig, account, metadataBytes, byteCode, options } = args;
+async function publicPackageTransaction(args) {
+  const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;
+  const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));
   const transaction = await generateTransaction({
     aptosConfig,
     sender: account,
     data: {
       function: "0x1::code::publish_package_txn",
-      arguments: [MoveVector.U8(metadataBytes), new MoveVector([MoveVector.U8(byteCode)])]
+      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)]
     },
     options
   });
@@ -3996,8 +4687,8 @@ async function transferCoinTransaction(args) {
     sender: sender.accountAddress.toString(),
     data: {
       function: "0x1::aptos_account::transfer_coins",
-      typeArguments: [new TypeTagStruct(StructTag.fromString(coinStructType))],
-      arguments: [AccountAddress.fromHexInput(recipient), new U64(amount)]
+      typeArguments: [parseTypeTag(coinStructType)],
+      functionArguments: [AccountAddress.fromHexInput(recipient), new U64(amount)]
     },
     options
   });
@@ -4022,7 +4713,7 @@ async function mintTokenTransaction(args) {
     sender: creator.accountAddress.toString(),
     data: {
       function: "0x4::aptos_token::mint",
-      arguments: [
+      functionArguments: [
         new MoveString(args.collection),
         new MoveString(args.description),
         new MoveString(args.name),
@@ -4124,7 +4815,7 @@ async function createCollectionTransaction(args) {
     sender: creator.accountAddress.toString(),
     data: {
       function: "0x4::aptos_token::create_collection",
-      arguments: [
+      functionArguments: [
         new MoveString(args.description),
         new U64((_a = args.maxSupply) != null ? _a : MAX_U64_BIG_INT),
         new MoveString(args.name),
@@ -4168,9 +4859,6 @@ async function getCollectionData(args) {
     query: graphqlQuery,
     originMethod: "getCollectionData"
   });
-  if (data.current_collections_v2.length === 0) {
-    throw Error("Collection not found");
-  }
   return data.current_collections_v2[0];
 }
 async function getCollectionId(args) {
@@ -4270,9 +4958,8 @@ var Event = class {
 
 // src/internal/faucet.ts
 async function fundAccount(args) {
-  var _a;
-  const { aptosConfig, accountAddress, amount } = args;
-  const timeoutSecs = (_a = args.timeoutSecs) != null ? _a : DEFAULT_TXN_TIMEOUT_SEC;
+  const { aptosConfig, accountAddress, amount, options } = args;
+  const timeout = (options == null ? void 0 : options.timeoutSecs) || DEFAULT_TXN_TIMEOUT_SEC;
   const { data } = await postAptosFaucet({
     aptosConfig,
     path: "fund",
@@ -4283,7 +4970,15 @@ async function fundAccount(args) {
     originMethod: "fundAccount"
   });
   const txnHash = data.txn_hashes[0];
-  await waitForTransaction({ aptosConfig, transactionHash: txnHash, options: { timeoutSecs } });
+  await waitForTransaction({
+    aptosConfig,
+    transactionHash: txnHash,
+    options: {
+      timeoutSecs: timeout,
+      checkSuccess: options == null ? void 0 : options.checkSuccess,
+      indexerVersionCheck: options == null ? void 0 : options.indexerVersionCheck
+    }
+  });
   return txnHash;
 }
 
@@ -4361,6 +5056,17 @@ var FungibleAsset = class {
   async getFungibleAssetMetadata(args) {
     return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });
   }
+  async getFungibleAssetMetadataByAssetType(assetType) {
+    const data = await getFungibleAssetMetadata({
+      aptosConfig: this.config,
+      options: {
+        where: {
+          asset_type: { _eq: assetType }
+        }
+      }
+    });
+    return data[0];
+  }
   async getFungibleAssetActivities(args) {
     return getFungibleAssetActivities({ aptosConfig: this.config, ...args });
   }
@@ -4535,8 +5241,8 @@ var TransactionSubmission = class {
       transaction
     });
   }
-  async publishModuleTransaction(args) {
-    return publishModuleTransaction({ aptosConfig: this.config, ...args });
+  async publishPackageTransaction(args) {
+    return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
 };
 
@@ -4581,32 +5287,47 @@ export {
   APTOS_PATH_REGEX,
   Account,
   AccountAddress,
+  AccountAuthenticator,
+  AccountAuthenticatorEd25519,
+  AccountAuthenticatorMultiEd25519,
+  AccountAuthenticatorMultiKey,
+  AccountAuthenticatorSingleKey,
   AccountAuthenticatorVariant,
   AddressInvalidReason,
+  AnyPublicKeyVariant,
+  AnySignatureVariant,
   Aptos,
   AptosApiError,
   AptosConfig,
   AuthenticationKey,
   Bool,
+  ChainId,
   DeriveScheme,
   Deserializer,
   Ed25519PrivateKey,
   Ed25519PublicKey,
   Ed25519Signature,
+  EntryFunction,
   EntryFunctionBytes,
+  FeePayerRawTransaction,
   FixedBytes,
   Hex,
   HexInvalidReason,
+  Identifier,
   KeyType,
   MimeType,
+  ModuleId,
   MoveAbility,
   MoveFunctionVisibility,
-  MoveObject,
   MoveOption,
   MoveString,
   MoveVector,
+  MultiAgentRawTransaction,
   MultiEd25519PublicKey,
   MultiEd25519Signature,
+  MultiKey,
+  MultiSig,
+  MultisigTransactionPayload,
   Network,
   NetworkToChainId,
   NetworkToFaucetAPI,
@@ -4615,7 +5336,10 @@ export {
   ParsingError,
   PrivateKey,
   PublicKey,
+  RawTransaction,
+  RawTransactionWithData,
   RoleType,
+  Script,
   ScriptTransactionArgumentVariants,
   Secp256k1PrivateKey,
   Secp256k1PublicKey,
@@ -4623,17 +5347,31 @@ export {
   Serializable,
   Serializer,
   Signature,
+  SignedTransaction,
   SigningScheme,
+  SigningSchemeInput,
   StructTag,
+  TransactionAuthenticator,
+  TransactionAuthenticatorEd25519,
+  TransactionAuthenticatorFeePayer,
+  TransactionAuthenticatorMultiAgent,
+  TransactionAuthenticatorMultiEd25519,
+  TransactionAuthenticatorSingleSender,
   TransactionAuthenticatorVariant,
+  TransactionPayload,
+  TransactionPayloadEntryFunction,
+  TransactionPayloadMultisig,
+  TransactionPayloadScript,
   TransactionPayloadVariants,
   TransactionResponseType,
   TransactionVariants,
   TypeTag,
   TypeTagAddress,
   TypeTagBool,
-  TypeTagParser,
+  TypeTagGeneric,
   TypeTagParserError,
+  TypeTagParserErrorType,
+  TypeTagReference,
   TypeTagSigner,
   TypeTagStruct,
   TypeTagU128,
@@ -4650,22 +5388,58 @@ export {
   U32,
   U64,
   U8,
+  aptosCoinStructTag,
   aptosRequest,
+  buildTransaction,
+  convertArgument,
   derivePrivateKeyFromMnemonic,
+  deriveTransactionType,
+  deserializeFromScriptArgument,
   ensureBoolean,
+  fetchEntryFunctionAbi,
+  findFirstNonSignerArg,
+  generateMultiSignersSignedTransaction,
+  generateRawTransaction,
+  generateSignedTransaction,
+  generateSignedTransactionForSimulation,
+  generateTransactionPayload,
+  generateTransactionPayloadWithABI,
   get,
   getAptosFullNode,
+  getAuthenticatorForSimulation,
+  getFunctionParts,
+  getSigningMessage,
+  isBcsAddress,
+  isBcsBool,
+  isBcsFixedBytes,
+  isBcsString,
+  isBcsU128,
+  isBcsU16,
+  isBcsU256,
+  isBcsU32,
+  isBcsU64,
+  isBcsU8,
+  isBool,
+  isLargeNumber,
+  isNull,
+  isNumber,
+  isScriptDataInput,
+  isString,
   isValidPath,
   objectStructTag,
   optionStructTag,
   outOfRangeErrorMessage,
   paginateWithCursor,
+  parseTypeTag,
   post,
   postAptosFaucet,
   postAptosFullNode,
   postAptosIndexer,
   request,
+  sign,
+  standardizeTypeTags,
   stringStructTag,
+  throwTypeMismatch,
   validateNumberInRange
 };
 //# sourceMappingURL=index.mjs.map