@aptos-labs/ts-sdk 0.0.0

package/src/types/indexer.ts

@@ -0,0 +1,93 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * GENERATED QUERY TYPES FROM GRAPHQL SCHEMA
+ *
+ * generated types we generate from graphql schema that match the structure of the
+ * response type when querying from Hasura schema.
+ *
+ * These types are used as the return type when making the actual request (usually
+ * under the /internal/ folder)
+ */
+
+import {
+  GetAccountCoinsDataQuery,
+  GetAccountOwnedObjectsQuery,
+  GetAccountOwnedTokensQuery,
+  GetAccountOwnedTokensFromCollectionQuery,
+  GetAccountCollectionsWithOwnedTokensQuery,
+  GetDelegatedStakingActivitiesQuery,
+  GetNumberOfDelegatorsQuery,
+  GetCollectionDataQuery,
+  GetChainTopUserTransactionsQuery,
+  GetEventsQuery,
+  GetTokenDataQuery,
+  GetProcessorStatusQuery,
+  GetFungibleAssetMetadataQuery,
+  GetFungibleAssetActivitiesQuery,
+  GetCurrentFungibleAssetBalancesQuery,
+  GetTokenActivityQuery,
+  GetCurrentTokenOwnershipQuery,
+} from "./generated/operations";
+
+/**
+ * CUSTOM RESPONSE TYPES FOR THE END USER
+ *
+ * To provide a good dev exp, we build custom types derived from the
+ * query types to be the response type the end developer/user will
+ * work with.
+ *
+ * These types are used as the return type when calling a sdk api function
+ * that calls the function that queries the server (usually under the /api/ folder)
+ */
+export type GetAccountOwnedObjectsResponse = GetAccountOwnedObjectsQuery["current_objects"];
+
+export type GetAccountOwnedTokensQueryResponse = GetAccountOwnedTokensQuery["current_token_ownerships_v2"];
+
+export type GetAccountOwnedTokensFromCollectionResponse =
+  GetAccountOwnedTokensFromCollectionQuery["current_token_ownerships_v2"];
+export type GetAccountCollectionsWithOwnedTokenResponse =
+  GetAccountCollectionsWithOwnedTokensQuery["current_collection_ownership_v2_view"];
+export type GetAccountCoinsDataResponse = GetAccountCoinsDataQuery["current_fungible_asset_balances"];
+export type GetChainTopUserTransactionsResponse = GetChainTopUserTransactionsQuery["user_transactions"];
+export type GetEventsResponse = GetEventsQuery["events"];
+
+export type GetNumberOfDelegatorsResponse = GetNumberOfDelegatorsQuery["num_active_delegator_per_pool"];
+export type GetDelegatedStakingActivitiesResponse = GetDelegatedStakingActivitiesQuery["delegated_staking_activities"];
+export type GetCollectionDataResponse = GetCollectionDataQuery["current_collections_v2"][0];
+export type GetTokenDataResponse = GetTokenDataQuery["current_token_datas_v2"][0];
+export type GetProcessorStatusResponse = GetProcessorStatusQuery["processor_status"];
+export type GetFungibleAssetMetadataResponse = GetFungibleAssetMetadataQuery["fungible_asset_metadata"];
+export type GetFungibleAssetActivitiesResponse = GetFungibleAssetActivitiesQuery["fungible_asset_activities"];
+export type GetCurrentFungibleAssetBalancesResponse =
+  GetCurrentFungibleAssetBalancesQuery["current_fungible_asset_balances"];
+export type GetTokenActivityResponse = GetTokenActivityQuery["token_activities_v2"];
+export type GetCurrentTokenOwnershipResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"][0];
+export type GetOwnedTokensResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"];
+
+/**
+ * A generic type that being passed by each function and holds an
+ * array of properties we can sort the query by
+ */
+export type OrderBy<T> = Array<{ [K in keyof T]?: OrderByValue }>;
+export type OrderByValue =
+  | "asc"
+  | "asc_nulls_first"
+  | "asc_nulls_last"
+  | "desc"
+  | "desc_nulls_first"
+  | "desc_nulls_last";
+
+/**
+ * Refers to the token standard we want to query for
+ */
+export type TokenStandard = "v1" | "v2";
+
+/**
+ * The graphql query type to pass into the `queryIndexer` function
+ */
+export type GraphqlQuery = {
+  query: string;
+  variables?: {};
+};

package/src/utils/apiEndpoints.ts

@@ -0,0 +1,36 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export const NetworkToIndexerAPI: Record<string, string> = {
+  mainnet: "https://indexer.mainnet.aptoslabs.com/v1/graphql",
+  testnet: "https://indexer-testnet.staging.gcp.aptosdev.com/v1/graphql",
+  devnet: "https://indexer-devnet.staging.gcp.aptosdev.com/v1/graphql",
+  local: "http://127.0.0.1:8090/v1/graphql",
+};
+
+export const NetworkToNodeAPI: Record<string, string> = {
+  mainnet: "https://fullnode.mainnet.aptoslabs.com/v1",
+  testnet: "https://fullnode.testnet.aptoslabs.com/v1",
+  devnet: "https://fullnode.devnet.aptoslabs.com/v1",
+  local: "http://127.0.0.1:8080/v1",
+};
+
+export const NetworkToFaucetAPI: Record<string, string> = {
+  mainnet: "https://faucet.mainnet.aptoslabs.com",
+  testnet: "https://faucet.testnet.aptoslabs.com",
+  devnet: "https://faucet.devnet.aptoslabs.com",
+  local: "http://127.0.0.1:8081",
+};
+
+export enum Network {
+  MAINNET = "mainnet",
+  TESTNET = "testnet",
+  DEVNET = "devnet",
+  LOCAL = "local",
+  CUSTOM = "custom",
+}
+
+export const NetworkToChainId: Record<string, number> = {
+  mainnet: 1,
+  testnet: 2,
+};

package/src/utils/const.ts

@@ -0,0 +1,51 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Network } from "./apiEndpoints";
+
+/**
+ * Type of API endpoint for request routing
+ */
+export enum AptosApiType {
+  FULLNODE,
+  INDEXER,
+  FAUCET,
+}
+
+export const DEFAULT_NETWORK = Network.DEVNET;
+
+/**
+ * The default max gas amount when none is given.
+ *
+ * This is the maximum number of gas units that will be used by a transaction before being rejected.
+ *
+ * Note that max gas amount varies based on the transaction.  A larger transaction will go over this
+ * default gas amount, and the value will need to be changed for the specific transaction.
+ */
+export const DEFAULT_MAX_GAS_AMOUNT = 200000;
+
+/**
+ * The default transaction expiration seconds from now.
+ *
+ * This time is how long until the blockchain nodes will reject the transaction.
+ *
+ * Note that the transaction expiration time varies based on network connection and network load.  It may need to be
+ * increased for the transaction to be processed.
+ */
+export const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
+
+/**
+ * The default number of seconds to wait for a transaction to be processed.
+ *
+ * This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for
+ * the results of the transaction.  It may take longer based on network connection and network load.
+ */
+export const DEFAULT_TXN_TIMEOUT_SEC = 20;
+
+/**
+ * The default gas currency for the network.
+ */
+export const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+
+export const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
+export const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";

package/src/utils/hdKey.ts

@@ -0,0 +1,113 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+import * as bip39 from "@scure/bip39";
+
+export type DerivedKeys = {
+  key: Uint8Array;
+  chainCode: Uint8Array;
+};
+
+/**
+ * Aptos derive path is 637
+ *
+ * See https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+ */
+export const APTOS_PATH_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+'\/[0-9]+'?$/;
+
+/**
+ * A list of supported key types and associated seeds
+ */
+export enum KeyType {
+  ED25519 = "ed25519 seed",
+}
+
+const HARDENED_OFFSET = 0x80000000;
+
+const deriveKey = (hashSeed: Uint8Array | string, data: Uint8Array | string): DerivedKeys => {
+  const digest = hmac.create(sha512, hashSeed).update(data).digest();
+  return {
+    key: digest.slice(0, 32),
+    chainCode: digest.slice(32),
+  };
+};
+
+/**
+ * Derive a child key from the private key
+ * @param key
+ * @param chainCode
+ * @param index
+ * @constructor
+ */
+const CKDPriv = ({ key, chainCode }: DerivedKeys, index: number): DerivedKeys => {
+  const buffer = new ArrayBuffer(4);
+  new DataView(buffer).setUint32(0, index);
+  const indexBytes = new Uint8Array(buffer);
+  const zero = new Uint8Array([0]);
+  const data = new Uint8Array([...zero, ...key, ...indexBytes]);
+
+  return deriveKey(chainCode, data);
+};
+
+const removeApostrophes = (val: string): string => val.replace("'", "");
+
+/**
+ * Splits derive path into segments
+ * @param path
+ */
+const splitPath = (path: string): Array<string> => path.split("/").slice(1).map(removeApostrophes);
+
+/**
+ * Checks if the BIP44 path is valid for Aptos
+ * @param path the BIP44 path
+ *
+ * @returns true if the path is a valid Aptos path
+ */
+export const isValidPath = (path: string): boolean => {
+  if (!APTOS_PATH_REGEX.test(path)) {
+    return false;
+  }
+  return !splitPath(path).some(Number.isNaN as any);
+};
+
+/**
+ * Normalizes the mnemonic by removing extra whitespace and making it lowercase
+ * @param mnemonic the mnemonic seed phrase
+ */
+const mnemonicToSeed = (mnemonic: string): Uint8Array => {
+  const normalizedMnemonic = mnemonic
+    .trim()
+    .split(/\s+/)
+    .map((part) => part.toLowerCase())
+    .join(" ");
+  return bip39.mnemonicToSeedSync(normalizedMnemonic);
+};
+
+/**
+ * Derives a private key from a mnemonic seed phrase.
+ *
+ * To derive multiple keys from the same phrase, change the path
+ * @param keyType the key type seed used to derive keys
+ * @param path the BIP44 path
+ * @param seedPhrase the mnemonic seed phrase
+ * @param offset the offset used for key derivation, defaults to [HARDENED_OFFSET]
+ */
+export const derivePrivateKeyFromMnemonic = (
+  keyType: KeyType,
+  path: string,
+  seedPhrase: string,
+  offset = HARDENED_OFFSET,
+): DerivedKeys => {
+  if (!isValidPath(path)) {
+    throw new Error("Invalid derivation path");
+  }
+
+  // Derive the master key from the mnemonic
+  const { key, chainCode } = deriveKey(keyType, mnemonicToSeed(seedPhrase));
+  const segments = splitPath(path).map((el) => parseInt(el, 10));
+
+  // Derive the child key based on the path
+  return segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), { key, chainCode });
+};

package/src/utils/helpers.ts

@@ -0,0 +1,12 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Sleep the current thread for the given amount of time
+ * @param timeMs time in milliseconds to sleep
+ */
+export async function sleep(timeMs: number): Promise<null> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeMs);
+  });
+}

package/src/utils/memoize.ts

@@ -0,0 +1,68 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * The global cache Map shared across all functions.  Must keep care to ensure that the
+ * cache keys are unique across all functions.
+ */
+const cache = new Map<string, { value: any; timestamp: number }>();
+
+/**
+ * A memoize high order function to cache async function response
+ *
+ * @param func An async function to cache the result of
+ * @param key The provided cache key
+ * @param ttlMs time-to-live in milliseconds for cached data
+ * @returns the cached or latest result
+ */
+export function memoizeAsync<T>(
+  func: (...args: any[]) => Promise<T>,
+  key: string,
+  ttlMs?: number,
+): (...args: any[]) => Promise<T> {
+  return async (...args: any[]) => {
+    // Check if the cached result exists and is within TTL
+    if (cache.has(key)) {
+      const { value, timestamp } = cache.get(key)!;
+      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
+        return value;
+      }
+    }
+
+    // If not cached or TTL expired, compute the result
+    const result = await func(...args);
+
+    // Cache the result with a timestamp
+    cache.set(key, { value: result, timestamp: Date.now() });
+
+    return result;
+  };
+}
+
+/**
+ * A memoize high order function to cache function response
+ *
+ * @param func A function to cache the result of
+ * @param key The provided cache key
+ * @param ttlMs time-to-live in milliseconds for cached data
+ * @returns the cached or latest result
+ */
+export function memoize<T>(func: (...args: any[]) => T, key: string, ttlMs?: number): (...args: any[]) => T {
+  return (...args: any[]) => {
+    // Check if the cached result exists and is within TTL
+    if (cache.has(key)) {
+      const { value, timestamp } = cache.get(key)!;
+      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
+        return value;
+      }
+    }
+
+    // If not cached or TTL expired, compute the result
+    const result = func(...args);
+
+    // Cache the result with a timestamp
+    cache.set(key, { value: result, timestamp: Date.now() });
+
+    return result;
+  };
+}

package/src/version.ts

@@ -0,0 +1,9 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * The current version of the SDK
+ *
+ * hardcoded for now, we would want to have it injected dynamically
+ */
+export const VERSION = "0.0.0";