@aptos-labs/ts-sdk 0.0.5 → 0.0.7

package/src/internal/ans.ts

@@ -9,12 +9,14 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { MoveOption, MoveString, U64 } from "../bcs";
-import { Account, AccountAddress } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
-import { HexInput, MoveAddressType, MoveValue } from "../types";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { GetANSNameResponse, MoveAddressType, MoveValue, OrderBy, PaginationArgs } from "../types";
+import { GetNamesQuery } from "../types/generated/operations";
+import { GetNames } from "../types/generated/queries";
+import { CurrentAptosNamesBoolExp } from "../types/generated/types";
 import { Network } from "../utils/apiEndpoints";
-import { view } from "./general";
+import { queryIndexer, view } from "./general";
 import { generateTransaction } from "./transactionSubmission";
 
 export const VALIDATION_RULES_DESCRIPTION = [
@@ -82,8 +84,8 @@ function getRouterAddress(aptosConfig: AptosConfig): string {
   return address;
 }
 
-const Some = <T>(value: T): MoveValue => ({ vec: [value] } as any);
-const None = (): MoveValue => ({ vec: [] } as any);
+const Some = <T>(value: T): MoveValue => ({ vec: [value] }) as any;
+const None = (): MoveValue => ({ vec: [] }) as any;
 // != here is intentional, we want to check for null and undefined
 // eslint-disable-next-line eqeqeq
 const Option = <T>(value: T | undefined | null): MoveValue => (value != undefined ? Some(value) : None());
@@ -119,17 +121,17 @@ export interface RegisterNameParameters {
   sender: Account;
   name: string;
   expiration:
-    | { policy: "domain"; years: 1 }
+    | { policy: "domain"; years?: 1 }
     | { policy: "subdomain:follow-domain" }
     | { policy: "subdomain:independent"; expirationDate: Date };
   transferable?: boolean;
-  toAddress?: HexInput;
-  targetAddress?: HexInput;
+  toAddress?: AccountAddressInput;
+  targetAddress?: AccountAddressInput;
   options?: InputGenerateTransactionOptions;
 }
 
-export async function registerName(args: RegisterNameParameters): Promise<InputSingleSignerTransaction> {
-  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options } = args;
+export async function registerName(args: RegisterNameParameters): Promise<SingleSignerTransaction> {
+  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options, transferable } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
 
@@ -147,29 +149,413 @@ export async function registerName(args: RegisterNameParameters): Promise<InputS
   }
 
   if (expiration.policy === "domain") {
-    if (expiration.years !== 1) {
+    const years = expiration.years ?? 1;
+    if (years !== 1) {
       throw new Error("For now, names can only be registered for 1 year at a time");
     }
 
-    const registrationDuration = expiration.years * 31536000;
+    const secondsInYear = 31536000;
+    const registrationDuration = years * secondsInYear;
 
     const transaction = await generateTransaction({
       aptosConfig,
       sender: sender.accountAddress.toString(),
       data: {
         function: `${routerAddress}::router::register_domain`,
-        functionArguments: [
-          new MoveString(domainName),
-          new U64(registrationDuration),
-          new MoveOption(targetAddress ? AccountAddress.from(targetAddress) : null),
-          new MoveOption(toAddress ? AccountAddress.from(toAddress) : null),
-        ],
+        functionArguments: [domainName, registrationDuration, targetAddress, toAddress],
       },
       options,
     });
 
-    return transaction as InputSingleSignerTransaction;
+    return transaction as SingleSignerTransaction;
   }
 
-  throw new Error(`Policy ${expiration.policy} is not supported yet`);
+  // We are a subdomain
+  if (!subdomainName) {
+    throw new Error(`${expiration.policy} requires a subdomain to be provided.`);
+  }
+
+  let tldExpiration = await getExpiration({ aptosConfig, name: domainName });
+  if (!tldExpiration) {
+    throw new Error("The domain does not exist");
+  }
+  // The contract gives us seconds, but JS expects milliseconds
+  tldExpiration *= 1000;
+
+  const expirationDateInMillisecondsSinceEpoch =
+    expiration.policy === "subdomain:independent" ? expiration.expirationDate.valueOf() : tldExpiration;
+
+  if (expirationDateInMillisecondsSinceEpoch > tldExpiration) {
+    throw new Error("The subdomain expiration time cannot be greater than the domain expiration time");
+  }
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::register_subdomain`,
+      functionArguments: [
+        domainName,
+        subdomainName,
+        Math.round(expirationDateInMillisecondsSinceEpoch / 1000),
+        expiration.policy === "subdomain:follow-domain" ? 1 : 0,
+        !!transferable,
+        targetAddress,
+        toAddress,
+      ],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getExpiration(args: { aptosConfig: AptosConfig; name: string }): Promise<number | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  try {
+    const res = await view({
+      aptosConfig,
+      payload: {
+        function: `${routerAddress}::router::get_expiration`,
+        functionArguments: [domainName, Option(subdomainName)],
+      },
+    });
+
+    return res[0] as number;
+  } catch (e) {
+    return undefined;
+  }
+}
+
+export async function getPrimaryName(args: {
+  aptosConfig: AptosConfig;
+  address: AccountAddressInput;
+}): Promise<string | undefined> {
+  const { aptosConfig, address } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_primary_name`,
+      functionArguments: [AccountAddress.fromRelaxed(address).toString()],
+    },
+  });
+
+  const domainName = unwrapOption<MoveAddressType>(res[1]);
+  const subdomainName = unwrapOption<MoveAddressType>(res[0]);
+
+  if (!domainName) return undefined;
+
+  return [subdomainName, domainName].filter(Boolean).join(".");
+}
+
+export async function setPrimaryName(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string | null;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  if (!name) {
+    const transaction = await generateTransaction({
+      aptosConfig,
+      sender: sender.accountAddress.toString(),
+      data: {
+        function: `${routerAddress}::router::clear_primary_name`,
+        functionArguments: [],
+      },
+      options,
+    });
+
+    return transaction as SingleSignerTransaction;
+  }
+
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::set_primary_name`,
+      functionArguments: [domainName, subdomainName],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getTargetAddress(args: {
+  aptosConfig: AptosConfig;
+  name: string;
+}): Promise<MoveAddressType | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_target_addr`,
+      functionArguments: [domainName, Option(subdomainName)],
+    },
+  });
+
+  const target = unwrapOption<MoveAddressType>(res[0]);
+  return target ? AccountAddress.fromRelaxed(target).toString() : undefined;
+}
+
+export async function setTargetAddress(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  address: AccountAddressInput;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, address, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::set_target_addr`,
+      functionArguments: [domainName, subdomainName, address],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getName(args: {
+  aptosConfig: AptosConfig;
+  name: string;
+}): Promise<GetANSNameResponse[0] | undefined> {
+  const { aptosConfig, name } = args;
+  const { domainName, subdomainName = "" } = isValidANSName(name);
+
+  const where: CurrentAptosNamesBoolExp = {
+    domain: { _eq: domainName },
+    subdomain: { _eq: subdomainName },
+  };
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    query: {
+      query: GetNames,
+      variables: {
+        where_condition: where,
+        limit: 1,
+      },
+    },
+    originMethod: "getName",
+  });
+
+  return data.current_aptos_names[0] as GetANSNameResponse[0] | undefined;
+}
+
+interface QueryNamesOptions {
+  options?: {
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetANSNameResponse[0]>;
+    where?: CurrentAptosNamesBoolExp;
+  };
+}
+
+export interface GetAccountNamesArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountNames(
+  args: { aptosConfig: AptosConfig } & GetAccountNamesArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountNames",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetAccountDomainsArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountDomains(
+  args: { aptosConfig: AptosConfig } & GetAccountDomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountDomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+          subdomain: { _eq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetAccountSubdomainsArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountSubdomains(
+  args: { aptosConfig: AptosConfig } & GetAccountSubdomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountSubdomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+          subdomain: { _neq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetDomainSubdomainsArgs extends QueryNamesOptions {
+  domain: string;
+}
+
+export async function getDomainSubdomains(
+  args: { aptosConfig: AptosConfig } & GetDomainSubdomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, domain } = args;
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getDomainSubdomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          domain: { _eq: domain },
+          subdomain: { _neq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+/**
+ * This function returns the expiration date in which a name is fully expired as
+ * defined by the contract.  The grace period allows for names to be past
+ * expiration for a certain amount of time before they are released to the
+ * public. The names will not function as normal, but the owner can renew
+ * without others taking ownership of the name. At the time of writing, the
+ * contract specified 30 days.
+ *
+ * @param args.aptosConfig an AptosConfig object
+ * @returns
+ */
+async function getANSExpirationDate(args: { aptosConfig: AptosConfig }): Promise<string> {
+  const { aptosConfig } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::config::reregistration_grace_sec`,
+      functionArguments: [],
+    },
+  });
+
+  const gracePeriodInSeconds = res[0] as number;
+  const gracePeriodInDays = gracePeriodInSeconds / 60 / 60 / 24;
+  const now = () => new Date();
+  return new Date(now().setDate(now().getDate() - gracePeriodInDays)).toISOString();
+}
+
+export async function renewDomain(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  years?: 1;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, years = 1, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const renewalDuration = years * 31536000;
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  if (subdomainName) {
+    throw new Error("Subdomains cannot be renewed");
+  }
+
+  if (years !== 1) {
+    throw new Error("Currently, only 1 year renewals are supported");
+  }
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::renew_domain`,
+      functionArguments: [domainName, renewalDuration],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
 }

package/src/internal/coin.ts

@@ -1,8 +1,8 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { U64 } from "../bcs/serializable/movePrimitives";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
-import { AnyNumber, MoveStructType } from "../types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { AnyNumber, MoveStructId } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
 import { parseTypeTag } from "../transactions/typeTag/parser";
@@ -12,9 +12,9 @@ export async function transferCoinTransaction(args: {
   sender: Account;
   recipient: AccountAddressInput;
   amount: AnyNumber;
-  coinType?: MoveStructType;
+  coinType?: MoveStructId;
   options?: InputGenerateTransactionOptions;
-}): Promise<InputSingleSignerTransaction> {
+}): Promise<SingleSignerTransaction> {
   const { aptosConfig, sender, recipient, amount, coinType, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({
@@ -28,5 +28,5 @@ export async function transferCoinTransaction(args: {
     options,
   });
 
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }

package/src/internal/digitalAsset.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveString, MoveVector, Bool, U64, U8 } from "../bcs";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import {
   AnyNumber,
   GetCollectionDataResponse,
@@ -55,7 +55,7 @@ export async function mintTokenTransaction(args: {
   name: string;
   uri: string;
   options?: InputGenerateTransactionOptions;
-}): Promise<InputSingleSignerTransaction> {
+}): Promise<SingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -74,7 +74,7 @@ export async function mintTokenTransaction(args: {
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }
 
 export async function getTokenData(args: {
@@ -219,7 +219,7 @@ export async function createCollectionTransaction(
     uri: string;
     options?: InputGenerateTransactionOptions;
   } & CreateCollectionOptions,
-): Promise<InputSingleSignerTransaction> {
+): Promise<SingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -247,7 +247,7 @@ export async function createCollectionTransaction(
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }
 
 export async function getCollectionData(args: {

package/src/internal/event.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AccountAddress, AccountAddressInput } from "../core";
-import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructType, OrderBy } from "../types";
+import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderBy } from "../types";
 import { GetEventsQuery } from "../types/generated/operations";
 import { GetEvents } from "../types/generated/queries";
 import { EventsBoolExp } from "../types/generated/types";
@@ -35,7 +35,7 @@ export async function getAccountEventsByCreationNumber(args: {
 export async function getAccountEventsByEventType(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  eventType: MoveStructType;
+  eventType: MoveStructId;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetEventsResponse[0]>;

package/src/internal/general.ts

@@ -21,7 +21,7 @@ import {
   MoveValue,
   TableItemRequest,
   ViewRequest,
-  ViewRequestData,
+  InputViewRequestData,
 } from "../types";
 import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
 import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
@@ -83,11 +83,11 @@ export async function getTableItem<T>(args: {
   return response.data as T;
 }
 
-export async function view(args: {
+export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args: {
   aptosConfig: AptosConfig;
-  payload: ViewRequestData;
+  payload: InputViewRequestData;
   options?: LedgerVersion;
-}): Promise<MoveValue[]> {
+}): Promise<T> {
   const { aptosConfig, payload, options } = args;
   const { data } = await postAptosFullNode<ViewRequest, MoveValue[]>({
     aptosConfig,
@@ -100,7 +100,8 @@ export async function view(args: {
       arguments: payload.functionArguments ?? [],
     },
   });
-  return data;
+
+  return data as T;
 }
 
 export async function getChainTopUserTransactions(args: {
@@ -122,7 +123,7 @@ export async function getChainTopUserTransactions(args: {
   return data.user_transactions;
 }
 
-export async function queryIndexer<T>(args: {
+export async function queryIndexer<T extends {}>(args: {
   aptosConfig: AptosConfig;
   query: GraphqlQuery;
   originMethod?: string;

package/src/internal/queries/ansTokenFragment.graphql

@@ -0,0 +1,9 @@
+fragment AnsTokenFragment on current_aptos_names {
+  domain
+  expiration_timestamp
+  registered_address
+  subdomain
+  token_standard
+  is_primary
+  owner_address
+}

package/src/internal/queries/getNames.graphql

@@ -0,0 +1,11 @@
+#import "./AnsTokenFragment";
+query getNames(
+  $offset: Int
+  $limit: Int
+  $where_condition: current_aptos_names_bool_exp
+  $order_by: [current_aptos_names_order_by!]
+) {
+  current_aptos_names(limit: $limit, where: $where_condition, order_by: $order_by, offset: $offset) {
+    ...AnsTokenFragment
+  }
+}