@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/api/general.ts

@@ -8,6 +8,7 @@ import {
   getChainTopUserTransactions,
   getIndexerLastSuccessVersion,
   getLedgerInfo,
+  getProcessorStatus,
   getTableItem,
   queryIndexer,
   view,
@@ -16,13 +17,15 @@ import {
   AnyNumber,
   Block,
   GetChainTopUserTransactionsResponse,
+  GetProcessorStatusResponse,
   GraphqlQuery,
   LedgerInfo,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveValue,
   TableItemRequest,
   InputViewRequestData,
 } from "../types";
+import { ProcessorType } from "../utils/const";
 
 /**
  * A class to query all `General` Aptos related queries
@@ -114,7 +117,7 @@ export class General {
    *
    * @returns Table item value rendered in JSON
    */
-  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersion }): Promise<T> {
+  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersionArg }): Promise<T> {
     return getTableItem<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -133,7 +136,10 @@ export class General {
    *
    * @returns an array of Move values
    */
-  async view<T extends Array<MoveValue>>(args: { payload: InputViewRequestData; options?: LedgerVersion }): Promise<T> {
+  async view<T extends Array<MoveValue>>(args: {
+    payload: InputViewRequestData;
+    options?: LedgerVersionArg;
+  }): Promise<T> {
     return view<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -185,4 +191,14 @@ export class General {
   async getIndexerLastSuccessVersion(): Promise<number> {
     return getIndexerLastSuccessVersion({ aptosConfig: this.config });
   }
+
+  /**
+   * Query the processor status for a specific processor type.
+   *
+   * @param processorType The processor type to query
+   * @returns
+   */
+  async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {
+    return getProcessorStatus({ aptosConfig: this.config, processorType });
+  }
 }

package/src/api/staking.ts

@@ -1,45 +1,57 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import {
   getDelegatedStakingActivities,
   getNumberOfDelegators,
   getNumberOfDelegatorsForAllPools,
 } from "../internal/staking";
-import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderBy } from "../types";
+import { AnyNumber, GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderByArg } from "../types";
 import { AccountAddressInput } from "../core";
+import { ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
 
 /**
  * A class to query all `Staking` related queries on Aptos.
  */
 export class Staking {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
    *
    * @param args.poolAddress Pool address
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns The number of delegators for the given pool
    */
-  async getNumberOfDelegators(args: { poolAddress: AccountAddressInput }): Promise<number> {
+  async getNumberOfDelegators(args: {
+    poolAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getNumberOfDelegators({ aptosConfig: this.config, ...args });
   }
 
   /**
    * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
    *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
    */
   async getNumberOfDelegatorsForAllPools(args?: {
-    options?: {
-      orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;
   }): Promise<GetNumberOfDelegatorsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getNumberOfDelegatorsForAllPools({ aptosConfig: this.config, ...args });
   }
 
@@ -48,12 +60,19 @@ export class Staking {
    *
    * @param args.delegatorAddress Delegator address
    * @param args.poolAddress Pool address
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetDelegatedStakingActivitiesResponse response type
    */
   async getDelegatedStakingActivities(args: {
     delegatorAddress: AccountAddressInput;
     poolAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
   }): Promise<GetDelegatedStakingActivitiesResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getDelegatedStakingActivities({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/transaction.ts

@@ -12,12 +12,15 @@ import {
 } from "../internal/transaction";
 import {
   AnyNumber,
+  CommittedTransactionResponse,
   GasEstimation,
   HexInput,
   PaginationArgs,
   TransactionResponse,
   WaitForTransactionOptions,
 } from "../types";
+import { getSigningMessage } from "../internal/transactionSubmission";
+import { AnyRawTransaction } from "../transactions";
 
 export class Transaction {
   readonly config: AptosConfig;
@@ -112,7 +115,7 @@ export class Transaction {
   async waitForTransaction(args: {
     transactionHash: HexInput;
     options?: WaitForTransactionOptions;
-  }): Promise<TransactionResponse> {
+  }): Promise<CommittedTransactionResponse> {
     return waitForTransaction({
       aptosConfig: this.config,
       ...args,
@@ -139,4 +142,16 @@ export class Transaction {
       aptosConfig: this.config,
     });
   }
+
+  /**
+   * Returns a signing message for a transaction.
+   *
+   * This allows a user to sign a transaction using their own preferred signing method, and
+   * then submit it to the network.
+   * @param args.transaction A raw transaction for signing elsewhere
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
+    return getSigningMessage(args);
+  }
 }

package/src/api/transactionSubmission/build.ts

@@ -0,0 +1,42 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountAddressInput } from "../../core";
+import { generateTransaction } from "../../internal/transactionSubmission";
+import {
+  InputGenerateTransactionPayloadData,
+  InputGenerateTransactionOptions,
+  SingleSignerTransaction,
+  MultiAgentTransaction,
+} from "../../transactions";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Build` transaction operations
+ */
+export class Build {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  async transaction(args: {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+  }): Promise<SingleSignerTransaction> {
+    return generateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  async multiAgentTransaction(args: {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+  }): Promise<MultiAgentTransaction> {
+    return generateTransaction({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/transactionSubmission/sign.ts

@@ -0,0 +1,44 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Account } from "../../core";
+import { signTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Sign` transaction operations
+ */
+export class Sign {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  transaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    return signTransaction({
+      ...args,
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  transactionAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    const { signer, transaction } = args;
+
+    // if transaction doesnt hold a "feePayerAddress" prop it means
+    // this is not a fee payer transaction
+    if (!transaction.feePayerAddress) {
+      throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
+    }
+
+    // Set the feePayerAddress to the signer account address
+    transaction.feePayerAddress = signer.accountAddress;
+
+    return signTransaction({
+      signer,
+      transaction,
+    });
+  }
+}

package/src/api/transactionSubmission/simulate.ts

@@ -0,0 +1,56 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { PublicKey } from "../../core";
+import { simulateTransaction } from "../../internal/transactionSubmission";
+import { AnyRawTransaction, InputSimulateTransactionOptions } from "../../transactions";
+import { UserTransactionResponse } from "../../types";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Simulate` transaction operations
+ */
+export class Simulate {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  @ValidateFeePayerData
+  async transaction(args: {
+    signerPublicKey: PublicKey;
+    transaction: AnyRawTransaction;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  @ValidateFeePayerData
+  async multiAgentTransaction(args: {
+    signerPublicKey: PublicKey;
+    transaction: AnyRawTransaction;
+    secondarySignersPublicKeys: Array<PublicKey>;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ aptosConfig: this.config, ...args });
+  }
+}
+
+function ValidateFeePayerData(target: unknown, propertyKey: string, descriptor: PropertyDescriptor) {
+  const originalMethod = descriptor.value;
+  /* eslint-disable-next-line func-names, no-param-reassign */
+  descriptor.value = async function (...args: any[]) {
+    const [methodArgs] = args;
+
+    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerPublicKey) {
+      throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");
+    }
+
+    return originalMethod.apply(this, args);
+  };
+
+  return descriptor;
+}

package/src/api/transactionSubmission/submit.ts

@@ -0,0 +1,53 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { submitTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
+import { PendingTransactionResponse } from "../../types";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Submit` transaction operations
+ */
+export class Submit {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  @ValidateFeePayerData
+  async transaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  @ValidateFeePayerData
+  async multiAgentTransaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    additionalSignersAuthenticators: Array<AccountAuthenticator>;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+}
+
+function ValidateFeePayerData(target: unknown, propertyKey: string, descriptor: PropertyDescriptor) {
+  const originalMethod = descriptor.value;
+  /* eslint-disable-next-line func-names, no-param-reassign */
+  descriptor.value = async function (...args: any[]) {
+    const [methodArgs] = args;
+
+    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerAuthenticator) {
+      throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");
+    }
+
+    return originalMethod.apply(this, args);
+  };
+
+  return descriptor;
+}

package/src/api/transactionSubmission.ts

@@ -3,30 +3,15 @@
 
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput, PrivateKey } from "../core";
-import { AccountAuthenticator } from "../transactions/authenticator/account";
 import {
   AnyRawTransaction,
-  InputFeePayerTransaction,
-  InputGenerateMultiAgentRawTransactionData,
-  InputGenerateTransactionData,
-  InputGenerateFeePayerRawTransactionData,
-  InputGenerateSingleSignerRawTransactionData,
-  InputMultiAgentTransaction,
-  InputSingleSignerTransaction,
-  InputSimulateTransactionData,
+  SingleSignerTransaction,
   InputGenerateTransactionOptions,
-  InputSubmitTransactionData,
+  InputGenerateTransactionPayloadData,
 } from "../transactions/types";
-import { UserTransactionResponse, PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
-import {
-  generateTransaction,
-  publicPackageTransaction,
-  rotateAuthKey,
-  signAndSubmitTransaction,
-  signTransaction,
-  simulateTransaction,
-  submitTransaction,
-} from "../internal/transactionSubmission";
+import { PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
+import { publicPackageTransaction, rotateAuthKey, signAndSubmitTransaction } from "../internal/transactionSubmission";
+import { TransactionWorker } from "../transactions/management";
 
 export class TransactionSubmission {
   readonly config: AptosConfig;
@@ -36,121 +21,39 @@ export class TransactionSubmission {
   }
 
   /**
-   * We are defining function signatures, each with its specific input and output.
-   * These are the possible function signature for `generateTransaction` function.
-   * When we call `generateTransaction` function with the relevant type properties,
-   * Typescript can infer the return type based on the appropriate function overload.
-   */
-  async generateTransaction(args: InputGenerateSingleSignerRawTransactionData): Promise<InputSingleSignerTransaction>;
-  async generateTransaction(args: InputGenerateFeePayerRawTransactionData): Promise<InputFeePayerTransaction>;
-  async generateTransaction(args: InputGenerateMultiAgentRawTransactionData): Promise<InputMultiAgentTransaction>;
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction>;
-
-  /**
-   * Generates any transaction by passing in the required arguments
+   * Batch transactions for a single account.
    *
-   * @param args.sender The transaction sender's account address as a AccountAddressInput
-   * @param args.data EntryFunctionData | ScriptData | MultiSigData
-   * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction
-   * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions
-   * @param args.options optional. GenerateTransactionOptions type
+   * This function uses a transaction worker that receives payloads to be processed
+   * and submitted to chain.
+   * Note that this process is best for submitting multiple transactions that
+   * dont rely on each other, i.e batch funds, batch token mints, etc.
    *
-   * @example
-   * For a single signer entry function
-   * move function name, move function type arguments, move function arguments
-   * `
-   * data: {
-   *  function: "0x1::aptos_account::transfer",
-   *  typeArguments: []
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * `
+   * If any worker failure, the functions throws an error.
    *
-   * @example
-   * For a single signer script function
-   * module bytecode, move function type arguments, move function arguments
-   * ```
-   * data: {
-   *  bytecode: "0x001234567",
-   *  typeArguments: [],
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * ```
+   * @param args.sender The sender account to sign and submit the transaction
+   * @param args.data An array of transaction payloads
+   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
    *
-   * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses? : Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
+   * @return void. Throws if any error
    */
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction> {
-    return generateTransaction({ aptosConfig: this.config, ...args });
-  }
+  async batchTransactionsForSingleAccount(args: {
+    sender: Account;
+    data: InputGenerateTransactionPayloadData[];
+    options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
+  }): Promise<void> {
+    try {
+      const { sender, data, options } = args;
+      const transactionWorker = new TransactionWorker(this.config, sender);
 
-  /**
-   * Sign a transaction that can later be submitted to chain
-   *
-   * @param args.signer The signer account to sign the transaction
-   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * @param args.asFeePayer optional. If the signer is also the fee payer
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses?: Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
-   *
-   * @return The signer AccountAuthenticator
-   */
-  /* eslint-disable class-methods-use-this */
-  signTransaction(args: {
-    signer: Account;
-    transaction: AnyRawTransaction;
-    asFeePayer?: boolean;
-  }): AccountAuthenticator {
-    const { signer, transaction, asFeePayer } = args;
+      transactionWorker.start();
 
-    // Account can only sign as fee payer if it's a fee payer transaction
-    if ("feePayerAddress" in transaction && asFeePayer) {
-      transaction.feePayerAddress = signer.accountAddress;
-    } else if (asFeePayer) {
-      throw new Error("Transaction being signed is not a Fee payer transaction, but `asFeePayer` is set to true");
+      for (const d of data) {
+        /* eslint-disable no-await-in-loop */
+        await transactionWorker.push(d, options);
+      }
+    } catch (error: any) {
+      throw new Error(`failed to submit transactions with error: ${error}`);
     }
-
-    return signTransaction({
-      signer,
-      transaction,
-    });
-  }
-
-  /**
-   * Simulates a transaction before singing it.
-   *
-   * @param args.signerPublicKey The signer public key
-   * @param args.transaction The raw transaction to simulate
-   * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
-   * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
-   * @param args.options optional. A config to simulate the transaction with
-   */
-  async simulateTransaction(args: InputSimulateTransactionData): Promise<Array<UserTransactionResponse>> {
-    return simulateTransaction({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Submit transaction to chain
-   *
-   * @param args.transaction A aptos transaction type
-   * @param args.senderAuthenticator The account authenticator of the transaction sender
-   * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
-   *
-   * @return PendingTransactionResponse
-   */
-  async submitTransaction(args: InputSubmitTransactionData): Promise<PendingTransactionResponse> {
-    return submitTransaction({ aptosConfig: this.config, ...args });
   }
 
   /**
@@ -198,7 +101,7 @@ export class TransactionSubmission {
     metadataBytes: HexInput;
     moduleBytecode: Array<HexInput>;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
 

package/src/api/utils.ts

@@ -0,0 +1,37 @@
+import { waitForIndexer } from "../internal/transaction";
+import { ProcessorType } from "../utils";
+import { AptosConfig } from "./aptosConfig";
+import { AnyNumber } from "../types";
+
+/**
+ * Utility function to handle optional waiting on indexer for APIs
+ *
+ * This is purposely placed here to not expose this internal function.
+ * @param args
+ */
+export async function waitForIndexerOnVersion(args: {
+  config: AptosConfig;
+  minimumLedgerVersion?: AnyNumber;
+  processorTypes: Array<ProcessorType>;
+}) {
+  if (args.minimumLedgerVersion !== undefined) {
+    // eslint-disable-next-line no-restricted-syntax
+
+    // Collect all of the promises to wait at the same time
+    // TODO(greg): This needs to be refactored to be handled at the query time.  It involves rewriting
+    // a bunch of the logic for wait for indexer
+    const promises: Array<Promise<void>> = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const processorType of args.processorTypes) {
+      promises.push(
+        waitForIndexer({
+          aptosConfig: args.config,
+          minimumLedgerVersion: args.minimumLedgerVersion,
+          processorType,
+        }),
+      );
+    }
+
+    await Promise.all(promises);
+  }
+}

package/src/bcs/deserializer.ts

@@ -222,10 +222,10 @@ export class Deserializer {
    * @example
    * // serialize a vector of addresses
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromRelaxed("0x1"),
-   *   AccountAddress.fromRelaxed("0x2"),
-   *   AccountAddress.fromRelaxed("0xa"),
-   *   AccountAddress.fromRelaxed("0xb"),
+   *   AccountAddress.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);

package/src/bcs/serializer.ts

@@ -298,10 +298,10 @@ export class Serializer {
    * @param values The array of BCS Serializable values
    * @example
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromRelaxed("0x1"),
-   *   AccountAddress.fromRelaxed("0x2"),
-   *   AccountAddress.fromRelaxed("0xa"),
-   *   AccountAddress.fromRelaxed("0xb"),
+   *   AccountAddress.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);