@aptos-labs/ts-sdk 1.34.0 → 1.35.0-zeta.0

package/src/client/post.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AptosConfig } from "../api/aptosConfig";
-import { aptosRequest } from "./core";
+import { aptosBinaryRequest, aptosRequest } from "./core";
 import { AptosResponse, AnyNumber, ClientConfig, MimeType } from "../types";
 import { AptosApiType } from "../utils/const";
 
@@ -115,6 +115,45 @@ export async function post<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Executes a POST request to the specified URL with the provided options.
+ *
+ * @param options - The options for the POST request.
+ * @param options.type - The type of the request.
+ * @param options.originMethod - The original method that initiated the request.
+ * @param options.path - The path for the request.
+ * @param options.body - The body content to be sent with the request.
+ * @param options.acceptType - The type of response expected from the server.
+ * @param options.contentType - The content type of the request body.
+ * @param options.params - Additional parameters to include in the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos request.
+ * @param options.overrides - Any overrides for the default request behavior.
+ * @returns The response from the POST request.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinary<Req extends {}>(options: PostRequestOptions): Promise<AptosResponse<Req, Buffer>> {
+  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
+  const url = aptosConfig.getRequestUrl(type);
+
+  return aptosBinaryRequest<Req>(
+    {
+      url,
+      method: "POST",
+      originMethod,
+      path,
+      body,
+      contentType,
+      acceptType,
+      params,
+      overrides,
+    },
+    aptosConfig,
+    options.type,
+  );
+}
+
 /**
  * Sends a request to the Aptos full node using the specified options.
  * This function allows you to interact with the Aptos blockchain by sending requests to the full node.
@@ -144,6 +183,36 @@ export async function postAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Sends a request to the Aptos full node using the specified options.
+ * This function allows you to interact with the Aptos blockchain by sending requests to the full node.
+ *
+ * @param options - The options for the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos client.
+ * @param options.aptosConfig.clientConfig - Client-specific configuration settings.
+ * @param options.aptosConfig.fullnodeConfig - Full node-specific configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinaryAptosFullNode<Req extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig } = options;
+
+  return postBinary<Req>({
+    ...options,
+    type: AptosApiType.FULLNODE,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },
+    },
+  });
+}
+
 /**
  * Sends a request to the Aptos indexer with the specified options.
  * This function allows you to interact with the Aptos indexer and customize the request using various configurations.
@@ -161,6 +230,7 @@ export async function postAptosIndexer<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
   const { aptosConfig } = options;
+  console.log("request", JSON.stringify(options.body, null, 2));
 
   return post<Req, Res>({
     ...options,

package/src/core/crypto/multiEd25519.ts

@@ -5,7 +5,8 @@ import { Deserializer, Serializer } from "../../bcs";
 import { SigningScheme as AuthenticationKeyScheme } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { AbstractMultiKey } from "./multiKey";
+import { VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 
 /**
@@ -19,7 +20,7 @@ import { Signature } from "./signature";
  * @group Implementation
  * @category Serialization
  */
-export class MultiEd25519PublicKey extends AccountPublicKey {
+export class MultiEd25519PublicKey extends AbstractMultiKey {
   /**
    * Maximum number of public keys supported
    * @group Implementation
@@ -69,8 +70,8 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
    * @category Serialization
    */
   constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {
-    super();
     const { publicKeys, threshold } = args;
+    super({ publicKeys });
 
     // Validate number of public keys
     if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {
@@ -209,6 +210,21 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
   }
 
   // endregion
+
+  /**
+   * Get the index of the provided public key.
+   *
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
+   * @group Implementation
+   */
+  getIndex(publicKey: Ed25519PublicKey): number {
+    return super.getIndex(publicKey);
+  }
 }
 
 /**

package/src/core/crypto/multiKey.ts

@@ -23,6 +23,79 @@ function bitCount(byte: number) {
 }
 /* eslint-enable no-bitwise */
 
+export abstract class AbstractMultiKey extends AccountPublicKey {
+  publicKeys: PublicKey[];
+
+  constructor(args: { publicKeys: PublicKey[] }) {
+    super();
+    this.publicKeys = args.publicKeys;
+  }
+
+  /**
+   * Create a bitmap that holds the mapping from the original public keys
+   * to the signatures passed in
+   *
+   * @param args.bits array of the index mapping to the matching public keys
+   * @returns Uint8array bit map
+   * @group Implementation
+   * @category Serialization
+   */
+  createBitmap(args: { bits: number[] }): Uint8Array {
+    const { bits } = args;
+    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.
+    // The decimal value of 0b10000000 is 128.
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+
+    // Check if duplicates exist in bits
+    const dupCheckSet = new Set();
+
+    bits.forEach((bit: number, idx: number) => {
+      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];
+
+      // eslint-disable-next-line no-bitwise
+      byte |= firstBitInByte >> bit % 8;
+
+      bitmap[byteOffset] = byte;
+    });
+
+    return bitmap;
+  }
+
+  /**
+   * Get the index of the provided public key.
+   *
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
+   * @group Implementation
+   * @category Serialization
+   */
+  getIndex(publicKey: PublicKey): number {
+    const index = this.publicKeys.findIndex((pk) => pk.toString() === publicKey.toString());
+
+    if (index !== -1) {
+      return index;
+    }
+    throw new Error(`Public key ${publicKey} not found in multi key set ${this.publicKeys}`);
+  }
+}
+
 /**
  * Represents a multi-key authentication scheme for accounts, allowing multiple public keys
  * to be associated with a single account. This class enforces a minimum number of valid signatures
@@ -34,7 +107,7 @@ function bitCount(byte: number) {
  * @group Implementation
  * @category Serialization
  */
-export class MultiKey extends AccountPublicKey {
+export class MultiKey extends AbstractMultiKey {
   /**
    * List of any public keys
    * @group Implementation
@@ -65,8 +138,8 @@ export class MultiKey extends AccountPublicKey {
    */
   // region Constructors
   constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {
-    super();
     const { publicKeys, signaturesRequired } = args;
+    super({ publicKeys });
 
     // Validate number of public keys is greater than signature required
     if (signaturesRequired < 1) {
@@ -156,49 +229,6 @@ export class MultiKey extends AccountPublicKey {
 
   // endregion
 
-  /**
-   * Create a bitmap that holds the mapping from the original public keys
-   * to the signatures passed in
-   *
-   * @param args.bits array of the index mapping to the matching public keys
-   * @returns Uint8array bit map
-   * @group Implementation
-   * @category Serialization
-   */
-  createBitmap(args: { bits: number[] }): Uint8Array {
-    const { bits } = args;
-    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.
-    // The decimal value of 0b10000000 is 128.
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-
-    // Check if duplicates exist in bits
-    const dupCheckSet = new Set();
-
-    bits.forEach((bit: number, idx: number) => {
-      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];
-
-      // eslint-disable-next-line no-bitwise
-      byte |= firstBitInByte >> bit % 8;
-
-      bitmap[byteOffset] = byte;
-    });
-
-    return bitmap;
-  }
-
   /**
    * Get the index of the provided public key.
    *
@@ -209,16 +239,10 @@ export class MultiKey extends AccountPublicKey {
    * @returns The corresponding index of the public key, if it exists.
    * @throws Error - If the public key is not found in the MultiKey.
    * @group Implementation
-   * @category Serialization
    */
   getIndex(publicKey: PublicKey): number {
     const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
-    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
-
-    if (index !== -1) {
-      return index;
-    }
-    throw new Error(`Public key ${publicKey} not found in MultiKey ${this.publicKeys}`);
+    return super.getIndex(anyPublicKey);
   }
 
   public static isInstance(value: PublicKey): value is MultiKey {

package/src/core/hex.ts

@@ -146,8 +146,10 @@ export class Hex {
    * @category Serialization
    */
   static fromHexInput(hexInput: HexInput): Hex {
+    if (hexInput instanceof Buffer) return new Hex(new Uint8Array(hexInput));
     if (hexInput instanceof Uint8Array) return new Hex(hexInput);
-    return Hex.fromHexString(hexInput);
+    if (typeof hexInput === "string") return Hex.fromHexString(hexInput);
+    throw new Error(`Invalid hex input type: ${typeof hexInput}`);
   }
 
   /**