---
title: "SWQoS के लिए Durable Nonce fan-out"
description: "web3.js के साथ Durable Nonce account सेटअप और SWQoS fan-out भेजना"
canonical: "https://erpc.global/hi/doc/rpc/durable-nonce-send-transaction/"
locale: "hi"
---

# SWQoS के लिए Durable Nonce fan-out

## पृष्ठभूमि और उपयोग का परिदृश्य

Solana में transaction भेजते समय, slot का आगे बढ़ना, leader की स्थिति और नेटवर्क पाथ की भीड़ लगातार यह बदलते रहते हैं कि कौन-सा रास्ता leader तक सबसे तेज़ पहुँचेगा। यह किसी एक RPC प्रदाता या भेजने वाली सेवा तक सीमित नहीं है; यह Solana के execution मॉडल की एक संरचनात्मक विशेषता है।

ERPC का SWQoS endpoint भेजने का एक ऐसा रास्ता देता है जो transactions को उस priority lane में डालता है जिसे leaders, Stake-weighted Quality of Service (SWQoS) के आधार पर आवंटित करते हैं। यह priority bandwidth non-priority lane की लगभग 5 गुना है और priority fee के मूल्यांकन से पहले लागू होती है।

इसी कारण, transaction भेजने के लिए SWQoS endpoint एक महत्वपूर्ण विकल्प है, लेकिन production में कोई एक endpoint हमेशा सबसे तेज़ नहीं होता। एक ही slot के भीतर भी, पाथ में अस्थायी अंतर या लोड का असंतुलन किसी दूसरे तेज़ endpoint को आगे निकलने दे सकता है।

इन विशेषताओं को देखते हुए, एक ही रास्ते पर निर्भर रहने के बजाय, एक ही transaction को कई तेज़ रास्तों पर समानांतर रूप से भेजना और सबसे पहले process होने वाले को स्वीकार करना एक प्रभावी operational पैटर्न हो सकता है।

लेकिन जब एक ही transaction कई endpoints पर भेजा जाता है, तो अतिरिक्त नियंत्रण के बिना आप यह गारंटी नहीं दे सकते कि वह केवल एक बार execute होगा। इस नियंत्रण के बिना किया गया fan-out अनचाहे double execution या बिगड़े हुए retry नियंत्रण का कारण बन सकता है।

Solana इसके लिए Durable Nonce नाम का तंत्र देता है। Durable Nonce के साथ आप एक ही signed transaction को कई रास्तों से भेज सकते हैं, जबकि on-chain execution एक ही बार तक सीमित रहता है।

यह पेज बताता है कि Durable Nonce के साथ transaction भेजने को आधार मानकर, ERPC के SWQoS endpoint को दूसरे तेज़ RPC endpoints के साथ जोड़ने वाले fan-out operations कैसे लागू करें।

---

## दायरा और पूर्व-आवश्यकताएँ

यह गाइड web3.js के साथ Durable Nonce account बनाने और उसे transaction भेजने तथा fan-out operations में इस्तेमाल करने को कवर करती है।

समझने के लिए पूर्व-आवश्यकताएँ:

- Durable Nonce transactions के लिए nonce मान को `recentBlockhash` के रूप में इस्तेमाल करें और `nonceAdvance` को पहले instruction के रूप में रखें
- `nonceAdvance` के execute होते ही, बाद के instructions विफल होने पर भी nonce खर्च हो सकता है। आप उसी rawTx को जैसा का तैसा दोबारा नहीं भेज सकते।
- Nonce account बनाना एक बार का सेटअप है और आम तौर पर उसे दोबारा इस्तेमाल किया जाता है

---

## चरण 1: nonce authority और connection तैयार करें

Nonce authority एक Keypair है जो nonce को आगे बढ़ा सकता है।

```ts
import {
  Connection,
  Keypair,
  SystemProgram,
  NONCE_ACCOUNT_LENGTH,
} from '@solana/web3.js'

const connection = new Connection('https://<primary-rpc-endpoint>', 'confirmed')

const nonceAuthority = Keypair.fromSecretKey(/* secret key */)
```

- Nonce authority `nonceAdvance` execute कर सकता है
- यह fee payer भी हो सकता है, या कोई अलग keypair

---

## चरण 2: nonce account का Keypair बनाएँ

Nonce account एक **System Account** होता है।

```ts
const nonceAccount = Keypair.generate()
```

यह Keypair इनके लिए इस्तेमाल होता है:

- nonce मान रखना (`recentBlockhash` की जगह)
- केवल बनाते समय sign करना
- उसके बाद सुरक्षित रखना; रोज़ाना भेजने के लिए इसकी ज़रूरत नहीं होती

---

## चरण 3: rent-exempt न्यूनतम राशि की गणना करें

Nonce accounts का rent-exempt होना ज़रूरी है। मानों को hardcode न करें; उन्हें RPC से प्राप्त करें।

```ts
const lamports =
  await connection.getMinimumBalanceForRentExemption(NONCE_ACCOUNT_LENGTH)
```

---

## चरण 4: nonce account बनाएँ और initialize करें

Nonce account को एक ही transaction में **createAccount + nonceInitialize** के साथ बनाएँ।

```ts
import { Transaction } from '@solana/web3.js'

const tx = new Transaction()

tx.add(
  SystemProgram.createAccount({
    fromPubkey: nonceAuthority.publicKey,
    newAccountPubkey: nonceAccount.publicKey,
    lamports,
    space: NONCE_ACCOUNT_LENGTH,
    programId: SystemProgram.programId,
  }),
  SystemProgram.nonceInitialize({
    noncePubkey: nonceAccount.publicKey,
    authorizedPubkey: nonceAuthority.publicKey,
  }),
)

// fee payer is the nonce authority
tx.feePayer = nonceAuthority.publicKey

// use a normal blockhash for initialization
const { blockhash, lastValidBlockHeight } =
  await connection.getLatestBlockhash('confirmed')

tx.recentBlockhash = blockhash

// sign with both the new account and the authority
tx.sign(nonceAccount, nonceAuthority)

const signature = await connection.sendRawTransaction(tx.serialize())
await connection.confirmTransaction(
  { signature, blockhash, lastValidBlockHeight },
  'confirmed',
)
```

आगे भेजे जाने वाले transactions के लिए इसी `nonceAccount.publicKey` का इस्तेमाल करें।

---

## चरण 5: हर बार भेजने से पहले nonce प्राप्त करें

हर transaction के लिए मौजूदा nonce मान प्राप्त करें।

```ts
import { NonceAccount } from '@solana/web3.js'

const { value, context } = await connection.getAccountInfoAndContext(
  nonceAccount.publicKey,
  'confirmed',
)

if (!value) {
  throw new Error('Nonce account not found')
}

const nonce = NonceAccount.fromAccountData(value.data).nonce
const minContextSlot = context.slot
```

- `nonce` को `recentBlockhash` के रूप में इस्तेमाल करें
- `context.slot` का इस्तेमाल confirmation में होता है

---

## चरण 6: Durable Nonce transaction बनाएँ

Durable Nonce transactions को ये शर्तें पूरी करनी होंगी:

- `recentBlockhash = nonce`
- पहला instruction `nonceAdvance` है

```ts
import { TransactionMessage, VersionedTransaction } from '@solana/web3.js'

const instructions = [
  SystemProgram.nonceAdvance({
    noncePubkey: nonceAccount.publicKey,
    authorizedPubkey: nonceAuthority.publicKey,
  }),
  // add your real instructions after this
]

const message = new TransactionMessage({
  payerKey: nonceAuthority.publicKey,
  recentBlockhash: nonce,
  instructions,
}).compileToV0Message()

const tx = new VersionedTransaction(message)
tx.sign([nonceAuthority /* + other signers */])

const rawTx = tx.serialize()
```

नोट्स:

- अगर आप ComputeBudget instructions इस्तेमाल करते हैं, तो वे `nonceAdvance` के **बाद** आने चाहिए
- अगर `nonceAdvance` पहले नहीं है, तो transaction अस्वीकार कर दिया जाएगा

---

## चरण 7: कई RPCs पर fan-out करें

उसी rawTx को एक साथ भेजें।

```ts
const endpoints = [
  'https://swqos-fra2.erpc.global?api-key=YOUR_API_KEY',
  'https://swqos-ams1.erpc.global?api-key=YOUR_API_KEY',
  'https://<backup-rpc-1>',
]

const results = await Promise.allSettled(
  endpoints.map((url) =>
    new Connection(url, 'confirmed').sendRawTransaction(rawTx, {
      skipPreflight: true,
      minContextSlot,
    }),
  ),
)

const success = results.find(
  (r): r is PromiseFulfilledResult<string> => r.status === 'fulfilled',
)

if (!success) {
  throw new Error('All sends failed')
}

const signature = success.value
```

- सभी endpoints पर signature एक ही रहता है
- सफलतापूर्वक भेज देना confirmation **नहीं** है

---

## चरण 8: Durable Nonce के साथ confirm करें

Durable Nonce में, confirmation के समय nonce की जानकारी शामिल करें।

```ts
await connection.confirmTransaction(
  {
    signature,
    nonceAccountPubkey: nonceAccount.publicKey,
    nonceValue: nonce,
    minContextSlot,
  },
  'confirmed',
)
```

अगर confirmation सफल होता है:

- nonce आगे बढ़ जाता है
- दूसरे RPCs पर भेजी गई प्रतियाँ `InvalidNonce` लौटाती हैं

---

## अगली बार भेजना

- confirmation के बाद नया nonce प्राप्त करें
- उसी rawTx या nonce मान का दोबारा इस्तेमाल न करें
- समानांतर workflows के लिए अलग-अलग nonce accounts इस्तेमाल करें

अगले transaction के लिए अपडेट किया गया nonce प्राप्त करें और उन्हीं चरणों से transaction बनाएँ।