JFWooten4
diff --git a/‎docs/build/guides/transactions/channel-accounts.mdx‎
Lines changed: 991 additions & 0 deletions b/‎docs/build/guides/transactions/channel-accounts.mdx‎
Lines changed: 991 additions & 0 deletions
diff --git a/‎docs/build/guides/transactions/claimable-balances.mdx‎
Lines changed: 588 additions & 0 deletions b/‎docs/build/guides/transactions/claimable-balances.mdx‎
Lines changed: 588 additions & 0 deletions
diff --git a/‎docs/build/guides/transactions/clawbacks.mdx‎
Lines changed: 1190 additions & 0 deletions b/‎docs/build/guides/transactions/clawbacks.mdx‎
Lines changed: 1190 additions & 0 deletions
diff --git a/‎docs/build/guides/transactions/path-payments.mdx‎
Lines changed: 161 additions & 0 deletions b/‎docs/build/guides/transactions/path-payments.mdx‎
Lines changed: 161 additions & 0 deletions
diff --git a/‎docs/data/apis/horizon/api-reference/structure/README.mdx‎
Lines changed: 14 additions & 2 deletions b/‎docs/data/apis/horizon/api-reference/structure/README.mdx‎
Lines changed: 14 additions & 2 deletions
diff --git a/‎docs/data/apis/rpc/api-reference/methods/getLedgerEntries.mdx‎
Lines changed: 196 additions & 0 deletions b/‎docs/data/apis/rpc/api-reference/methods/getLedgerEntries.mdx‎
Lines changed: 196 additions & 0 deletions
@@ -0,0 +1,161 @@
+---
+title: Path payments
+sidebar_position: 60
+description: Send a payment where the asset received differs from the asset sent.
+---
+
+path p ayments let [accounts](../../fundamentals/stellar-data-structures/accounts.mdx) send one asset to a recipeint , whoi receiveds a differnt asset. The secure conversion takes advantagfe of the netowrk's [natie liquidity](../sdex/README.mdx) to ewxchange using istant avaliable trades.
+
+The [operations](../../fundamentals/transactions/operations-and-transactions.mdx#operations) specify a minimum amount which the market must meet or excceed. For instance, if you send 10 bananas and rquire a receiver to get at last 15 appleess, then the trahsfer will seek the best exxchange at or above 1.5 each.
+
+TRhis let accoutns transfer value without mandating a single universal currency. You converting one asset ito another at the point of transferring value.
+
+## Routign logic
+
+Pay payments use [the DEX](../sdex/liquidity-on-stellar-sdex-liquidity-pools.mdx#orderbook) or [AMM pools](../sdex/liquidity-on-stellar-sdex-liquidity-pools.mdx#amms) whcih standy readyt t oswap assets at the time of a trnasaction. They cna only consume existing liquidity by drawing on offers previously posted.
+
+Tje tramsfer suicceeds oiF nd only if there's enough eavlaible interest in the [ledger](../../fundamentals/stellar-data-structures/ledgers.mdx) submitted, at the minimum rate. Without this liquiddyty, the cohnversion fails and returns an [errro code](../../../data/apis/horizon/api-reference/errors/README.mdx).
+
+To prepatre for
+
+#### Path Hops
+
+When sending path payments, your transfer can hop between up to six order books or AMMs to find the best price.
+
+Validators perform this arithmatic automatically, allowing you to specify only the lowest total amount you will accept.
+
+At each step in the path, the network calculates the optimal source of liquidity to convert through given your destination asset.
+
+Both the order book and AMMs coexist, providing multiple avenues for liquidity.
+
+Instead of having to choose whether to go through the order book or an AMM, the pathfinding algorithm automatically checks both sources of liquidity and executes new trades using whichever offers the better rate.
+
+It also exchanges with an AMM over an order book at each step if the entire conversation happens at a price equal to or better than limit offers.
+
+## paths {#pathfinding}
+
+[s](../../../data/apis/horizon/api-reference/aggregations/paths/README.mdx) when you call this ou;ll notice differnt `soruce_amoutns` in /data/apis/horizon/api-reference/list-strict-receive-payment-paths or differnt `destination_amount` in docs/data/apis/horizon/api-reference/list-strict-send-payment-paths
+
+### Converting Path Paymtns
+
+offers or AMMs which convert to a minimum specified amount or better.
+
+Transfers automatically use up to six different orderbooks to get the best price, as fully defined in [the Encyclopedia page here] .
+
+Some assets will have a small or nonexistent order book between them. In these cases, Stellar facilitates path payments, which we’ll discuss later.
+
+### Atomicity
+
+payh maymentn operations take adntage of every teerasnaction's exclusive ability to [succeed i n full](../../../fundamentals/transactions/operations-and-transactions) or fail.
+
+This means that your transfer off 10 or more AstroDollars will not
+
+In a path payment, the asset received differs from the asset sent. Rather than the operation transferring assets directly from one account to another, path payments cross through
+
+before arriving at the destination account.
+
+For the path payment to succeed, there has to be enough liquidity path in existence. Conversions can take up to six independent hops to succeed at the best avaliable price.
+
+### Example
+
+Account A sells XLM → [buy XLM / sell ETH → buy ETH / sell BTC → buy BTC / sell USDC] → Account B receives USDC {/* Image suggester here in #944 */}
+
+It is possible for path payments to fail if there are no viable exchange paths.
+
+## Path payments - more info
+
+- Path payments don’t allow intermediate offers to be from the source account as this would yield a worse exchange rate. You’ll need to either split the path payment into two smaller path payments or ensure that the source account’s offers are not at the top of the order book.
+- Balances are settled at the very end of the operation.
+  - This is especially important when (`Destination, Destination Asset) == (Source, Send Asset`) as this provides a functionality equivalent to getting a no-interest loan for the duration of the operation.
+- `Destination min` is a protective measure, it allows you to specify a lower bound for an acceptable conversion. If offers in the order books are not favorable enough for the operation to deliver that amount, the operation will fail.
+
+## Operations
+
+Path payments use the Path Payment Strict Send or Path Payment Strict Receive operations.
+
+### Path Payment Strict Send
+
+[errors](../../../data/apis/horizon/api-reference/errors/result-codes/operation-specific/path-payment-strict-send.mdx) Allows a user to specify the amount of the asset to send. The amount received will vary based on offers in the order books and/or liquidity pools.
+
+https://developers.stellar.org/docs/learn/fundamentals/transactions/list-of-operations#path-payment-strict-send
+
+### Path Payment Strict Receive
+
+[errors](../../../data/apis/horizon/api-reference/errors/result-codes/operation-specific/path-payment-strict-receive.mdx) Allows a user to specify the amount of the asset received. The amount sent will vary based on the offers in the order books/liquidity pools.
+
+## Example
+
+First, ensure the receiver has a trustline established for the asset they will receive. In this example, we will use USDC as the asset received. The sender will send XLM, which will be converted to USDC through the path payment operation.
+
+```js
+import {
+  Horizon,
+  Asset,
+  Keypair,
+  TransactionBuilder,
+  Networks,
+  BASE_FEE,
+  Operation,
+  Memo,
+} from "@stellar/stellar-sdk";
+
+const USDC_ISSUER = "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5"; // USDC issuer on Stellar Testnet
+const USDC_ASSET = new Asset("USDC", USDC_ISSUER); // USDC asset on Stellar Testnet
+const RECEIVER_SECRET = "S..."; // Receiver's secret key
+
+const SENDER_SECRET = "S..."; // Sender's secret key
+const horizonServer = new Horizon.Server("https://horizon-testnet.stellar.org");
+
+// Create a USDC trustline for the receiver
+const receiverKP = Keypair.fromSecret(RECEIVER_SECRET);
+let account = await horizonServer.loadAccount(receiverKP.publicKey());
+let transaction = new TransactionBuilder(account, {
+  fee: BASE_FEE * 100,
+  networkPassphrase: Networks.TESTNET,
+})
+  .addOperation(
+    Operation.changeTrust({
+      asset: USDC_ASSET,
+      limit: "10",
+    }),
+  )
+  .addMemo(Memo.text("Trusting USDC"))
+  .setTimeout(30)
+  .build();
+
+transaction.sign(receiverKP);
+const resp = await SERVER.submitTransaction(transaction);
+console.log("resp", resp);
+```
+
+Now let's send a path payment from the sender to the receiver, converting XLM to USDC.
+
+```js
+// Use path payment to send XLM from the receiver to the sender, who receives USDC
+let senderKP = Keypair.fromSecret(SENDER_SECRET);
+let account = await horizonServer.loadAccount(senderKP.publicKey());
+let transaction = new TransactionBuilder(account, {
+  fee: BASE_FEE * 100,
+  networkPassphrase: Networks.TESTNET,
+})
+  .addOperation(
+    Operation.pathPaymentStrictReceive({
+      sendAsset: Asset.native(), // Sending XLM
+      sendMax: "10", // Maximum amount of XLM to send
+      destAsset: USDC_ASSET, // Receiving USDC
+      destAmount: "1", // Amount of USDC to receive
+      destination: receiverKP.publicKey(), // Receiver's public key
+    }),
+  )
+  .addMemo(Memo.text("XLM to USDC"))
+  .setTimeout(30)
+  .build();
+
+transaction.sign(senderKP);
+const resp = await horizonServer.submitTransaction(transaction);
+console.log("resp", resp);
+```
+
+https://developers.stellar.org/docs/learn/fundamentals/transactions/list-of-operations#path-payment-strict-receive
+
+also we need to clairfy chanign API v openApia which si from #991 docs/data/apis/horizon/api-reference/structure/response-format.mdx#L170 \_contra- openapi/horizon/components/examples/responses/Offers/GetAllOffers.yml#L28 ++ openapi/horizon/components/examples/responses/Offers/GetAllOffers.yml#L28
@@ -5,8 +5,20 @@ sidebar_label: Structure
 description: Horizon is an API for interacting with the Stellar network.
 ---
 
-import DocCardList from "@theme/DocCardList";
+import { MethodTable } from "@site/src/components/MethodTable";
 
 How Horizon is structured.
 
-<DocCardList />
+<MethodTable title="Structure Types">
+
+|                                                   |     |
+| ------------------------------------------------- | --- |
+| [Response Format](./response-format.mdx)          |     |
+| [Page Arguments](./pagination/page-arguments.mdx) |     |
+| [Streaming](./streaming.mdx)                      |     |
+| [Rate Limiting](./rate-limiting.mdx)              |     |
+| [XDR](./xdr.mdx)                                  |     |
+| [Consistency](./consistency.mdx)                  |     |
+| [Pagination](./pagination/README.mdx)             |     |
+
+</MethodTable>
@@ -335,6 +335,202 @@ switch (AMM.switch().value) {
 
 </CodeExample>
 
+### Offers
+
+An offer represents a live order on the DEX. Each offer is identified by its `offerID`. To construct a `LedgerKey` for an offer, you only need the offer ID:
+
+<CodeExample>
+
+```typescript
+const offerLedgerKey = xdr.LedgerKey.ledgerKeyOffer(
+  new xdr.LedgerKeyOffer({
+    offerID: 123456789n,
+  }),
+);
+console.log(offerLedgerKey.toXDR("base64"));
+```
+
+</CodeExample>
+
+Once you have the ledger entry, you can extract its fields:
+
+<CodeExample>
+
+```typescript
+const offerEntryData = (
+  await s.getLedgerEntries(offerLedgerKey)
+).entries[0].offer();
+
+console.log(`Offer ID: ${offerEntryData.offerId().toString()}`);
+console.log(`Seller: ${offerEntryData.sellerId().accountId()}`);
+console.log(`Amount: ${offerEntryData.amount().toString()}`); // of selling
+console.log(
+  `Price: ${offerEntryData.price().n().toString()} / ${offerEntryData.price().d().toString()}`,
+);
+```
+
+</CodeExample>
+
+You can then decode the selling and buying assets the same way you do for Trustlines, by inspecting `offerEntryData.selling()` and `offerEntryData.buying()` using the standard `xdr.Asset` parsing logic.
+
+### Claimable Balances
+
+A claimable balance represents assets that have been locked under certain claim conditions. Each claimable balance is identified by its `balanceId`, which is a 32-byte hash.
+
+To construct a `LedgerKey` for a claimable balance, you need the `balanceId` as a `Buffer` or `Uint8Array`:
+
+<CodeExample>
+
+```typescript
+const balanceIdHex =
+  "407a334017a508fb2bf41952c74f977b46147ed70b175717f8bacc0ca3f2cc5b";
+const balanceIdBytes = Buffer.from(balanceIdHex, "hex");
+
+const claimableBalanceLedgerKey = xdr.LedgerKey.ledgerKeyClaimableBalance(
+  new xdr.LedgerKeyClaimableBalance({
+    balanceID: xdr.ClaimableBalanceID.claimableBalanceIdTypeV0(balanceIdBytes),
+  }),
+);
+console.log(claimableBalanceLedgerKey.toXDR("base64"));
+```
+
+</CodeExample>
+
+Once you have the ledger entry, you can extract its fields:
+
+<CodeExample>
+
+```typescript
+const claimableBalanceEntryData = (
+  await s.getLedgerEntries(claimableBalanceLedgerKey)
+).entries[0].claimableBalance();
+
+console.log(`Amount: ${claimableBalanceEntryData.amount().toString()} stroops`);
+
+const asset = claimableBalanceEntryData.asset();
+// Decode asset similar to as in trustlines
+
+const claimants = claimableBalanceEntryData.claimants();
+
+if (claimableBalanceEntryData.ext().switch().value === 1) {
+  const flags = claimableBalanceEntryData.ext().v1().flags();
+  const clawbackEnabled =
+    (flags &
+      xdr.ClaimableBalanceFlags.claimableBalanceClawbackEnabledFlag()) !==
+    0;
+  console.log(`Clawback Enabled: ${clawbackEnabled}`);
+}
+```
+
+</CodeExample>
+
+#### Claimants and Predicates
+
+Claimable balances contain one or more claimants, each with a claim predicate. You can iterate through them as follows:
+
+<CodeExample>
+
+```typescript
+for (let i = 0; i < claimants.length; i++) {
+  const claimant = claimants[i].v0();
+  const destination = claimant.destination().accountId();
+  console.log(`Claimant ${i + 1}: ${destination}`);
+
+  const predicate = claimant.predicate();
+  const predicateType = predicate.switch().value;
+
+  switch (predicateType) {
+    case xdr.ClaimPredicateType.claimPredicateUnconditional().value:
+      console.log("Predicate: Unconditional");
+      break;
+    case xdr.ClaimPredicateType.claimPredicateBeforeAbsoluteTime().value:
+      console.log(`Predicate: Before Absolute Time = ${predicate.absBefore().toString()}`);
+      break;
+    case xdr.ClaimPredicateType.claimPredicateBeforeRelativeTime().value:
+      console.log(`Predicate: Before Relative Time = ${predicate.relBefore().toString()} seconds`);
+      break;
+    default:
+      console.log("Predicate: Complex predicate type (AND/OR/NOT)");
+      break;
+}
+```
+
+</CodeExample>
+
+#### Flags
+
+If the claimable balance has flags set (not `v0`), you can read them like this:
+
+<CodeExample>
+
+```typescript
+switch (claimableBalanceEntryData.ext().switch().value) {
+  case 0: // No flags
+    break;
+  case 1:
+    const flags = claimableBalanceEntryData.ext().v1().flags();
+    const clawbackEnabled = (flags & 1) !== 0; // claw = 0x1
+    console.log(`Clawback Enabled: ${clawbackEnabled}`);
+    break;
+}
+```
+
+</CodeExample>
+
+### Liquidity Pools
+
+A liquidity pool represents an Automated Market Maker holding two assets. Each liquidity pool is identified by its `liquidityPoolID`, which is a 32-byte hash.
+
+To construct a `LedgerKey` for an AMM, you need the liquidity-pool ID as a `Buffer` or `Uint8Array`. Core deterministicly stores this as a 64-char hex string.
+
+<CodeExample>
+
+```typescript
+const liquidityPoolIdHex =
+  "82f857462d5304e1ad7d5308fb6d90ff3e70ad8fb07b81d04b12d2cc867fc735";
+const liquidityPoolIdBytes = Buffer.from(liquidityPoolIdHex, "hex");
+
+const liquidityPoolLedgerKey = xdr.LedgerKey.ledgerKeyLiquidityPool(
+  new xdr.LedgerKeyLiquidityPool({
+    liquidityPoolID: liquidityPoolIdBytes,
+  }),
+);
+console.log(liquidityPoolLedgerKey.toXDR("base64"));
+```
+
+</CodeExample>
+
+Once you have the ledger entry, you can extract its fields:
+
+<CodeExample>
+
+```typescript
+const liquidityPoolEntryData = (
+  await s.getLedgerEntries(liquidityPoolLedgerKey)
+).entries[0].liquidityPool();
+
+console.log(
+  `Total Pool Shares: ${liquidityPoolEntryData.totalPoolShares().toString()}`,
+);
+console.log(
+  `Total Trustlines: ${liquidityPoolEntryData.poolSharesTrustLineCount().toString()}`,
+);
+
+const AMM = liquidityPoolEntryData.body();
+switch (AMM.switch().value) {
+  case xdr.LiquidityPoolType.liquidityPoolConstantProduct().value: {
+    const params = AMM.constantProduct().params();
+    const fee = params.fee(); // basis points
+    const assetA = params.assetA();
+    const assetB = params.assetB();
+    console.log(`Constant-Product Between: ${assetA} and ${assetB}`);
+    break;
+  }
+}
+```
+
+</CodeExample>
+
 ### Contract Data
 
 Suppose we've deployed the [`increment` example contract] and want to find out what value is stored in the `COUNTER` ledger key. To build the key: