Merge branch 'main' into main

Author: gregnazario

apps/nextra/pages/en/build/guides/_meta.tsx

@@ -37,6 +37,9 @@ export default {
   "sponsored-transactions": {
     title: "Sponsored Transactions",
   },
+  "orderless-transactions": {
+    title: "Orderless Transactions",
+  },
   "transaction-management": {
     title: "Transaction Management",
   },

apps/nextra/pages/en/build/guides/orderless-transactions.mdx

@@ -0,0 +1,36 @@
+# Orderless Transactions
+
+As outlined
+in [AIP-123](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-123.md),
+orderless transactions allow for transactions to be executed out of order, which
+is particularly useful in scenarios where multiple machines need to sign for a
+single sending account, but the order in which they sign does not affect the
+outcome of the transaction or matter to the creator.  Replay is protected by a
+nonce, which is a unique identifier for a transaction.  This allows for the
+transaction to be executed at any time within the expiration time, regardless of
+the order in which the machines sign the transaction, but not be able to be
+replayed after the nonce has expired.  The maximum expiration time is 60 seconds
+for orderless transactions, which is not the same for sequence number
+transactions.
+
+## Process Overview
+
+Orderless transactions are dependent on the transaction payload specified in
+[AIP-129](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-129.md).
+The process for building and executing an orderless transaction is as follows:
+
+1. Build a transaction with a `replayProtectionNonce` and a `TransactionPayload::TransactionPayloadPayload` that defines the operation to be executed.
+2. Sign and submit the transaction as any other transaction, but with the
+`replayProtectionNonce` set.  Ideally, the nonce should be a random u64 value.
+
+Note, that the behavior of the `replayProtectionNonce` is similar to a sequence
+number, but it does not guarantee ordered execution of transactions. Instead, it
+ensures that the transaction is unique and cannot be replayed (executed twice)
+with the same nonce.
+
+## SDK Support
+
+These are demonstrations of sponsored transactions:
+
+- The [TypeScript SDK](../sdks/ts-sdk/building-transactions/orderless-transactions.mdx) has documentation
+- The [Go SDK](https://github.com/aptos-labs/aptos-go-sdk/tree/main/examples/orderless_transaction) has an example

apps/nextra/pages/en/build/sdks/ts-sdk/building-transactions.mdx

@@ -200,8 +200,9 @@ Building and sending transactions on-chain involves the following 5 steps:
 
 Transactions have a couple of additional features which let them adapt to your needs which you can learn about here:
 
-1. [Multi-Agent Signatures](building-transactions/multi-agent-transactions.mdx) - Allowing multiple accounts to be used for a single contract.
-2. [Sponsoring Transactions](building-transactions/sponsoring-transactions.mdx) - Have another account pay gas fees for this transaction.
-3. [Batch Submit Transactions](building-transactions/batching-transactions.mdx) - How to send multiple transactions quickly from a single account.
-4. [Binary Canonical Serialization (BCS)](building-transactions/bcs-format.mdx) - The format used to serialize data for Aptos transactions.
-5. [Composing multiple Move calls with ScriptComposer](building-transactions/script-composer.mdx) - (Experimental) Building more complex transaction payload that calls into multiple Move functions dynamically.
+1. [Multi-Agent Transactions](building-transactions/multi-agent-transactions.mdx) - Allowing multiple accounts to interact with a single transaction.
+2. [Orderless Transactions](building-transactions/orderless-transactions.mdx) - Allowing for transactions to be executed out of order for easier management.
+3. [Sponsoring Transactions](building-transactions/sponsoring-transactions.mdx) - Have another account pay gas fees for this transaction.
+4. [Batch Submit Transactions](building-transactions/batching-transactions.mdx) - How to send multiple transactions quickly from a single account.
+5. [Binary Canonical Serialization (BCS)](building-transactions/bcs-format.mdx) - The format used to serialize data for Aptos transactions.
+7. [Composing multiple Move calls with ScriptComposer](building-transactions/script-composer.mdx) - (Experimental) Building more complex transaction payload that calls into multiple Move functions dynamically.

apps/nextra/pages/en/build/sdks/ts-sdk/building-transactions/_meta.tsx

@@ -5,6 +5,9 @@ export default {
   "multi-agent-transactions": {
     title: "Multi-Agent Transactions",
   },
+  "orderless-transactions": {
+    title: "Orderless Transactions",
+  },
   "sponsoring-transactions": {
     title: "Sponsoring Transactions",
   },

apps/nextra/pages/en/build/sdks/ts-sdk/building-transactions/orderless-transactions.mdx

@@ -0,0 +1,95 @@
+---
+title: "Orderless Transactions"
+---
+
+import { Callout } from 'nextra/components'
+
+# Orderless Transactions
+
+Orderless transactions allow you to create transactions that do not specify a
+order of execution between them. This is particularly useful
+in scenarios where multiple machines need to sign a transaction, but the order
+in which they sign does not affect the outcome of the transaction or matter to
+the creator.
+
+## Building Orderless Transactions
+
+Creating and executing a multi-agent transaction follows a similar flow to the
+[simple transaction flow](../building-transactions.mdx), and the
+[multi-agent transaction flow](./multi-agent-transactions.mdx).
+
+<Callout type="info">
+  Instead of providing a `sequenceNumber` (or no sequence number at all), a
+  `Replay Protection Nonce` is used to ensure that the transaction is unique and
+  cannot be replayed (i.e., executed multiple times with the same nonce).
+</Callout>
+
+For example, to create a single signer transaction that uses orderless transactions,
+specify the `nonce` in the `build.simple` method like so:
+
+```ts filename="build-a-transaction.ts"
+const transaction = await aptos.transaction.build.simple({
+  sender: sender.accountAddress,
+  data: {
+	  // All transactions on Aptos are implemented via smart contracts.
+	  function: "0x1::aptos_account::transfer",
+	  functionArguments: [destination.accountAddress, 100],
+  },
+  options: {
+    replayProtectionNonce: 12345, // This is the nonce that will be used to ensure the transaction is unique.
+  }
+});
+```
+
+Similarly, if you are building a multi-agent transaction, you can specify the
+`replayProtectionNonce` in the `build.multiAgent` method:
+
+```ts filename="build-a-transaction.ts"
+const transaction = await aptos.transaction.build.multiAgent({
+  sender: sender.accountAddress,
+  secondarySignerAddresses: [bob.accountAddress], // List of secondary signers
+  data: {
+	  // All transactions on Aptos are implemented via smart contracts.
+	  function: "0x1::aptos_account::transfer",
+	  functionArguments: [destination.accountAddress, 100],
+  },
+  options: {
+    replayProtectionNonce: 12345, // This is the nonce that will be used to ensure the transaction is unique.
+  }
+});
+```
+
+And the same if you are building a sponsored transaction, you can specify the
+`replayProtectionNonce` in the `build.multiAgent` method:
+```ts filename="build-a-transaction.ts"
+const transaction = await aptos.transaction.build.multiAgent({
+  sender: sender.accountAddress,
+  withFeePayer: true, // This indicates that the transaction will be sponsored.
+  data: {
+	  // All transactions on Aptos are implemented via smart contracts.
+	  function: "0x1::aptos_account::transfer",
+	  functionArguments: [destination.accountAddress, 100],
+  },
+  options: {
+    replayProtectionNonce: 12345, // This is the nonce that will be used to ensure the transaction is unique.
+  }
+});
+```
+
+<Callout type="info">
+  For orderless transactions, the `replayProtectionNonce` must be unique for
+  each transaction. Additionally, the expiration time of the transaction is
+  maximum 60 seconds from the time it is submitted. If the transaction is not
+  executed within that time, it will be considered expired and will not be
+  executed.
+</Callout>
+
+After that, simply follow the same steps as you would for a simple transaction:
+1. [**Simulate** the transaction (optional)](./simulating-transactions).
+2. **Sign** the transaction.
+3. **Submit** the transaction to the network.
+4. **Wait** for the transaction to be executed.
+
+### Examples
+
+* [TS SDK Example](https://github.com/aptos-labs/aptos-ts-sdk/blob/main/examples/typescript/simple_orderless_transfer.ts)

apps/nextra/pages/en/build/sdks/wallet-adapter.mdx

@@ -4,24 +4,45 @@ title: "Wallet Adapter"
 
 # Wallet Adapter
 
-The Aptos Wallet Adapter provides a single interface for Aptos dapps and Aptos wallets to communicate with each other.
+There are two wallet adapter standards in the Aptos ecosystem:
 
-For app developers, this means that you can connect to an ever-growing list of Aptos wallets with a single integration. As new wallets enter the ecosystem and integrate with the Wallet Adapter, you can support them simply by updating your Wallet Adapter version.
+1. [Aptos Wallet Adapter](#aptos-wallet-adapter) by Aptos Labs
+2. [OKX Connect](#okx-connect) by OKX
 
-For Aptos wallet providers, integrating with the Wallet Adapter allows you to be supported on a wide range of Aptos apps.
+## Aptos Wallet Adapter
 
-## For Aptos Dapps
+The Aptos Wallet Adapter by Aptos Labs provides a single interface for Aptos
+dapps and Aptos wallets to communicate with each other.
 
-Follow the [Wallet Adapter for Dapp Builders Guide](./wallet-adapter/dapp.mdx) on how to use the Wallet Adapter (via the [Wallet Adapter React package](https://github.com/aptos-labs/aptos-wallet-adapter/tree/main/packages/wallet-adapter-react)).
+For dapp developers, this means that you can connect to any Aptos wallet that is
+integrated with the Wallet Adapter without needing to write custom code for each
+wallet.  This is described in [AIP-62](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-62.md),
+which defines the Modern Wallet Standard and autodetection of wallets.
 
-## For Aptos Wallet Providers
+For Aptos wallet providers, integrating with AIP-62 means that your wallet will
+be compatible with any dapp that uses the Wallet Adapter.
 
-Follow one of these guides for how to implement a Wallet Adapter plugin that dapps can connect to:
+### For Aptos Dapps
+
+Follow the [Wallet Adapter for Dapp Builders Guide](./wallet-adapter/dapp.mdx) on how to use the
+Wallet Adapter (via the [Wallet Adapter React package](https://github.com/aptos-labs/aptos-wallet-adapter/tree/main/packages/wallet-adapter-react)).
+
+### For Aptos Wallet Providers
+
+Follow one of these guides for how to implement a Wallet Adapter plugin that
+dapps can connect to:
 
 1. For [Browser Extension Wallets](./wallet-adapter/browser-extension-wallets.mdx) (ex. [Petra](https://chromewebstore.google.com/detail/petra-aptos-wallet/ejjladinnckdgjemekebdpeokbikhfci?hl=en))
 2. For [SDK Wallets](./wallet-adapter/wallets.mdx) (ex. [AptosConnect](https://aptosconnect.app))
 
-## Reference Material
+## OKX Connect
+
+The OKX Connect adapter provides an interface for Aptos dapps to connect to OKX
+wallet and other wallets that support the OKX Connect standard.  You can find
+more information about OKX Connect for Aptos dapps in the [OKX Connect documentation](https://web3.okx.com/build/dev-docs/sdks/app-connect-aptos)
+
+
+## Other Resources
 
 - [Dapp Builder Guide](./wallet-adapter/dapp.mdx)
 - [Wallet Browser Extension Guide](./wallet-adapter/browser-extension-wallets.mdx)