@aptos-labs/ts-sdk 0.0.0 → 0.0.2

package/dist/cjs/index.js

@@ -40,6 +40,8 @@ __export(src_exports, {
   AccountAddress: () => AccountAddress,
   AccountAuthenticatorVariant: () => AccountAuthenticatorVariant,
   AddressInvalidReason: () => AddressInvalidReason,
+  AnyPublicKeyVariant: () => AnyPublicKeyVariant,
+  AnySignatureVariant: () => AnySignatureVariant,
   Aptos: () => Aptos,
   AptosApiError: () => AptosApiError,
   AptosConfig: () => AptosConfig,
@@ -81,6 +83,7 @@ __export(src_exports, {
   Serializer: () => Serializer,
   Signature: () => Signature,
   SigningScheme: () => SigningScheme,
+  SigningSchemeInput: () => SigningSchemeInput,
   StructTag: () => StructTag,
   TransactionAuthenticatorVariant: () => TransactionAuthenticatorVariant,
   TransactionPayloadVariants: () => TransactionPayloadVariants,
@@ -121,14 +124,12 @@ __export(src_exports, {
   postAptosFaucet: () => postAptosFaucet,
   postAptosFullNode: () => postAptosFullNode,
   postAptosIndexer: () => postAptosIndexer,
+  request: () => request,
   stringStructTag: () => stringStructTag,
   validateNumberInRange: () => validateNumberInRange
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/client/core.ts
-var import_aptos_client = __toESM(require("@aptos-labs/aptos-client"));
-
 // src/client/types.ts
 var AptosApiError = class extends Error {
   constructor(request2, response, message) {
@@ -142,6 +143,9 @@ var AptosApiError = class extends Error {
   }
 };
 
+// src/version.ts
+var VERSION = "2.0.0";
+
 // src/types/index.ts
 var MimeType = /* @__PURE__ */ ((MimeType2) => {
   MimeType2["JSON"] = "application/json";
@@ -191,15 +195,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["SingleSenderTransactionAuthenticator"] = 4] = "SingleSenderTransactionAuthenticator";
   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";
@@ -229,9 +244,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";
   return SigningScheme2;
 })(SigningScheme || {});
+var SigningSchemeInput = /* @__PURE__ */ ((SigningSchemeInput2) => {
+  SigningSchemeInput2[SigningSchemeInput2["Ed25519"] = 0] = "Ed25519";
+  SigningSchemeInput2[SigningSchemeInput2["MultiEd25519"] = 1] = "MultiEd25519";
+  SigningSchemeInput2[SigningSchemeInput2["Secp256k1Ecdsa"] = 2] = "Secp256k1Ecdsa";
+  return SigningSchemeInput2;
+})(SigningSchemeInput || {});
 var DeriveScheme = /* @__PURE__ */ ((DeriveScheme2) => {
   DeriveScheme2[DeriveScheme2["DeriveAuid"] = 251] = "DeriveAuid";
   DeriveScheme2[DeriveScheme2["DeriveObjectAddressFromObject"] = 252] = "DeriveObjectAddressFromObject";
@@ -241,9 +262,6 @@ var DeriveScheme = /* @__PURE__ */ ((DeriveScheme2) => {
   return DeriveScheme2;
 })(DeriveScheme || {});
 
-// src/version.ts
-var VERSION = "0.0.0";
-
 // src/client/core.ts
 var errors = {
   400: "Bad Request",
@@ -255,7 +273,8 @@ var errors = {
   502: "Bad Gateway",
   503: "Service Unavailable"
 };
-async function request(url, method, body, contentType, params, overrides) {
+async function request(options, client) {
+  const { url, method, body, contentType, params, overrides } = options;
   const headers = {
     ...overrides == null ? void 0 : overrides.HEADERS,
     "x-aptos-client": `aptos-ts-sdk/${VERSION}`,
@@ -264,7 +283,7 @@ async function request(url, method, body, contentType, params, overrides) {
   if (overrides == null ? void 0 : overrides.TOKEN) {
     headers.Authorization = `Bearer ${overrides == null ? void 0 : overrides.TOKEN}`;
   }
-  return (0, import_aptos_client.default)({
+  return client.provider({
     url,
     method,
     body,
@@ -275,26 +294,28 @@ async function request(url, method, body, contentType, params, overrides) {
 }
 async function aptosRequest(options, aptosConfig) {
   var _a;
-  const { url, path, method, body, contentType, params, overrides } = options;
+  const { url, path } = options;
   const fullUrl = `${url}/${path != null ? path : ""}`;
-  const response = await request(fullUrl, method, body, contentType, params, overrides);
+  const response = await request({ ...options, url: fullUrl }, aptosConfig.client);
   const result = {
     status: response.status,
     statusText: response.statusText,
     data: response.data,
     headers: response.headers,
     config: response.config,
+    request: response.request,
     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;
@@ -362,7 +383,7 @@ async function get(options) {
       acceptType: acceptType == null ? void 0 : acceptType.valueOf(),
       params,
       overrides: {
-        ...aptosConfig,
+        ...aptosConfig.clientConfig,
         ...overrides
       }
     },
@@ -410,7 +431,7 @@ async function post(options) {
       acceptType: acceptType == null ? void 0 : acceptType.valueOf(),
       params,
       overrides: {
-        ...aptosConfig,
+        ...aptosConfig.clientConfig,
         ...overrides
       }
     },
@@ -1298,6 +1319,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;
@@ -1361,6 +1386,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;
@@ -1511,6 +1540,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;
@@ -1558,7 +1591,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;
   }
@@ -1575,10 +1608,66 @@ 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;
+    if (this.isED25519Signature(signature)) {
+      return this.publicKey.verifySignature({ message, signature: signature.signature });
+    } else if (this.isSecp256k1Signature(signature)) {
+      return this.publicKey.verifySignature({ message, signature: signature.signature });
+    } else {
+      throw new Error("Unknown public key type");
+    }
+  }
+  isED25519Signature(signature) {
+    return this.publicKey instanceof Ed25519PublicKey && signature.signature instanceof Ed25519Signature;
+  }
+  isSecp256k1Signature(signature) {
+    return this.publicKey instanceof Secp256k1PublicKey && signature.signature instanceof Secp256k1Signature;
+  }
+  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/authenticationKey.ts
 var _AuthenticationKey = class {
   constructor(args) {
@@ -1595,15 +1684,29 @@ var _AuthenticationKey = class {
   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 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 = import_sha32.sha3_256.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;
@@ -1612,13 +1715,12 @@ 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 {
       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() });
@@ -1676,50 +1778,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);
+  static fromPrivateKey(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;
@@ -2216,7 +2326,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;
@@ -2354,7 +2464,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;
@@ -2366,7 +2476,7 @@ async function lookupOriginalAccountAddress(args) {
   });
   const {
     address_map: { handle }
-  } = resource.data;
+  } = resource;
   try {
     const originalAddress = await getTableItem({
       aptosConfig,
@@ -2572,6 +2682,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.fromPrivateKey({ 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.fromPrivateKey({ 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.fromPrivateKey({ 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 {
@@ -2647,17 +2806,22 @@ var Account2 = class {
       ...args
     });
   }
+  async deriveAccountFromPrivateKey(args) {
+    return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });
+  }
 };
 
 // src/api/aptosConfig.ts
+var import_aptos_client = __toESM(require("@aptos-labs/aptos-client"));
 var AptosConfig = class {
   constructor(settings) {
-    var _a, _b;
+    var _a, _b, _c;
     this.network = (_a = settings == null ? void 0 : settings.network) != null ? _a : DEFAULT_NETWORK;
     this.fullnode = settings == null ? void 0 : settings.fullnode;
     this.faucet = settings == null ? void 0 : settings.faucet;
     this.indexer = settings == null ? void 0 : settings.indexer;
-    this.clientConfig = (_b = settings == null ? void 0 : settings.clientConfig) != null ? _b : {};
+    this.client = (_b = settings == null ? void 0 : settings.client) != null ? _b : { provider: import_aptos_client.default };
+    this.clientConfig = (_c = settings == null ? void 0 : settings.clientConfig) != null ? _c : {};
   }
   getRequestUrl(apiType) {
     switch (apiType) {
@@ -3067,6 +3231,42 @@ function nextToken(tagStr, pos) {
 // src/transactions/transaction_builder/transaction_builder.ts
 var import_sha33 = require("@noble/hashes/sha3");
 
+// src/core/crypto/anySignature.ts
+var AnySignature = class extends Signature {
+  constructor(signature) {
+    super();
+    this.signature = signature;
+  }
+  toUint8Array() {
+    return this.signature.toUint8Array();
+  }
+  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");
+    }
+  }
+  static deserialize(deserializer) {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      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 AnySignature: ${index}`);
+    }
+  }
+};
+
 // src/utils/helpers.ts
 async function sleep(timeMs) {
   return new Promise((resolve) => {
@@ -3241,8 +3441,8 @@ 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);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -3282,26 +3482,26 @@ 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);
   }
 };
 
 // src/transactions/authenticator/transaction.ts
-var TransactionAuthenticator = class {
+var TransactionAuthenticator = class extends Serializable {
   static deserialize(deserializer) {
     const index = deserializer.deserializeUleb128AsU32();
     switch (index) {
@@ -3313,8 +3513,8 @@ var TransactionAuthenticator = class {
         return TransactionAuthenticatorMultiAgent.load(deserializer);
       case 3 /* FeePayer */:
         return TransactionAuthenticatorFeePayer.load(deserializer);
-      case 4 /* Secp256k1Ecdsa */:
-        return TransactionAuthenticatorSecp256k1.load(deserializer);
+      case 4 /* SingleSenderTransactionAuthenticator */:
+        return SingleSenderTransactionAuthenticator.load(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
     }
@@ -3400,21 +3600,18 @@ 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 SingleSenderTransactionAuthenticator = class extends TransactionAuthenticator {
+  constructor(sender) {
     super();
-    this.public_key = public_key;
-    this.signature = signature;
+    this.sender = sender;
   }
   serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* Secp256k1Ecdsa */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
+    serializer.serializeU32AsUleb128(4 /* SingleSenderTransactionAuthenticator */);
+    this.sender.serialize(serializer);
   }
   static load(deserializer) {
-    const public_key = Secp256k1PublicKey.deserialize(deserializer);
-    const signature = Secp256k1Signature.deserialize(deserializer);
-    return new TransactionAuthenticatorSecp256k1(public_key, signature);
+    const sender = AccountAuthenticator.deserialize(deserializer);
+    return new SingleSenderTransactionAuthenticator(sender);
   }
 };
 
@@ -3752,7 +3949,7 @@ 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)
+      new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), (_a = args.typeArguments) != null ? _a : [], args.functionArguments)
     );
   }
   if ("multisigAddress" in args) {
@@ -3765,7 +3962,7 @@ function generateTransactionPayload(args) {
             `${funcNameParts2[0]}::${funcNameParts2[1]}`,
             funcNameParts2[2],
             (_b = args.typeArguments) != null ? _b : [],
-            args.arguments
+            args.functionArguments
           )
         )
       )
@@ -3777,7 +3974,7 @@ function generateTransactionPayload(args) {
       `${funcNameParts[0]}::${funcNameParts[1]}`,
       funcNameParts[2],
       (_c = args.typeArguments) != null ? _c : [],
-      args.arguments
+      args.functionArguments
     )
   );
 }
@@ -3884,26 +4081,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 SingleSenderTransactionAuthenticator(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) {
@@ -3917,11 +4113,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`);
   }
@@ -3945,11 +4138,8 @@ function generateSignedTransaction(args) {
     );
     return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
-  if (accountAuthenticator instanceof AccountAuthenticatorSecp256k1) {
-    const transactionAuthenticator = new TransactionAuthenticatorSecp256k1(
-      accountAuthenticator.public_key,
-      accountAuthenticator.signature
-    );
+  if (accountAuthenticator instanceof AccountAuthenticatorSingleKey) {
+    const transactionAuthenticator = new SingleSenderTransactionAuthenticator(accountAuthenticator);
     return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
   throw new Error(
@@ -4079,6 +4269,28 @@ async function submitTransaction(args) {
   });
   return data;
 }
+async function signAndSubmitTransaction(args) {
+  const { aptosConfig, signer, transaction } = args;
+  const authenticator = signTransaction({ signer, transaction });
+  return submitTransaction({
+    aptosConfig,
+    transaction,
+    senderAuthenticator: authenticator
+  });
+}
+async function publishModuleTransaction(args) {
+  const { aptosConfig, account, metadataBytes, byteCode, options } = args;
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: account,
+    data: {
+      function: "0x1::code::publish_package_txn",
+      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector([MoveVector.U8(byteCode)])]
+    },
+    options
+  });
+  return transaction;
+}
 
 // src/internal/coin.ts
 async function transferCoinTransaction(args) {
@@ -4090,7 +4302,7 @@ async function transferCoinTransaction(args) {
     data: {
       function: "0x1::aptos_account::transfer_coins",
       typeArguments: [new TypeTagStruct(StructTag.fromString(coinStructType))],
-      arguments: [AccountAddress.fromHexInput(recipient), new U64(amount)]
+      functionArguments: [AccountAddress.fromHexInput(recipient), new U64(amount)]
     },
     options
   });
@@ -4115,7 +4327,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),
@@ -4217,7 +4429,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),
@@ -4261,9 +4473,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) {
@@ -4376,7 +4585,11 @@ 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 }
+  });
   return txnHash;
 }
 
@@ -4454,6 +4667,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 });
   }
@@ -4622,13 +4846,15 @@ var TransactionSubmission = class {
   }
   async signAndSubmitTransaction(args) {
     const { signer, transaction } = args;
-    const authenticator = signTransaction({ signer, transaction });
-    return submitTransaction({
+    return signAndSubmitTransaction({
       aptosConfig: this.config,
-      transaction,
-      senderAuthenticator: authenticator
+      signer,
+      transaction
     });
   }
+  async publishModuleTransaction(args) {
+    return publishModuleTransaction({ aptosConfig: this.config, ...args });
+  }
 };
 
 // src/api/aptos.ts
@@ -4675,6 +4901,8 @@ applyMixin(Aptos, TransactionSubmission, "transactionSubmission");
   AccountAddress,
   AccountAuthenticatorVariant,
   AddressInvalidReason,
+  AnyPublicKeyVariant,
+  AnySignatureVariant,
   Aptos,
   AptosApiError,
   AptosConfig,
@@ -4716,6 +4944,7 @@ applyMixin(Aptos, TransactionSubmission, "transactionSubmission");
   Serializer,
   Signature,
   SigningScheme,
+  SigningSchemeInput,
   StructTag,
   TransactionAuthenticatorVariant,
   TransactionPayloadVariants,
@@ -4756,6 +4985,7 @@ applyMixin(Aptos, TransactionSubmission, "transactionSubmission");
   postAptosFaucet,
   postAptosFullNode,
   postAptosIndexer,
+  request,
   stringStructTag,
   validateNumberInRange
 });