@aptos-labs/ts-sdk 0.0.6 → 0.0.8

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, OrderByArg, PaginationArgs, WhereArg } 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] });
+const None = (): MoveValue => ({ vec: [] });
 // != 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());
@@ -111,7 +113,7 @@ export async function getOwnerAddress(args: { aptosConfig: AptosConfig; name: st
 
   const owner = unwrapOption<MoveAddressType>(res[0]);
 
-  return owner ? AccountAddress.fromRelaxed(owner).toString() : undefined;
+  return owner ? AccountAddress.from(owner).toString() : undefined;
 }
 
 export interface RegisterNameParameters {
@@ -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 };
+    | { policy: "subdomain:independent"; expirationDate: number };
   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,426 @@ 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;
   }
 
-  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.`);
+  }
+
+  const tldExpiration = await getExpiration({ aptosConfig, name: domainName });
+  if (!tldExpiration) {
+    throw new Error("The domain does not exist");
+  }
+
+  const expirationDateInMillisecondsSinceEpoch =
+    expiration.policy === "subdomain:independent" ? expiration.expirationDate : 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;
+}
+
+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)],
+      },
+    });
+
+    // Normalize expiration time from epoch seconds to epoch milliseconds
+    return Number(res[0]) * 1000;
+  } 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.from(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;
+  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;
+  }
+
+  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;
+}
+
+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.from(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;
+}
+
+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",
+  });
+
+  // Convert the expiration_timestamp from an ISO string to milliseconds since epoch
+  let res = data.current_aptos_names[0];
+  if (res) {
+    res = sanitizeANSName(res);
+  }
+
+  return res;
+}
+
+interface QueryNamesOptions {
+  options?: PaginationArgs & OrderByArg<GetANSNameResponse[0]> & WhereArg<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?.limit,
+        offset: options?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names.map(sanitizeANSName);
+}
+
+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?.limit,
+        offset: options?.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.map(sanitizeANSName);
+}
+
+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?.limit,
+        offset: options?.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.map(sanitizeANSName);
+}
+
+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?.limit,
+        offset: options?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          domain: { _eq: domain },
+          subdomain: { _neq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names.map(sanitizeANSName);
+}
+
+/**
+ * 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 [gracePeriodInSeconds] = await view<[number]>({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::config::reregistration_grace_sec`,
+      functionArguments: [],
+    },
+  });
+
+  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;
+}
+
+/**
+ * The indexer returns ISO strings for expiration, however the contract works in
+ * epoch milliseconds. This function converts the ISO string to epoch
+ * milliseconds. In the future, if other properties need sanitization, this can
+ * be extended.
+ */
+function sanitizeANSName(name: GetANSNameResponse[0]): GetANSNameResponse[0] {
+  return {
+    ...name,
+    expiration_timestamp: new Date(name.expiration_timestamp).valueOf(),
+  };
 }

package/src/internal/coin.ts

@@ -1,11 +1,9 @@
 import { AptosConfig } from "../api/aptosConfig";
-import { U64 } from "../bcs/serializable/movePrimitives";
-import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { Account, AccountAddressInput } from "../core";
+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";
 
 export async function transferCoinTransaction(args: {
   aptosConfig: AptosConfig;
@@ -14,7 +12,7 @@ export async function transferCoinTransaction(args: {
   amount: AnyNumber;
   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({
@@ -22,11 +20,11 @@ export async function transferCoinTransaction(args: {
     sender: sender.accountAddress,
     data: {
       function: "0x1::aptos_account::transfer_coins",
-      typeArguments: [parseTypeTag(coinStructType)],
-      functionArguments: [AccountAddress.from(recipient), new U64(amount)],
+      typeArguments: [coinStructType],
+      functionArguments: [recipient, amount],
     },
     options,
   });
 
-  return transaction as InputSingleSignerTransaction;
+  return transaction;
 }

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,
@@ -19,9 +19,9 @@ import {
   GetOwnedTokensResponse,
   GetTokenActivityResponse,
   GetTokenDataResponse,
-  OrderBy,
+  OrderByArg,
   PaginationArgs,
-  TokenStandard,
+  TokenStandardArg,
 } from "../types";
 import {
   GetCollectionDataQuery,
@@ -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;
 }
 
 export async function getTokenData(args: {
@@ -132,10 +132,7 @@ export async function getCurrentTokenOwnership(args: {
 export async function getOwnedTokens(args: {
   aptosConfig: AptosConfig;
   ownerAddress: AccountAddressInput;
-  options?: {
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetTokenActivityResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
 }): Promise<GetOwnedTokensResponse> {
   const { aptosConfig, ownerAddress, options } = args;
 
@@ -147,8 +144,8 @@ export async function getOwnedTokens(args: {
     query: GetCurrentTokenOwnership,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -165,10 +162,7 @@ export async function getOwnedTokens(args: {
 export async function getTokenActivity(args: {
   aptosConfig: AptosConfig;
   tokenAddress: AccountAddressInput;
-  options?: {
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetTokenActivityResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
 }): Promise<GetTokenActivityResponse> {
   const { aptosConfig, tokenAddress, options } = args;
 
@@ -180,8 +174,8 @@ export async function getTokenActivity(args: {
     query: GetTokenActivity,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -219,7 +213,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,16 +241,14 @@ export async function createCollectionTransaction(
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction;
 }
 
 export async function getCollectionData(args: {
   aptosConfig: AptosConfig;
   creatorAddress: AccountAddressInput;
   collectionName: string;
-  options?: {
-    tokenStandard?: TokenStandard;
-  };
+  options?: TokenStandardArg;
 }): Promise<GetCollectionDataResponse> {
   const { aptosConfig, creatorAddress, collectionName, options } = args;
   const address = AccountAddress.from(creatorAddress);
@@ -289,9 +281,7 @@ export async function getCollectionId(args: {
   aptosConfig: AptosConfig;
   creatorAddress: AccountAddressInput;
   collectionName: string;
-  options?: {
-    tokenStandard?: TokenStandard;
-  };
+  options?: TokenStandardArg;
 }): Promise<string> {
   return (await getCollectionData(args)).collection_id;
 }