From 8276ed6f1efa061e1ee349ff49f7343be38dced2 Mon Sep 17 00:00:00 2001 From: Joshua <62268199+minimalsm@users.noreply.github.com> Date: Sat, 14 Feb 2026 00:09:22 +0000 Subject: [PATCH 1/2] i18n(ur): translation import part 09 of 13 (23 files) --- .../developers/tutorials/short-abi/index.md | 585 +++++ .../index.md | 91 + .../tutorials/stealth-addr/index.md | 436 ++++ .../index.md | 314 +++ .../token-integration-checklist/index.md | 80 + .../index.md | 314 +++ .../index.md | 177 ++ .../uniswap-v2-annotated-code/index.md | 1970 +++++++++++++++++ .../tutorials/using-websockets/index.md | 245 ++ .../index.md | 300 +++ .../index.md | 204 ++ .../index.md | 199 ++ .../tutorials/yellow-paper-evm/index.md | 278 +++ public/content/translations/ur/eips/index.md | 78 + .../ur/energy-consumption/index.md | 86 + .../translations/ur/eth/supply/index.md | 80 + .../translations/ur/ethereum-forks/index.md | 663 ++++++ .../translations/ur/foundation/index.md | 33 + .../content/translations/ur/gaming/index.md | 70 + .../content/translations/ur/glossary/index.md | 505 +++++ .../translations/ur/governance/index.md | 184 ++ .../index.md | 75 + .../ur/guides/how-to-id-scam-tokens/index.md | 94 + 23 files changed, 7061 insertions(+) create mode 100644 public/content/translations/ur/developers/tutorials/short-abi/index.md create mode 100644 public/content/translations/ur/developers/tutorials/smart-contract-security-guidelines/index.md create mode 100644 public/content/translations/ur/developers/tutorials/stealth-addr/index.md create mode 100644 public/content/translations/ur/developers/tutorials/the-graph-fixing-web3-data-querying/index.md create mode 100644 public/content/translations/ur/developers/tutorials/token-integration-checklist/index.md create mode 100644 public/content/translations/ur/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md create mode 100644 public/content/translations/ur/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md create mode 100644 public/content/translations/ur/developers/tutorials/uniswap-v2-annotated-code/index.md create mode 100644 public/content/translations/ur/developers/tutorials/using-websockets/index.md create mode 100644 public/content/translations/ur/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md create mode 100644 public/content/translations/ur/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md create mode 100644 public/content/translations/ur/developers/tutorials/waffle-test-simple-smart-contract/index.md create mode 100644 public/content/translations/ur/developers/tutorials/yellow-paper-evm/index.md create mode 100644 public/content/translations/ur/eips/index.md create mode 100644 public/content/translations/ur/energy-consumption/index.md create mode 100644 public/content/translations/ur/eth/supply/index.md create mode 100644 public/content/translations/ur/ethereum-forks/index.md create mode 100644 public/content/translations/ur/foundation/index.md create mode 100644 public/content/translations/ur/gaming/index.md create mode 100644 public/content/translations/ur/glossary/index.md create mode 100644 public/content/translations/ur/governance/index.md create mode 100644 public/content/translations/ur/guides/how-to-create-an-ethereum-account/index.md create mode 100644 public/content/translations/ur/guides/how-to-id-scam-tokens/index.md diff --git a/public/content/translations/ur/developers/tutorials/short-abi/index.md b/public/content/translations/ur/developers/tutorials/short-abi/index.md new file mode 100644 index 00000000000..3f37c69fa04 --- /dev/null +++ b/public/content/translations/ur/developers/tutorials/short-abi/index.md @@ -0,0 +1,585 @@ +--- +title: "کال ڈیٹا آپٹمائزیشن کے لیے مختصر ABIs" +description: "آپٹیمسٹک رول اپس کے لیے اسمارٹ کنٹریکٹس کو آپٹمائز کرنا" +author: Ori Pomerantz +lang: ur-in +tags: [ "لیئر 2" ] +skill: intermediate +published: 2022-04-01 +--- + +## تعارف {#introduction} + +اس مضمون میں، آپ [optimistic rollups](/developers/docs/scaling/optimistic-rollups)، ان پر ٹرانزیکشنز کی لاگت، اور اس بارے میں جانیں گے کہ کس طرح یہ مختلف لاگت کا ڈھانچہ ہمیں Ethereum Mainnet کے مقابلے میں مختلف چیزوں کے لیے آپٹمائز کرنے کا تقاضا کرتا ہے۔ +آپ یہ بھی سیکھیں گے کہ اس آپٹمائزیشن کو کیسے نافذ کیا جائے۔ + +### مکمل انکشاف {#full-disclosure} + +میں [Optimism](https://www.optimism.io/) کا کل وقتی ملازم ہوں، اس لیے اس مضمون میں مثالیں Optimism پر چلیں گی۔ +تاہم، یہاں بیان کردہ تکنیک دیگر رول اپس کے لیے بھی اتنی ہی اچھی طرح کام کرنی چاہیے۔ + +### اصطلاحات {#terminology} + +رول اپس پر بحث کرتے وقت، 'لیئر 1' (L1) کی اصطلاح Mainnet، یعنی پروڈکشن Ethereum نیٹ ورک کے لیے استعمال ہوتی ہے۔ +'لیئر 2' (L2) کی اصطلاح رول اپ یا کسی دوسرے ایسے سسٹم کے لیے استعمال ہوتی ہے جو سیکیورٹی کے لیے L1 پر انحصار کرتا ہے لیکن اپنی زیادہ تر پروسیسنگ آف چین کرتا ہے۔ + +## ہم L2 ٹرانزیکشنز کی لاگت کو مزید کیسے کم کر سکتے ہیں؟ {#how-can-we-further-reduce-the-cost-of-L2-transactions} + +[آپٹیمسٹک رول اپس](/developers/docs/scaling/optimistic-rollups) کو ہر تاریخی ٹرانزیکشن کا ریکارڈ محفوظ رکھنا ہوتا ہے تاکہ کوئی بھی ان کا جائزہ لے سکے اور اس بات کی تصدیق کر سکے کہ موجودہ اسٹیٹ درست ہے۔ +Ethereum Mainnet میں ڈیٹا داخل کرنے کا سب سے سستا طریقہ اسے کال ڈیٹا کے طور پر لکھنا ہے۔ +یہ حل [Optimism](https://help.optimism.io/hc/en-us/articles/4413163242779-What-is-a-rollup-) اور [Arbitrum](https://developer.offchainlabs.com/docs/rollup_basics#intro-to-rollups) دونوں نے منتخب کیا تھا۔ + +### L2 ٹرانزیکشنز کی لاگت {#cost-of-l2-transactions} + +L2 ٹرانزیکشنز کی لاگت دو اجزاء پر مشتمل ہے: + +1. L2 پروسیسنگ، جو عام طور پر انتہائی سستی ہوتی ہے +2. L1 اسٹوریج، جو Mainnet گیس کی لاگت سے منسلک ہے + +جب میں یہ لکھ رہا ہوں، Optimism پر L2 گیس کی لاگت 0.001 [Gwei](/developers/docs/gas/#pre-london) ہے۔ +دوسری طرف، L1 گیس کی لاگت تقریباً 40 gwei ہے۔ +[آپ موجودہ قیمتیں یہاں دیکھ سکتے ہیں](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m)۔ + +کال ڈیٹا کے ایک بائٹ کی لاگت یا تو 4 گیس ہے (اگر یہ صفر ہے) یا 16 گیس ہے (اگر یہ کوئی اور قدر ہے)۔ +EVM پر سب سے مہنگے آپریشنز میں سے ایک اسٹوریج میں لکھنا ہے۔ +L2 پر اسٹوریج میں 32 بائٹ کا ورڈ لکھنے کی زیادہ سے زیادہ لاگت 22100 گیس ہے۔ فی الحال، یہ 22.1 gwei ہے۔ +لہذا اگر ہم کال ڈیٹا کا ایک صفر بائٹ بچا سکتے ہیں، تو ہم اسٹوریج میں تقریباً 200 بائٹ لکھ سکیں گے اور پھر بھی فائدے میں رہیں گے۔ + +### ABI {#the-abi} + +ٹرانزیکشنز کی بڑی اکثریت ایک بیرونی ملکیت والے اکاؤنٹ سے ایک کنٹریکٹ تک رسائی حاصل کرتی ہے۔ +زیادہ تر کنٹریکٹس Solidity میں لکھے جاتے ہیں اور اپنے ڈیٹا فیلڈ کی تشریح [ایپلیکیشن بائنری انٹرفیس (ABI)](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding) کے مطابق کرتے ہیں۔ + +تاہم، ABI کو L1 کے لیے ڈیزائن کیا گیا تھا، جہاں کال ڈیٹا کے ایک بائٹ کی لاگت تقریباً چار ریاضیاتی آپریشنز کے برابر ہے، نہ کہ L2 کے لیے جہاں کال ڈیٹا کے ایک بائٹ کی لاگت ایک ہزار سے زیادہ ریاضیاتی آپریشنز کے برابر ہے۔ +کال ڈیٹا کو اس طرح تقسیم کیا گیا ہے: + +| سیکشن | لمبائی | بائٹس | ضائع شدہ بائٹس | ضائع شدہ گیس | ضروری بائٹس | ضروری گیس | +| ------------ | -----: | ----: | -------------: | -----------: | ----------: | --------: | +| فنکشن سلیکٹر | 4 | 0-3 | 3 | 48 | 1 | 16 | +| صفر | 12 | 4-15 | 12 | 48 | 0 | 0 | +| منزل کا پتہ | 20 | 16-35 | 0 | 0 | 20 | 320 | +| رقم | 32 | 36-67 | 17 | 64 | 15 | 240 | +| کل | 68 | | | 160 | | 576 | + +وضاحت: + +- **فنکشن سلیکٹر**: کنٹریکٹ میں 256 سے کم فنکشنز ہیں، اس لیے ہم ایک بائٹ سے ان میں فرق کر سکتے ہیں۔ + یہ بائٹس عام طور پر غیر صفر ہوتے ہیں اور اس لیے ان کی [لاگت سولہ گیس](https://eips.ethereum.org/EIPS/eip-2028) ہوتی ہے۔ +- **صفر**: یہ بائٹس ہمیشہ صفر ہوتے ہیں کیونکہ بیس بائٹ کے پتے کو رکھنے کے لیے بتیس بائٹ کے ورڈ کی ضرورت نہیں ہوتی۔ + صفر رکھنے والے بائٹس کی لاگت چار گیس ہوتی ہے ([یلو پیپر دیکھیں](https://ethereum.github.io/yellowpaper/paper.pdf)، ضمیمہ G، + صفحہ 27، `G``txdatazero` کی قدر)۔ +- **رقم**: اگر ہم فرض کریں کہ اس کنٹریکٹ میں `decimals` اٹھارہ (عام قدر) ہے اور ٹوکنز کی زیادہ سے زیادہ رقم جو ہم منتقل کریں گے 1018 ہوگی، تو ہمیں 1036 کی زیادہ سے زیادہ رقم ملتی ہے۔ + 25615 > 1036، اس لیے پندرہ بائٹس کافی ہیں۔ + +L1 پر 160 گیس کا ضیاع عام طور پر نہ ہونے کے برابر ہے۔ ایک ٹرانزیکشن کی لاگت کم از کم [21,000 گیس](https://yakkomajuri.medium.com/blockchain-definition-of-the-week-ethereum-gas-2f976af774ed) ہوتی ہے، اس لیے اضافی 0.8% سے کوئی فرق نہیں پڑتا۔ +تاہم، L2 پر، چیزیں مختلف ہیں۔ ٹرانزیکشن کی تقریباً پوری لاگت اسے L1 پر لکھنا ہے۔ +ٹرانزیکشن کال ڈیٹا کے علاوہ، ٹرانزیکشن ہیڈر کے 109 بائٹس ہوتے ہیں (منزل کا پتہ، دستخط، وغیرہ)۔ +اس لیے کل لاگت `109*16+576+160=2480` ہے، اور ہم اس کا تقریباً 6.5% ضائع کر رہے ہیں۔ + +## لاگت کم کرنا جب آپ منزل کو کنٹرول نہیں کرتے {#reducing-costs-when-you-dont-control-the-destination} + +یہ فرض کرتے ہوئے کہ آپ کا منزل کے کنٹریکٹ پر کوئی کنٹرول نہیں ہے، آپ پھر بھی [اس والے](https://github.com/qbzzt/ethereum.org-20220330-shortABI) جیسا حل استعمال کر سکتے ہیں۔ +آئیے متعلقہ فائلوں کا جائزہ لیں۔ + +### Token.sol {#token-sol} + +[یہ منزل کا کنٹریکٹ ہے](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/Token.sol)۔ +یہ ایک معیاری ERC-20 کنٹریکٹ ہے، جس میں ایک اضافی خصوصیت ہے۔ +یہ `faucet` فنکشن کسی بھی صارف کو استعمال کرنے کے لیے کچھ ٹوکن حاصل کرنے دیتا ہے۔ +یہ ایک پروڈکشن ERC-20 کنٹریکٹ کو بیکار بنا دے گا، لیکن یہ زندگی کو آسان بنا دیتا ہے جب ایک ERC-20 صرف ٹیسٹنگ کی سہولت کے لیے موجود ہو۔ + +```solidity + /** + * @dev کالر کو کھیلنے کے لیے 1000 ٹوکن دیتا ہے + */ + function faucet() external { + _mint(msg.sender, 1000); + } // فنکشن faucet +``` + +### CalldataInterpreter.sol {#calldatainterpreter-sol} + +[یہ وہ کنٹریکٹ ہے جسے ٹرانزیکشنز کو مختصر کال ڈیٹا کے ساتھ کال کرنا چاہیے](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/CalldataInterpreter.sol)۔ +آئیے اس کا لائن بہ لائن جائزہ لیں۔ + +```solidity +//SPDX-License-Identifier: Unlicense +pragma solidity ^0.8.0; + + +import { OrisUselessToken } from "./Token.sol"; +``` + +ہمیں ٹوکن فنکشن کی ضرورت ہے تاکہ یہ جان سکیں کہ اسے کیسے کال کرنا ہے۔ + +```solidity +contract CalldataInterpreter { + + OrisUselessToken public immutable token; +``` + +اس ٹوکن کا پتہ جس کے لیے ہم پراکسی ہیں۔ + +```solidity + + /** + * @dev ٹوکن کا پتہ متعین کریں + * @param tokenAddr_ ERC-20 کنٹریکٹ کا پتہ + */ + constructor( + address tokenAddr_ + ) { + token = OrisUselessToken(tokenAddr_); + } // constructor +``` + +ٹوکن کا پتہ ہی واحد پیرامیٹر ہے جسے ہمیں متعین کرنے کی ضرورت ہے۔ + +```solidity + function calldataVal(uint startByte, uint length) + private pure returns (uint) { +``` + +کال ڈیٹا سے ایک قدر پڑھیں۔ + +```solidity + uint _retVal; + + require(length < 0x21, + "calldataVal لمبائی کی حد 32 بائٹس ہے"); + + require(length + startByte <= msg.data.length, + "calldataVal کال ڈیٹا سائز سے آگے پڑھنے کی کوشش کر رہا ہے"); +``` + +ہم میموری میں ایک 32-بائٹ (256-بٹ) ورڈ لوڈ کرنے جا رہے ہیں اور ان بائٹس کو ہٹانے جا رہے ہیں جو اس فیلڈ کا حصہ نہیں ہیں جسے ہم چاہتے ہیں۔ +یہ الگورتھم 32 بائٹس سے لمبی قدروں کے لیے کام نہیں کرتا، اور یقیناً ہم کال ڈیٹا کے آخر سے آگے نہیں پڑھ سکتے۔ +L1 پر گیس بچانے کے لیے ان ٹیسٹوں کو چھوڑنا ضروری ہو سکتا ہے، لیکن L2 پر گیس انتہائی سستی ہے، جو ہمارے ذہن میں آنے والے کسی بھی قسم کے سیفٹی چیکس کو ممکن بناتی ہے۔ + +```solidity + assembly { + _retVal := calldataload(startByte) + } +``` + +ہم `fallback()` (نیچے دیکھیں) کی کال سے ڈیٹا کاپی کر سکتے تھے، لیکن [Yul](https://docs.soliditylang.org/en/v0.8.12/yul.html) کا استعمال کرنا آسان ہے، جو EVM کی اسمبلی لینگویج ہے۔ + +یہاں ہم [CALLDATALOAD opcode](https://www.evm.codes/#35) کا استعمال کرتے ہیں تاکہ بائٹس `startByte` سے `startByte+31` کو اسٹیک میں پڑھ سکیں۔ +عام طور پر، Yul میں ایک opcode کا نحو یہ ہے `(,...)` + +```solidity + + _retVal = _retVal >> (256-length*8); +``` + +صرف سب سے اہم `length` بائٹس فیلڈ کا حصہ ہیں، اس لیے ہم دوسری قدروں سے چھٹکارا پانے کے لیے [رائٹ-شفٹ](https://en.wikipedia.org/wiki/Logical_shift) کرتے ہیں۔ +اس کا اضافی فائدہ یہ ہے کہ یہ قدر کو فیلڈ کے دائیں طرف منتقل کر دیتا ہے، لہذا یہ خود قدر ہے بجائے اس کے کہ قدر کو 256کچھ سے ضرب دیا جائے۔ + +```solidity + + return _retVal; + } + + + fallback() external { +``` + +جب ایک Solidity کنٹریکٹ کو کی گئی کال کسی بھی فنکشن کے دستخط سے مماثل نہیں ہوتی ہے، تو یہ [the `fallback()` function](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) کو کال کرتی ہے (یہ فرض کرتے ہوئے کہ کوئی موجود ہے)۔ +`CalldataInterpreter` کے معاملے میں، _کوئی بھی_ کال یہاں پہنچتی ہے کیونکہ کوئی دوسرا `external` یا `public` فنکشن نہیں ہے۔ + +```solidity + uint _func; + + _func = calldataVal(0, 1); +``` + +کال ڈیٹا کا پہلا بائٹ پڑھیں، جو ہمیں فنکشن بتاتا ہے۔ +دو وجوہات ہیں کہ کوئی فنکشن یہاں دستیاب کیوں نہیں ہوگا: + +1. جو فنکشنز `pure` یا `view` ہیں وہ اسٹیٹ کو تبدیل نہیں کرتے اور گیس کی لاگت نہیں اٹھاتے (جب آف چین کال کیا جاتا ہے)۔ + ان کی گیس کی لاگت کو کم کرنے کی کوشش کرنا کوئی معنی نہیں رکھتا۔ +2. وہ فنکشنز جو [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties) پر انحصار کرتے ہیں۔ + `msg.sender` کی قدر `CalldataInterpreter` کا پتہ ہوگی، کالر کا نہیں۔ + +بدقسمتی سے، [looking at the ERC-20 specifications](https://eips.ethereum.org/EIPS/eip-20) کو دیکھنے پر، یہ صرف ایک فنکشن، `transfer` چھوڑتا ہے۔ +یہ ہمارے پاس صرف دو فنکشنز چھوڑتا ہے: `transfer` (کیونکہ ہم `transferFrom` کو کال کر سکتے ہیں) اور `faucet` (کیونکہ ہم ٹوکنز کو واپس اسی کو منتقل کر سکتے ہیں جس نے ہمیں کال کیا)۔ + +```solidity + + // کال ڈیٹا سے معلومات کا استعمال کرتے ہوئے ٹوکن کے + // اسٹیٹ کو تبدیل کرنے والے طریقوں کو کال کریں + + // faucet + if (_func == 1) { +``` + +`faucet()` کو ایک کال، جس میں پیرامیٹرز نہیں ہوتے۔ + +```solidity + token.faucet(); + token.transfer(msg.sender, + token.balanceOf(address(this))); + } +``` + +جب ہم `token.faucet()` کو کال کرتے ہیں تو ہمیں ٹوکن ملتے ہیں۔ تاہم، پراکسی کنٹریکٹ کے طور پر، ہمیں ٹوکنز کی **ضرورت** نہیں ہے۔ +EOA (بیرونی ملکیت والا اکاؤنٹ) یا وہ کنٹریکٹ جس نے ہمیں کال کیا تھا اسے ضرورت ہے۔ +لہذا ہم اپنے تمام ٹوکنز اس کو منتقل کر دیتے ہیں جس نے ہمیں کال کیا تھا۔ + +```solidity + // منتقلی (فرض کریں کہ ہمارے پاس اس کے لیے الاؤنس ہے) + if (_func == 2) { +``` + +ٹوکنز کی منتقلی کے لیے دو پیرامیٹرز کی ضرورت ہوتی ہے: منزل کا پتہ اور رقم۔ + +```solidity + token.transferFrom( + msg.sender, +``` + +ہم صرف کال کرنے والوں کو اپنے ملکیت والے ٹوکن منتقل کرنے کی اجازت دیتے ہیں + +```solidity + address(uint160(calldataVal(1, 20))), +``` + +منزل کا پتہ بائٹ #1 سے شروع ہوتا ہے (بائٹ #0 فنکشن ہے)۔ +ایک پتے کے طور پر، یہ 20-بائٹس لمبا ہے۔ + +```solidity + calldataVal(21, 2) +``` + +اس خاص کنٹریکٹ کے لیے ہم فرض کرتے ہیں کہ کوئی بھی شخص جو زیادہ سے زیادہ ٹوکن منتقل کرنا چاہے گا وہ دو بائٹس (65536 سے کم) میں فٹ ہو جائے گا۔ + +```solidity + ); + } +``` + +مجموعی طور پر، ایک منتقلی میں کال ڈیٹا کے 35 بائٹس لگتے ہیں: + +| سیکشن | لمبائی | بائٹس | +| ------------ | -----: | ----: | +| فنکشن سلیکٹر | 1 | 0 | +| منزل کا پتہ | 32 | 1-32 | +| رقم | 2 | 33-34 | + +```solidity + } // fallback + +} // contract CalldataInterpreter +``` + +### test.js {#test-js} + +[یہ JavaScript یونٹ ٹیسٹ](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) ہمیں دکھاتا ہے کہ اس میکانزم کا استعمال کیسے کریں (اور اس کی تصدیق کیسے کریں کہ یہ صحیح طریقے سے کام کرتا ہے)۔ +میں یہ فرض کر رہا ہوں کہ آپ [chai](https://www.chaijs.com/) اور [ethers](https://docs.ethers.io/v5/) کو سمجھتے ہیں اور صرف ان حصوں کی وضاحت کروں گا جو خاص طور پر کنٹریکٹ پر لاگو ہوتے ہیں۔ + +```js +const { expect } = require("chai"); + +describe("CalldataInterpreter", function () { + it("Should let us use tokens", async function () { + const Token = await ethers.getContractFactory("OrisUselessToken") + const token = await Token.deploy() + await token.deployed() + console.log("Token addr:", token.address) + + const Cdi = await ethers.getContractFactory("CalldataInterpreter") + const cdi = await Cdi.deploy(token.address) + await cdi.deployed() + console.log("CalldataInterpreter addr:", cdi.address) + + const signer = await ethers.getSigner() +``` + +ہم دونوں کنٹریکٹس کو تعینات کرکے شروع کرتے ہیں۔ + +```javascript + // کھیلنے کے لیے ٹوکن حاصل کریں + const faucetTx = { +``` + +ہم ٹرانزیکشنز بنانے کے لیے عام طور پر استعمال ہونے والے اعلیٰ سطحی فنکشنز (جیسے `token.faucet()`) کا استعمال نہیں کر سکتے، کیونکہ ہم ABI کی پیروی نہیں کرتے۔ +اس کے بجائے، ہمیں خود ٹرانزیکشن بنانا ہوگا اور پھر اسے بھیجنا ہوگا۔ + +```javascript + to: cdi.address, + data: "0x01" +``` + +ٹرانزیکشن کے لیے ہمیں دو پیرامیٹرز فراہم کرنے کی ضرورت ہے: + +1. `to`، منزل کا پتہ۔ + یہ کال ڈیٹا انٹرپریٹر کنٹریکٹ ہے۔ +2. `data`، بھیجنے کے لیے کال ڈیٹا۔ + faucet کال کی صورت میں، ڈیٹا ایک بائٹ، `0x01` ہے۔ + +```javascript + + } + await (await signer.sendTransaction(faucetTx)).wait() +``` + +ہم [the signer's `sendTransaction` method](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) کو کال کرتے ہیں کیونکہ ہم نے پہلے ہی منزل (`faucetTx.to`) کی وضاحت کر دی ہے اور ہمیں ٹرانزیکشن پر دستخط کرنے کی ضرورت ہے۔ + +```javascript +// چیک کریں کہ faucet ٹوکنز کو صحیح طریقے سے فراہم کرتا ہے +expect(await token.balanceOf(signer.address)).to.equal(1000) +``` + +یہاں ہم بیلنس کی تصدیق کرتے ہیں۔ +`view` فنکشنز پر گیس بچانے کی ضرورت نہیں ہے، لہذا ہم انہیں عام طور پر چلاتے ہیں۔ + +```javascript +// CDI کو ایک الاؤنس دیں (منظوریوں کو پراکسی نہیں کیا جا سکتا) +const approveTX = await token.approve(cdi.address, 10000) +await approveTX.wait() +expect(await token.allowance(signer.address, cdi.address)).to.equal(10000) +``` + +منتقلی کرنے کے قابل ہونے کے لیے کال ڈیٹا انٹرپریٹر کو ایک الاؤنس دیں۔ + +```javascript +// ٹوکن منتقل کریں +const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d" +const transferTx = { + to: cdi.address, + data: "0x02" + destAddr.slice(2, 42) + "0100", +} +``` + +ایک منتقلی کا ٹرانزیکشن بنائیں۔ پہلا بائٹ "0x02" ہے، اس کے بعد منزل کا پتہ، اور آخر میں رقم (0x0100، جو ڈیسیمل میں 256 ہے)۔ + +```javascript + await (await signer.sendTransaction(transferTx)).wait() + + // چیک کریں کہ ہمارے پاس 256 ٹوکن کم ہیں + expect (await token.balanceOf(signer.address)).to.equal(1000-256) + + // اور یہ کہ ہماری منزل کو وہ مل گئے ہیں + expect (await token.balanceOf(destAddr)).to.equal(256) + }) // it +}) // describe +``` + +## لاگت کو کم کرنا جب آپ منزل کے کنٹریکٹ کو کنٹرول کرتے ہیں {#reducing-the-cost-when-you-do-control-the-destination-contract} + +اگر آپ کا منزل کے کنٹریکٹ پر کنٹرول ہے تو آپ ایسے فنکشنز بنا سکتے ہیں جو `msg.sender` چیکس کو بائی پاس کرتے ہیں کیونکہ وہ کال ڈیٹا انٹرپریٹر پر بھروسہ کرتے ہیں۔ +[آپ یہاں اس کی ایک مثال دیکھ سکتے ہیں کہ یہ کیسے کام کرتا ہے، `control-contract` برانچ میں](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract)۔ + +اگر کنٹریکٹ صرف بیرونی ٹرانزیکشنز کا جواب دے رہا ہوتا، تو ہم صرف ایک کنٹریکٹ کے ساتھ کام چلا سکتے تھے۔ +تاہم، اس سے [composability](/developers/docs/smart-contracts/composability/) ٹوٹ جائے گی۔ +ایک ایسا کنٹریکٹ رکھنا بہت بہتر ہے جو عام ERC-20 کالز کا جواب دے، اور دوسرا کنٹریکٹ جو مختصر کال ڈیٹا والے ٹرانزیکشنز کا جواب دے۔ + +### Token.sol {#token-sol-2} + +اس مثال میں ہم `Token.sol` میں ترمیم کر سکتے ہیں۔ +یہ ہمیں کئی ایسے فنکشنز رکھنے کی اجازت دیتا ہے جنہیں صرف پراکسی ہی کال کر سکتا ہے۔ +یہاں نئے حصے ہیں: + +```solidity + // CalldataInterpreter ایڈریس کی وضاحت کرنے کی اجازت والا واحد ایڈریس + address owner; + + // CalldataInterpreter ایڈریس + address proxy = address(0); +``` + +ERC-20 کنٹریکٹ کو مجاز پراکسی کی شناخت جاننے کی ضرورت ہے۔ +تاہم، ہم اس متغیر کو کنسٹرکٹر میں سیٹ نہیں کر سکتے، کیونکہ ہمیں ابھی تک قدر کا علم نہیں ہے۔ +یہ کنٹریکٹ پہلے انسٹینٹی ایٹ کیا جاتا ہے کیونکہ پراکسی اپنے کنسٹرکٹر میں ٹوکن کے پتے کی توقع کرتا ہے۔ + +```solidity + /** + * @dev ERC20 کنسٹرکٹر کو کال کرتا ہے۔ + */ + constructor( + ) ERC20("Oris useless token-2", "OUT-2") { + owner = msg.sender; + } +``` + +تخلیق کار کا پتہ (جسے `owner` کہا جاتا ہے) یہاں ذخیرہ کیا جاتا ہے کیونکہ یہ واحد پتہ ہے جسے پراکسی سیٹ کرنے کی اجازت ہے۔ + +```solidity + /** + * @dev پراکسی (CalldataInterpreter) کے لیے پتہ سیٹ کریں۔ + * مالک کے ذریعہ صرف ایک بار کال کیا جاسکتا ہے + */ + function setProxy(address _proxy) external { + require(msg.sender == owner, "صرف مالک کے ذریعہ کال کیا جاسکتا ہے"); + require(proxy == address(0), "پراکسی پہلے ہی سیٹ ہے"); + + proxy = _proxy; + } // فنکشن setProxy +``` + +پراکسی کو مراعات یافتہ رسائی حاصل ہے، کیونکہ یہ سیکیورٹی چیک کو بائی پاس کر سکتا ہے۔ +یہ یقینی بنانے کے لیے کہ ہم پراکسی پر بھروسہ کر سکتے ہیں، ہم صرف `owner` کو اس فنکشن کو کال کرنے دیتے ہیں، اور صرف ایک بار۔ +ایک بار جب `proxy` کی کوئی حقیقی قدر (صفر نہیں) ہو جاتی ہے، تو وہ قدر تبدیل نہیں ہو سکتی، لہذا یہاں تک کہ اگر مالک بدمعاش بننے کا فیصلہ کرتا ہے، یا اس کے لیے میمونک ظاہر ہو جاتا ہے، ہم پھر بھی محفوظ ہیں۔ + +```solidity + /** + * @dev کچھ فنکشنز صرف پراکسی کے ذریعے ہی کال کیے جا سکتے ہیں۔ + */ + modifier onlyProxy { +``` + +یہ ایک [`modifier` function](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) ہے، یہ دوسرے فنکشنز کے کام کرنے کے طریقے میں ترمیم کرتا ہے۔ + +```solidity + require(msg.sender == proxy); +``` + +سب سے پہلے، تصدیق کریں کہ ہمیں پراکسی نے کال کیا ہے اور کسی اور نے نہیں۔ +اگر نہیں، تو `revert` کریں۔ + +```solidity + _; + } +``` + +اگر ایسا ہے تو، اس فنکشن کو چلائیں جس میں ہم ترمیم کرتے ہیں۔ + +```solidity + /* وہ فنکشنز جو پراکسی کو اکاؤنٹس کے لیے پراکسی کرنے کی اجازت دیتے ہیں */ + + function transferProxy(address from, address to, uint256 amount) + public virtual onlyProxy() returns (bool) + { + _transfer(from, to, amount); + return true; + } + + function approveProxy(address from, address spender, uint256 amount) + public virtual onlyProxy() returns (bool) + { + _approve(from, spender, amount); + return true; + } + + function transferFromProxy( + address spender, + address from, + address to, + uint256 amount + ) public virtual onlyProxy() returns (bool) + { + _spendAllowance(from, spender, amount); + _transfer(from, to, amount); + return true; + } +``` + +یہ تین آپریشنز ہیں جن کے لیے عام طور پر پیغام کو براہ راست ٹوکن منتقل کرنے یا الاؤنس منظور کرنے والی ہستی سے آنے کی ضرورت ہوتی ہے۔ +یہاں ہمارے پاس ان آپریشنز کا ایک پراکسی ورژن ہے جو: + +1. `onlyProxy()` کے ذریعے ترمیم کیا گیا ہے تاکہ کسی اور کو انہیں کنٹرول کرنے کی اجازت نہ ہو۔ +2. وہ پتہ حاصل کرتا ہے جو عام طور پر `msg.sender` ہوگا ایک اضافی پیرامیٹر کے طور پر۔ + +### CalldataInterpreter.sol {#calldatainterpreter-sol-2} + +کال ڈیٹا انٹرپریٹر اوپر والے سے تقریباً مماثل ہے، سوائے اس کے کہ پراکسیڈ فنکشنز کو `msg.sender` پیرامیٹر ملتا ہے اور `transfer` کے لیے الاؤنس کی کوئی ضرورت نہیں ہے۔ + +```solidity + // منتقلی (الاؤنس کی ضرورت نہیں) + if (_func == 2) { + token.transferProxy( + msg.sender, + address(uint160(calldataVal(1, 20))), + calldataVal(21, 2) + ); + } + + // منظوری + if (_func == 3) { + token.approveProxy( + msg.sender, + address(uint160(calldataVal(1, 20))), + calldataVal(21, 2) + ); + } + + // transferFrom + if (_func == 4) { + token.transferFromProxy( + msg.sender, + address(uint160(calldataVal( 1, 20))), + address(uint160(calldataVal(21, 20))), + calldataVal(41, 2) + ); + } +``` + +### Test.js {#test-js-2} + +پچھلے ٹیسٹنگ کوڈ اور اس کے درمیان کچھ تبدیلیاں ہیں۔ + +```js +const Cdi = await ethers.getContractFactory("CalldataInterpreter") +const cdi = await Cdi.deploy(token.address) +await cdi.deployed() +await token.setProxy(cdi.address) +``` + +ہمیں ERC-20 کنٹریکٹ کو یہ بتانے کی ضرورت ہے کہ کس پراکسی پر بھروسہ کرنا ہے + +```js +console.log("CalldataInterpreter addr:", cdi.address) + +// الاؤنس کی تصدیق کے لیے دو دستخط کنندگان کی ضرورت ہے +const signers = await ethers.getSigners() +const signer = signers[0] +const poorSigner = signers[1] +``` + +`approve()` اور `transferFrom()` کو چیک کرنے کے لیے ہمیں دوسرے دستخط کنندہ کی ضرورت ہے۔ +ہم اسے `poorSigner` کہتے ہیں کیونکہ اسے ہمارے کوئی ٹوکن نہیں ملتے (اس کے پاس ETH ہونا ضروری ہے، یقیناً)۔ + +```js +// ٹوکن منتقل کریں +const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d" +const transferTx = { + to: cdi.address, + data: "0x02" + destAddr.slice(2, 42) + "0100", +} +await (await signer.sendTransaction(transferTx)).wait() +``` + +کیونکہ ERC-20 کنٹریکٹ پراکسی (`cdi`) پر بھروسہ کرتا ہے، ہمیں منتقلیوں کو ریلے کرنے کے لیے الاؤنس کی ضرورت نہیں ہے۔ + +```js +// منظوری اور transferFrom +const approveTx = { + to: cdi.address, + data: "0x03" + poorSigner.address.slice(2, 42) + "00FF", +} +await (await signer.sendTransaction(approveTx)).wait() + +const destAddr2 = "0xE1165C689C0c3e9642cA7606F5287e708d846206" + +const transferFromTx = { + to: cdi.address, + data: "0x04" + signer.address.slice(2, 42) + destAddr2.slice(2, 42) + "00FF", +} +await (await poorSigner.sendTransaction(transferFromTx)).wait() + +// چیک کریں کہ منظوری / transferFrom کا امتزاج صحیح طریقے سے کیا گیا تھا +expect(await token.balanceOf(destAddr2)).to.equal(255) +``` + +دو نئے فنکشنز کی جانچ کریں۔ +نوٹ کریں کہ `transferFromTx` کو دو ایڈریس پیرامیٹرز کی ضرورت ہے: الاؤنس دینے والا اور وصول کنندہ۔ + +## نتیجہ {#conclusion} + +دونوں [Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) اور [Arbitrum](https://developer.offchainlabs.com/docs/special_features) L1 پر لکھے گئے کال ڈیٹا کے سائز کو کم کرنے اور اس وجہ سے ٹرانزیکشنز کی لاگت کو کم کرنے کے طریقے تلاش کر رہے ہیں۔ +تاہم، عام حل تلاش کرنے والے بنیادی ڈھانچے فراہم کرنے والوں کے طور پر، ہماری صلاحیتیں محدود ہیں۔ +ڈ ایپ ڈیولپر کے طور پر، آپ کے پاس ایپلیکیشن کے لیے مخصوص علم ہے، جو آپ کو اپنے کال ڈیٹا کو ہم سے کہیں بہتر طور پر آپٹمائز کرنے دیتا ہے جتنا کہ ہم ایک عام حل میں کر سکتے ہیں۔ +امید ہے کہ یہ مضمون آپ کو اپنی ضروریات کے لیے مثالی حل تلاش کرنے میں مدد کرے گا۔ + +[میرے مزید کام کے لیے یہاں دیکھیں](https://cryptodocguy.pro/)۔ + diff --git a/public/content/translations/ur/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/ur/developers/tutorials/smart-contract-security-guidelines/index.md new file mode 100644 index 00000000000..82035f97ad6 --- /dev/null +++ b/public/content/translations/ur/developers/tutorials/smart-contract-security-guidelines/index.md @@ -0,0 +1,91 @@ +--- +title: "اسمارٹ کنٹریکٹ سیکیورٹی گائیڈ لائنز" +description: "اپنا ڈیپ بناتے وقت غور کرنے کے لیے سیکیورٹی گائیڈ لائنز کی ایک چیک لسٹ" +author: "Trailofbits" +tags: [ "solidity", "اسمارٹ معاہدات", "سیکورٹی" ] +skill: intermediate +lang: ur-in +published: 2020-09-06 +source: Building secure contracts +sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md +--- + +مزید محفوظ اسمارٹ کنٹریکٹس بنانے کے لیے ان اعلیٰ سطحی سفارشات پر عمل کریں۔ + +## ڈیزائن کے رہنما اصول {#design-guidelines} + +کنٹریکٹ کے ڈیزائن پر پہلے سے، کوڈ کی کوئی بھی لائن لکھنے سے پہلے بات چیت کی جانی چاہیے۔ + +### دستاویزات اور وضاحتیں {#documentation-and-specifications} + +دستاویزات مختلف سطحوں پر لکھی جا سکتی ہیں، اور کنٹریکٹس کو نافذ کرتے وقت اسے اپ ڈیٹ کیا جانا چاہیے: + +- **سسٹم کی سادہ انگریزی میں تفصیل**، یہ بیان کرتے ہوئے کہ کنٹریکٹس کیا کرتے ہیں اور کوڈبیس پر کوئی بھی مفروضہ۔ +- **اسکیما اور آرکیٹیکچرل ڈایاگرام**، بشمول کنٹریکٹ کے تعاملات اور سسٹم کی اسٹیٹ مشین۔ [Slither پرنٹرز](https://github.com/crytic/slither/wiki/Printer-documentation) ان اسکیماز کو بنانے میں مدد کر سکتے ہیں۔ +- **مکمل کوڈ دستاویزات**، [Natspec فارمیٹ](https://docs.soliditylang.org/en/develop/natspec-format.html) Solidity کے لیے استعمال کیا جا سکتا ہے۔ + +### آن چین بمقابلہ آف چین کمپیوٹیشن {#onchain-vs-offchain-computation} + +- **جتنا ہو سکے کوڈ کو آف چین رکھیں۔** آن چین لیئر کو چھوٹا رکھیں۔ آف چین کوڈ کے ساتھ ڈیٹا کو اس طرح پہلے سے پروسیس کریں کہ آن چین تصدیق آسان ہو۔ کیا آپ کو ایک ترتیب شدہ فہرست کی ضرورت ہے؟ فہرست کو آف چین ترتیب دیں، پھر اس کی ترتیب کو صرف آن چین چیک کریں۔ + +### اپ گریڈ ایبلٹی {#upgradeability} + +ہم نے [ہمارے بلاگ پوسٹ](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) میں مختلف اپ گریڈ ایبلٹی حل پر تبادلہ خیال کیا ہے۔ کوئی بھی کوڈ لکھنے سے پہلے اپ گریڈ ایبلٹی کو سپورٹ کرنے یا نہ کرنے کا دانستہ انتخاب کریں۔ یہ فیصلہ اس بات پر اثرانداز ہوگا کہ آپ اپنے کوڈ کی ساخت کیسے بناتے ہیں۔ عام طور پر، ہم تجویز کرتے ہیں: + +- **اپ گریڈ ایبلٹی پر [کنٹریکٹ مائیگریشن](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) کو ترجیح دینا۔** مائیگریشن سسٹم میں اپ گریڈ ایبل سسٹم جیسے بہت سے فوائد ہوتے ہیں، بغیر ان کی خامیوں کے۔ +- **delegatecallproxy کے بجائے ڈیٹا سیپریشن پیٹرن کا استعمال۔** اگر آپ کے پروجیکٹ میں واضح تجریدی علیحدگی ہے، تو ڈیٹا سیپریشن کا استعمال کرتے ہوئے اپ گریڈ ایبلٹی کے لیے صرف چند ایڈجسٹمنٹ کی ضرورت ہوگی۔ delegatecallproxy کے لیے EVM کی مہارت درکار ہے اور یہ بہت زیادہ غلطی کا شکار ہے۔ +- **تعیناتی سے پہلے مائیگریشن/اپ گریڈ کے طریقہ کار کو دستاویز کریں۔** اگر آپ کو بغیر کسی رہنما اصول کے دباؤ میں رد عمل ظاہر کرنا پڑا تو آپ غلطیاں کریں گے۔ پیروی کرنے کے لیے طریقہ کار پہلے سے لکھیں۔ اس میں شامل ہونا چاہیے: + - وہ کالز جو نئے کنٹریکٹس شروع کرتی ہیں + - چابیاں کہاں محفوظ ہیں اور ان تک کیسے رسائی حاصل کی جائے + - تعیناتی کو کیسے چیک کریں! ایک پوسٹ-ڈیپلائمنٹ اسکرپٹ تیار اور ٹیسٹ کریں۔ + +## نفاذ کے رہنما اصول {#implementation-guidelines} + +**سادگی کے لیے کوشش کریں۔** ہمیشہ سب سے آسان حل استعمال کریں جو آپ کے مقصد کے مطابق ہو۔ آپ کی ٹیم کا کوئی بھی رکن آپ کے حل کو سمجھنے کے قابل ہونا چاہیے۔ + +### فنکشن کمپوزیشن {#function-composition} + +آپ کے کوڈبیس کا فن تعمیر آپ کے کوڈ کا جائزہ لینا آسان بنانا چاہیے۔ ایسے آرکیٹیکچرل انتخاب سے گریز کریں جو اس کی درستگی کے بارے میں استدلال کرنے کی صلاحیت کو کم کرتے ہیں۔ + +- **اپنے سسٹم کی منطق کو تقسیم کریں**، یا تو متعدد کنٹریکٹس کے ذریعے یا اسی طرح کے فنکشنز کو ایک ساتھ گروپ کرکے (مثال کے طور پر، توثیق، ریاضی، ...)۔ +- **چھوٹے فنکشنز لکھیں، ایک واضح مقصد کے ساتھ۔** یہ آسان جائزہ لینے میں سہولت فراہم کرے گا اور انفرادی اجزاء کی جانچ کی اجازت دے گا۔ + +### وراثت {#inheritance} + +- **وراثت کو قابل انتظام رکھیں۔** وراثت کو منطق کو تقسیم کرنے کے لیے استعمال کیا جانا چاہیے، تاہم، آپ کے پروجیکٹ کا مقصد وراثت کے درخت کی گہرائی اور چوڑائی کو کم کرنا ہونا چاہیے۔ +- **کنٹریکٹس کے درجہ بندی کو چیک کرنے کے لیے Slither کے [وراثت پرنٹر](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) کا استعمال کریں۔** وراثت پرنٹر آپ کو درجہ بندی کے سائز کا جائزہ لینے میں مدد کرے گا۔ + +### ایونٹس {#events} + +- **تمام اہم کارروائیوں کو لاگ کریں۔** ایونٹس ڈیولپمنٹ کے دوران کنٹریکٹ کو ڈیبگ کرنے، اور تعیناتی کے بعد اس کی نگرانی کرنے میں مدد کریں گے۔ + +### معروف نقصانات سے بچیں {#avoid-known-pitfalls} + +- **سب سے عام سیکیورٹی مسائل سے آگاہ رہیں۔** عام مسائل کے بارے میں جاننے کے لیے بہت سے آن لائن وسائل موجود ہیں، جیسے کہ [Ethernaut CTF](https://ethernaut.openzeppelin.com/)، [Capture the Ether](https://capturetheether.com/)، یا [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/)۔ +- **[Solidity دستاویزات](https://docs.soliditylang.org/en/latest/) میں وارننگ سیکشنز سے آگاہ رہیں۔** وارننگ سیکشنز آپ کو زبان کے غیر واضح رویے کے بارے میں آگاہ کریں گے۔ + +### انحصار {#dependencies} + +- **اچھی طرح سے ٹیسٹ شدہ لائبریریوں کا استعمال کریں۔** اچھی طرح سے ٹیسٹ شدہ لائبریریوں سے کوڈ درآمد کرنا اس امکان کو کم کر دے گا کہ آپ بگ والا کوڈ لکھیں۔ اگر آپ ERC20 کنٹریکٹ لکھنا چاہتے ہیں، تو [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20) استعمال کریں۔ +- **ایک ڈیپنڈنسی مینیجر کا استعمال کریں؛ کوڈ کو کاپی پیسٹ کرنے سے گریز کریں۔** اگر آپ کسی بیرونی ماخذ پر انحصار کرتے ہیں، تو آپ کو اسے اصل ماخذ کے ساتھ اپ ٹو ڈیٹ رکھنا چاہیے۔ + +### جانچ اور تصدیق {#testing-and-verification} + +- **مکمل یونٹ ٹیسٹ لکھیں۔** اعلیٰ معیار کا سافٹ ویئر بنانے کے لیے ایک وسیع ٹیسٹ سویٹ بہت ضروری ہے۔ +- **[Slither](https://github.com/crytic/slither)، [Echidna](https://github.com/crytic/echidna) اور [Manticore](https://github.com/trailofbits/manticore) کسٹم چیکس اور پراپرٹیز لکھیں۔** خودکار ٹولز آپ کے کنٹریکٹ کو محفوظ بنانے میں مدد کریں گے۔ موثر چیکس اور پراپرٹیز لکھنے کا طریقہ جاننے کے لیے اس گائیڈ کے باقی حصے کا جائزہ لیں۔ +- **[crytic.io](https://crytic.io/) کا استعمال کریں۔** Crytic GitHub کے ساتھ مربوط ہوتا ہے، نجی Slither ڈیٹیکٹرز تک رسائی فراہم کرتا ہے، اور Echidna سے کسٹم پراپرٹی چیکس چلاتا ہے۔ + +### Solidity {#solidity} + +- **0.4 اور 0.6 پر Solidity 0.5 کو ترجیح دیں۔** ہماری رائے میں، Solidity 0.5 زیادہ محفوظ ہے اور 0.4 کے مقابلے میں بہتر بلٹ ان پریکٹسز رکھتا ہے۔ Solidity 0.6 پروڈکشن کے لیے بہت غیر مستحکم ثابت ہوا ہے اور اسے پختہ ہونے کے لیے وقت درکار ہے۔ +- **کمپائل کرنے کے لیے ایک مستحکم ریلیز کا استعمال کریں؛ وارننگز چیک کرنے کے لیے تازہ ترین ریلیز کا استعمال کریں۔** چیک کریں کہ آپ کے کوڈ میں تازہ ترین کمپائلر ورژن کے ساتھ کوئی رپورٹ شدہ مسئلہ نہیں ہے۔ تاہم، Solidity کا ایک تیز ریلیز سائیکل ہے اور اس میں کمپائلر بگز کی تاریخ ہے، اس لیے ہم تعیناتی کے لیے تازہ ترین ورژن کی سفارش نہیں کرتے ہیں (Slither کی [solc ورژن کی سفارش](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33) دیکھیں)۔ +- **ان لائن اسمبلی کا استعمال نہ کریں۔** اسمبلی کے لیے EVM کی مہارت درکار ہے۔ EVM کوڈ نہ لکھیں اگر آپ نے یلو پیپر میں _مہارت_ حاصل نہیں کی ہے۔ + +## تعیناتی کے رہنما اصول {#deployment-guidelines} + +ایک بار جب کنٹریکٹ تیار اور تعینات ہو جائے: + +- **اپنے کنٹریکٹس کی نگرانی کریں۔** لاگز دیکھیں، اور کنٹریکٹ یا والیٹ کے سمجھوتے کی صورت میں رد عمل ظاہر کرنے کے لیے تیار رہیں۔ +- **اپنی رابطہ کی معلومات [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts) میں شامل کریں۔** یہ فہرست تیسرے فریق کو آپ سے رابطہ کرنے میں مدد کرتی ہے اگر کوئی سیکیورٹی خامی دریافت ہوتی ہے۔ +- **مراعات یافتہ صارفین کے والیٹس کو محفوظ بنائیں۔** اگر آپ ہارڈ ویئر والیٹس میں چابیاں محفوظ کرتے ہیں تو ہماری [بہترین طریقوں](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) پر عمل کریں۔ +- **واقعہ کے جواب کا منصوبہ بنائیں۔** غور کریں کہ آپ کے اسمارٹ کنٹریکٹس سے سمجھوتہ کیا جا سکتا ہے۔ یہاں تک کہ اگر آپ کے کنٹریکٹس بگ سے پاک ہیں، ایک حملہ آور کنٹریکٹ کے مالک کی چابیوں پر کنٹرول حاصل کر سکتا ہے۔ diff --git a/public/content/translations/ur/developers/tutorials/stealth-addr/index.md b/public/content/translations/ur/developers/tutorials/stealth-addr/index.md new file mode 100644 index 00000000000..5703588ab12 --- /dev/null +++ b/public/content/translations/ur/developers/tutorials/stealth-addr/index.md @@ -0,0 +1,436 @@ +--- +title: "خفیہ پتوں کا استعمال" +description: "خفیہ پتے صارفین کو گمنام طور پر اثاثوں کی منتقلی کی اجازت دیتے ہیں۔ اس مضمون کو پڑھنے کے بعد، آپ اس قابل ہو جائیں گے: یہ بتانے کے کہ خفیہ پتے کیا ہیں اور وہ کیسے کام کرتے ہیں، خفیہ پتوں کو اس طرح استعمال کرنے کا طریقہ سمجھنے کے جو گمنامی کو برقرار رکھتا ہے، اور ایک ویب پر مبنی ایپلیکیشن لکھنے کے جو خفیہ پتوں کا استعمال کرتی ہے۔" +author: Ori Pomerantz +tags: [ "خفیہ پتہ", "رازداری", "کریپٹوگرافی", "rust", "wasm" ] +skill: intermediate +published: 2025-11-30 +lang: ur-in +sidebarDepth: 3 +--- + +آپ بل ہیں۔ ان وجوہات کی بنا پر جن میں ہم نہیں جائیں گے، آپ "دنیا کی ملکہ کے لیے ایلس" مہم کو عطیہ دینا چاہتے ہیں اور ایلس کو یہ معلوم کرانا چاہتے ہیں کہ آپ نے عطیہ دیا ہے تاکہ اگر وہ جیت جائے تو وہ آپ کو انعام دے۔ بدقسمتی سے، اس کی جیت کی ضمانت نہیں ہے۔ ایک مسابقتی مہم ہے، "کیرول نظام شمسی کی مہارانی کے لیے"۔ اگر کیرول جیت جاتی ہے، اور اسے پتہ چل جاتا ہے کہ آپ نے ایلس کو عطیہ دیا ہے، تو آپ مشکل میں پڑ جائیں گے۔ لہذا آپ صرف اپنے اکاؤنٹ سے ایلس کے اکاؤنٹ میں 200 ETH منتقل نہیں کر سکتے۔ + +[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) کے پاس اس کا حل ہے۔ یہ ERC گمنام منتقلی کے لیے [خفیہ پتوں](https://nerolation.github.io/stealth-utils) کا استعمال کرنے کا طریقہ بتاتا ہے۔ + +**انتباہ**: خفیہ پتوں کے پیچھے کی کریپٹوگرافی، جہاں تک ہم جانتے ہیں، درست ہے۔ تاہم، ممکنہ سائیڈ چینل حملے ہو سکتے ہیں۔ [نیچے](#go-wrong)، آپ دیکھیں گے کہ آپ اس خطرے کو کم کرنے کے لیے کیا کر سکتے ہیں۔ + +## خفیہ پتے کیسے کام کرتے ہیں {#how} + +یہ مضمون دو طریقوں سے خفیہ پتوں کی وضاحت کرنے کی کوشش کرے گا۔ پہلا یہ ہے کہ [ان کا استعمال کیسے کریں](#how-use)۔ یہ حصہ مضمون کے باقی حصے کو سمجھنے کے لیے کافی ہے۔ پھر، [اس کے پیچھے ریاضی کی وضاحت](#how-math) ہے۔ اگر آپ کریپٹوگرافی میں دلچسپی رکھتے ہیں، تو یہ حصہ بھی پڑھیں۔ + +### سادہ ورژن (خفیہ پتوں کا استعمال کیسے کریں) {#how-use} + +ایلس دو پرائیویٹ کیز بناتی ہے اور متعلقہ پبلک کیز شائع کرتی ہے (جنہیں ایک ہی ڈبل لینتھ میٹا ایڈریس میں ملایا جا سکتا ہے)۔ بل بھی ایک پرائیویٹ کی بناتا ہے اور متعلقہ پبلک کی شائع کرتا ہے۔ + +ایک پارٹی کی پبلک کی اور دوسری کی پرائیویٹ کی کا استعمال کرتے ہوئے، آپ ایک مشترکہ راز حاصل کر سکتے ہیں جو صرف ایلس اور بل کو معلوم ہے (اسے صرف پبلک کیز سے حاصل نہیں کیا جا سکتا)۔ اس مشترکہ راز کا استعمال کرتے ہوئے، بل خفیہ پتہ حاصل کرتا ہے اور اس پر اثاثے بھیج سکتا ہے۔ + +ایلس کو بھی مشترکہ راز سے پتہ ملتا ہے، لیکن چونکہ وہ اپنی شائع کردہ پبلک کیز کی پرائیویٹ کیز جانتی ہے، اس لیے وہ وہ پرائیویٹ کی بھی حاصل کر سکتی ہے جو اسے اس پتے سے رقم نکالنے دیتی ہے۔ + +### ریاضی (خفیہ پتے اس طرح کیوں کام کرتے ہیں) {#how-math} + +معیاری خفیہ پتے کم کی بٹس کے ساتھ بہتر کارکردگی حاصل کرنے کے لیے [الیپٹک کرو کریپٹوگرافی (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor) کا استعمال کرتے ہیں، جبکہ سیکیورٹی کی سطح وہی رہتی ہے۔ لیکن زیادہ تر ہم اسے نظر انداز کر سکتے ہیں اور یہ دکھاوا کر سکتے ہیں کہ ہم باقاعدہ ریاضی کا استعمال کر رہے ہیں۔ + +ایک نمبر ہے جسے ہر کوئی جانتا ہے، _G_۔ آپ _G_ سے ضرب دے سکتے ہیں۔ لیکن ECC کی نوعیت کی وجہ سے، _G_ سے تقسیم کرنا عملی طور پر ناممکن ہے۔ Ethereum میں پبلک کی کریپٹوگرافی عام طور پر جس طرح کام کرتی ہے وہ یہ ہے کہ آپ ایک پرائیویٹ کی، _Ppriv_، کا استعمال لین دین پر دستخط کرنے کے لیے کر سکتے ہیں جن کی تصدیق پھر ایک پبلک کی، _Ppub = GPpriv_ سے ہوتی ہے۔ + +ایلس دو پرائیویٹ کیز بناتی ہے، _Kpriv_ اور _Vpriv_۔ _Kpriv_ کا استعمال خفیہ پتے سے رقم خرچ کرنے کے لیے کیا جائے گا، اور _Vpriv_ کا استعمال ایلس سے تعلق رکھنے والے پتوں کو دیکھنے کے لیے کیا جائے گا۔ ایلس پھر پبلک کیز شائع کرتی ہے: _Kpub = GKpriv_ اور _Vpub = GVpriv_ + +بل ایک تیسری پرائیویٹ کی، _Rpriv_ بناتا ہے، اور _Rpub = GRpriv_ کو ایک مرکزی رجسٹری میں شائع کرتا ہے (بل اسے ایلس کو بھی بھیج سکتا تھا، لیکن ہم فرض کرتے ہیں کہ کیرول سن رہی ہے)۔ + +بل _RprivVpub = GRprivVpriv_ کا حساب لگاتا ہے، جس کی وہ توقع کرتا ہے کہ ایلس بھی جانتی ہے (نیچے وضاحت کی گئی ہے)۔ اس قدر کو _S_، یعنی مشترکہ راز کہا جاتا ہے۔ یہ بل کو ایک پبلک کی دیتا ہے، _Ppub = Kpub+G\*hash(S)_۔ اس پبلک کی سے، وہ ایک پتہ کا حساب لگا سکتا ہے اور جو بھی وسائل وہ چاہے اسے بھیج سکتا ہے۔ مستقبل میں، اگر ایلس جیت جاتی ہے، تو بل اسے _Rpriv_ بتا سکتا ہے تاکہ یہ ثابت ہو سکے کہ وسائل اسی کی طرف سے آئے ہیں۔ + +ایلس _RpubVpriv = GRprivVpriv_ کا حساب لگاتی ہے۔ یہ اسے وہی مشترکہ راز، _S_ دیتا ہے۔ چونکہ وہ پرائیویٹ کی، _Kpriv_ جانتی ہے، وہ _Ppriv = Kpriv+hash(S)_ کا حساب لگا سکتی ہے۔ یہ کی اسے اس پتے میں موجود اثاثوں تک رسائی دیتی ہے جو _Ppub = GPpriv = GKpriv+G\*hash(S) = Kpub+G\*hash(S)_ سے حاصل ہوتا ہے۔ + +ہمارے پاس ایک علیحدہ ویونگ کی ہے تاکہ ایلس ڈیو کی ورلڈ ڈومینیشن کمپین سروسز کو سب کنٹریکٹ دے سکے۔ ایلس ڈیو کو عوامی پتے بتانے اور جب مزید رقم دستیاب ہو تو اسے مطلع کرنے کے لیے تیار ہے، لیکن وہ نہیں چاہتی کہ وہ اس کی مہم کی رقم خرچ کرے۔ + +چونکہ دیکھنے اور خرچ کرنے کے لیے علیحدہ کیز کا استعمال ہوتا ہے، ایلس ڈیو کو _Vpriv_ دے سکتی ہے۔ پھر ڈیو _S = RpubVpriv = GRprivVpriv_ کا حساب لگا سکتا ہے اور اس طرح پبلک کیز (_Ppub = Kpub+G\*hash(S)_) حاصل کر سکتا ہے۔ لیکن _Kpriv_ کے بغیر ڈیو پرائیویٹ کی حاصل نہیں کر سکتا۔ + +خلاصہ یہ کہ، یہ وہ اقدار ہیں جو مختلف شرکاء کو معلوم ہیں۔ + +| ایلس | شائع شدہ | بل | ڈیو | | +| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------- | +| G | G | G | G | | +| _Kpriv_ | ۔ | ۔ | ۔ | | +| _Vpriv_ | ۔ | ۔ | _Vpriv_ | | +| _Kpub = GKpriv_ | _Kpub_ | _Kpub_ | _Kpub_ | | +| _Vpub = GVpriv_ | _Vpub_ | _Vpub_ | _Vpub_ | | +| ۔ | ۔ | _Rpriv_ | ۔ | | +| _Rpub_ | _Rpub_ | _Rpub = GRpriv_ | _Rpub_ | | +| _S = RpubVpriv = GRprivVpriv_ | ۔ | _S = RprivVpub = GRprivVpriv_ | _S = _RpubVpriv_ = GRprivVpriv_ | | +| _Ppub = Kpub+G\*hash(S)_ | ۔ | _Ppub = Kpub+G\*hash(S)_ | _Ppub = Kpub+G\*hash(S)_ | | +| _پتہ=f(Ppub)_ | ۔ | _پتہ=f(Ppub)_ | _پتہ=f(Ppub)_ | _پتہ=f(Ppub)_ | +| _Ppriv = Kpriv+hash(S)_ | ۔ | ۔ | ۔ | | + +## جب خفیہ پتے غلط ہو جاتے ہیں {#go-wrong} + +_بلاک چین پر کوئی راز نہیں ہوتے_۔ جبکہ خفیہ پتے آپ کو رازداری فراہم کر سکتے ہیں، لیکن وہ رازداری ٹریفک کے تجزیے کے لیے حساس ہے۔ ایک معمولی مثال کے طور پر، تصور کریں کہ بل ایک پتے کو فنڈ کرتا ہے اور فوری طور پر _Rpub_ قدر شائع کرنے کے لیے ایک لین دین بھیجتا ہے۔ ایلس کی _Vpriv_ کے بغیر، ہم یقینی طور پر نہیں کہہ سکتے کہ یہ ایک خفیہ پتہ ہے، لیکن شرط لگانے کا یہی طریقہ ہے۔ پھر، ہم ایک اور لین دین دیکھتے ہیں جو اس پتے سے تمام ETH کو ایلس کے مہم کے فنڈ کے پتے پر منتقل کرتا ہے۔ ہم شاید اسے ثابت نہ کر سکیں، لیکن امکان ہے کہ بل نے ابھی ایلس کی مہم کو عطیہ دیا ہے۔ کیرول یقینی طور پر ایسا ہی سوچے گی۔ + +بل کے لیے _Rpub_ کی اشاعت کو خفیہ پتے کی فنڈنگ سے الگ کرنا آسان ہے (انہیں مختلف اوقات میں، مختلف پتوں سے کریں)۔ تاہم، یہ ناکافی ہے۔ کیرول جس پیٹرن کو تلاش کرتی ہے وہ یہ ہے کہ بل ایک پتے کو فنڈ کرتا ہے، اور پھر ایلس کا مہم فنڈ اس سے رقم نکالتا ہے۔ + +ایک حل یہ ہے کہ ایلس کی مہم براہ راست رقم نہ نکالے، بلکہ اسے کسی تیسرے فریق کو ادائیگی کے لیے استعمال کرے۔ اگر ایلس کی مہم ڈیو کی ورلڈ ڈومینیشن کمپین سروسز کو 10 ETH بھیجتی ہے، تو کیرول کو صرف یہ معلوم ہوتا ہے کہ بل نے ڈیو کے صارفین میں سے کسی ایک کو عطیہ دیا ہے۔ اگر ڈیو کے پاس کافی گاہک ہیں، تو کیرول یہ نہیں جان پائے گی کہ بل نے ایلس کو عطیہ دیا جو اس سے مقابلہ کرتی ہے، یا ایڈم، البرٹ، یا ابیگیل کو جن کی کیرول کو پرواہ نہیں ہے۔ ایلس ادائیگی کے ساتھ ایک ہیش شدہ قدر شامل کر سکتی ہے، اور پھر ڈیو کو پری امیج فراہم کر سکتی ہے، تاکہ یہ ثابت ہو سکے کہ یہ اس کا عطیہ تھا۔ متبادل کے طور پر، جیسا کہ اوپر بتایا گیا ہے، اگر ایلس ڈیو کو اپنی _Vpriv_ دیتی ہے، تو وہ پہلے ہی جانتا ہے کہ ادائیگی کس کی طرف سے آئی ہے۔ + +اس حل کے ساتھ بنیادی مسئلہ یہ ہے کہ اس میں ایلس کو رازداری کا خیال رکھنے کی ضرورت ہوتی ہے جبکہ اس رازداری سے بل کو فائدہ ہوتا ہے۔ ایلس اپنی ساکھ برقرار رکھنا چاہ سکتی ہے تاکہ بل کا دوست باب بھی اسے عطیہ دے۔ لیکن یہ بھی ممکن ہے کہ اسے بل کو بے نقاب کرنے میں کوئی اعتراض نہ ہو، کیونکہ پھر اسے ڈر ہوگا کہ اگر کیرول جیت گئی تو کیا ہوگا۔ بل شاید ایلس کو اور بھی زیادہ مدد فراہم کرے۔ + +### متعدد خفیہ پرتوں کا استعمال {#multi-layer} + +بل کی رازداری کو برقرار رکھنے کے لیے ایلس پر انحصار کرنے کے بجائے، بل خود یہ کر سکتا ہے۔ وہ فرضی لوگوں، باب اور بیلا کے لیے متعدد میٹا پتے بنا سکتا ہے۔ بل پھر باب کو ETH بھیجتا ہے، اور "باب" (جو دراصل بل ہے) اسے بیلا کو بھیجتا ہے۔ "بیلا" (جو بھی بل ہے) اسے ایلس کو بھیجتی ہے۔ + +کیرول اب بھی ٹریفک کا تجزیہ کر سکتی ہے اور بل-ٹو-باب-ٹو-بیلا-ٹو-ایلس پائپ لائن دیکھ سکتی ہے۔ تاہم، اگر "باب" اور "بیلا" بھی دیگر مقاصد کے لیے ETH کا استعمال کرتے ہیں، تو یہ ظاہر نہیں ہوگا کہ بل نے ایلس کو کچھ بھی منتقل کیا ہے، چاہے ایلس فوری طور پر خفیہ پتے سے اپنے معلوم مہم کے پتے پر رقم نکال لے۔ + +## خفیہ پتے والی ایپلیکیشن لکھنا {#write-app} + +یہ مضمون GitHub پر دستیاب ایک [خفیہ پتے والی ایپلیکیشن](https://github.com/qbzzt/251022-stealth-addresses.git) کی وضاحت کرتا ہے۔ + +### ٹولز {#tools} + +ایک [ٹائپ اسکرپٹ خفیہ پتہ لائبریری](https://github.com/ScopeLift/stealth-address-sdk) ہے جسے ہم استعمال کر سکتے ہیں۔ تاہم، کریپٹوگرافک آپریشنز CPU-انٹینسیو ہو سکتے ہیں۔ میں انہیں ایک کمپائلڈ زبان، جیسے [Rust](https://rust-lang.org/) میں نافذ کرنے کو ترجیح دیتا ہوں، اور براؤزر میں کوڈ چلانے کے لیے [WASM](https://webassembly.org/) کا استعمال کرتا ہوں۔ + +ہم [Vite](https://vite.dev/) اور [React](https://react.dev/) کا استعمال کرنے جا رہے ہیں۔ یہ انڈسٹری کے معیاری ٹولز ہیں؛ اگر آپ ان سے واقف نہیں ہیں، تو آپ [یہ ٹیوٹوریل](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) استعمال کر سکتے ہیں۔ Vite استعمال کرنے کے لیے، ہمیں Node کی ضرورت ہے۔ + +### خفیہ پتوں کو عمل میں دیکھیں {#in-action} + +1. ضروری ٹولز انسٹال کریں: [Rust](https://rust-lang.org/tools/install/) اور [Node](https://nodejs.org/en/download)۔ + +2. GitHub ریپوزٹری کو کلون کریں۔ + + ```sh + git clone https://github.com/qbzzt/251022-stealth-addresses.git + cd 251022-stealth-addresses + ``` + +3. پیشگی شرائط انسٹال کریں اور Rust کوڈ کو کمپائل کریں۔ + + ```sh + cd src/rust-wasm + rustup target add wasm32-unknown-unknown + cargo install wasm-pack + wasm-pack build --target web + ``` + +4. ویب سرور شروع کریں۔ + + ```sh + cd ../.. + npm install + npm run dev + ``` + +5. [ایپلیکیشن](http://localhost:5173/) پر براؤز کریں۔ اس ایپلیکیشن پیج میں دو فریم ہیں: ایک ایلس کے یوزر انٹرفیس کے لیے اور دوسرا بل کے لیے۔ دونوں فریم آپس میں بات چیت نہیں کرتے؛ وہ صرف سہولت کے لیے ایک ہی صفحے پر ہیں۔ + +6. ایلس کے طور پر، **ایک خفیہ میٹا ایڈریس بنائیں** پر کلک کریں۔ یہ نیا خفیہ پتہ اور متعلقہ پرائیویٹ کیز دکھائے گا۔ خفیہ میٹا ایڈریس کو کلپ بورڈ پر کاپی کریں۔ + +7. بل کے طور پر، نیا خفیہ میٹا ایڈریس پیسٹ کریں اور **ایک پتہ بنائیں** پر کلک کریں۔ یہ آپ کو ایلس کے لیے فنڈ کرنے کا پتہ دیتا ہے۔ + +8. پتہ اور بل کی پبلک کی کاپی کریں اور انہیں ایلس کے یوزر انٹرفیس کے "بل کے ذریعے بنائے گئے پتے کے لیے پرائیویٹ کی" والے حصے میں پیسٹ کریں۔ ایک بار جب وہ فیلڈز بھر جائیں گے، تو آپ اس پتے پر اثاثوں تک رسائی کے لیے پرائیویٹ کی دیکھیں گے۔ + +9. آپ [ایک آن لائن کیلکولیٹر](https://iancoleman.net/ethereum-private-key-to-address/) کا استعمال کر سکتے ہیں تاکہ یہ یقینی بنایا جا سکے کہ پرائیویٹ کی پتے سے مطابقت رکھتی ہے۔ + +### پروگرام کیسے کام کرتا ہے {#how-the-program-works} + +#### WASM جزو {#wasm} + +وہ سورس کوڈ جو WASM میں کمپائل ہوتا ہے [Rust](https://rust-lang.org/) میں لکھا گیا ہے۔ آپ اسے [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs) میں دیکھ سکتے ہیں۔ یہ کوڈ بنیادی طور پر جاوا اسکرپٹ کوڈ اور [`eth-stealth-addresses` لائبریری](https://github.com/kassandraoftroy/eth-stealth-addresses) کے درمیان ایک انٹرفیس ہے۔ + +**`Cargo.toml`** + +Rust میں [`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) جاوا اسکرپٹ میں [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) کے مترادف ہے۔ اس میں پیکیج کی معلومات، انحصاری اعلانات وغیرہ شامل ہیں۔ + +```toml +[package] +name = "rust-wasm" +version = "0.1.0" +edition = "2024" + +[dependencies] +eth-stealth-addresses = "0.1.0" +hex = "0.4.3" +wasm-bindgen = "0.2.104" +getrandom = { version = "0.2", features = ["js"] } +``` + +[`getrandom`](https://docs.rs/getrandom/latest/getrandom/) پیکیج کو بے ترتیب اقدار پیدا کرنے کی ضرورت ہے۔ یہ خالص الگورتھمک طریقوں سے نہیں کیا جا سکتا؛ اسے اینٹروپی کے منبع کے طور پر ایک طبعی عمل تک رسائی کی ضرورت ہوتی ہے۔ یہ تعریف بتاتی ہے کہ ہم اس اینٹروپی کو اس براؤزر سے پوچھ کر حاصل کریں گے جس میں ہم چل رہے ہیں۔ + +```toml +console_error_panic_hook = "0.1.7" +``` + +[یہ لائبریری](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) ہمیں مزید معنی خیز غلطی کے پیغامات دیتی ہے جب WASM کوڈ پینک کرتا ہے اور جاری نہیں رہ سکتا۔ + +```toml +[lib] +crate-type = ["cdylib", "rlib"] +``` + +WASM کوڈ تیار کرنے کے لیے درکار آؤٹ پٹ قسم۔ + +**`lib.rs`** + +یہ اصل Rust کوڈ ہے۔ + +```rust +use wasm_bindgen::prelude::*; +``` + +Rust سے WASM پیکیج بنانے کی تعریفیں۔ وہ [یہاں](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html) دستاویزی ہیں۔ + +```rust +use eth_stealth_addresses::{ + generate_stealth_meta_address, + generate_stealth_address, + compute_stealth_key +}; +``` + +وہ فنکشنز جن کی ہمیں [`eth-stealth-addresses` لائبریری](https://github.com/kassandraoftroy/eth-stealth-addresses) سے ضرورت ہے۔ + +```rust +use hex::{decode,encode}; +``` + +Rust عام طور پر اقدار کے لیے بائٹ [ایریز](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; ]`) کا استعمال کرتا ہے۔ لیکن جاوا اسکرپٹ میں، ہم عام طور پر ہیکسا ڈیسیمل اسٹرنگز کا استعمال کرتے ہیں۔ [`ہیکس` لائبریری](https://docs.rs/hex/latest/hex/) ہمارے لیے ایک نمائندگی سے دوسری میں ترجمہ کرتی ہے۔ + +```rust +#[wasm_bindgen] +``` + +جاوا اسکرپٹ سے اس فنکشن کو کال کرنے کے قابل ہونے کے لیے WASM بائنڈنگز بنائیں۔ + +```rust +pub fn wasm_generate_stealth_meta_address() -> String { +``` + +متعدد فیلڈز والے آبجیکٹ کو واپس کرنے کا سب سے آسان طریقہ JSON اسٹرنگ واپس کرنا ہے۔ + +```rust + let (address, spend_private_key, view_private_key) = + generate_stealth_meta_address(); +``` + +[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) تین فیلڈز واپس کرتا ہے: + +- میٹا ایڈریس (_Kpub_ اور _Vpub_) +- ویونگ پرائیویٹ کی (_Vpriv_) +- اسپینڈنگ پرائیویٹ کی (_Kpriv_) + +[ٹیوپل](https://doc.rust-lang.org/std/primitive.tuple.html) سنٹیکس ہمیں ان اقدار کو دوبارہ الگ کرنے دیتا ہے۔ + +```rust + format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}", + encode(address), + encode(view_private_key), + encode(spend_private_key) + ) +} +``` + +JSON-انکوڈڈ اسٹرنگ بنانے کے لیے [`format!`](https://doc.rust-lang.org/std/fmt/index.html) میکرو کا استعمال کریں۔ ایریز کو ہیکس اسٹرنگز میں تبدیل کرنے کے لیے [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html) کا استعمال کریں۔ + +```rust +fn str_to_array(s: &str) -> Option<[u8; N]> { +``` + +یہ فنکشن ایک ہیکس اسٹرنگ (جو جاوا اسکرپٹ کے ذریعے فراہم کی گئی ہے) کو بائٹ ایرے میں بدل دیتا ہے۔ ہم اسے جاوا اسکرپٹ کوڈ کے ذریعے فراہم کردہ اقدار کو پارس کرنے کے لیے استعمال کرتے ہیں۔ یہ فنکشن اس لیے پیچیدہ ہے کہ Rust ایریز اور ویکٹرز کو کیسے ہینڈل کرتا ہے۔ + +`` ایکسپریشن کو [جینرک](https://doc.rust-lang.org/book/ch10-01-syntax.html) کہا جاتا ہے۔ `N` ایک پیرامیٹر ہے جو واپس آنے والی ایرے کی لمبائی کو کنٹرول کرتا ہے۔ فنکشن کو دراصل `str_to_array::` کہا جاتا ہے، جہاں `n` ایرے کی لمبائی ہے۔ + +واپسی کی قدر `Option<[u8; N]>` ہے، جس کا مطلب ہے کہ واپس آنے والی ایرے [اختیاری](https://doc.rust-lang.org/std/option/) ہے۔ یہ Rust میں ان فنکشنز کے لیے ایک عام پیٹرن ہے جو ناکام ہو سکتے ہیں۔ + +مثال کے طور پر، اگر ہم `str_to_array::10("bad060a7")` کو کال کرتے ہیں، تو فنکشن کو دس-ویلیو ایرے واپس کرنا چاہیے، لیکن ان پٹ صرف چار بائٹس ہے۔ فنکشن کو ناکام ہونے کی ضرورت ہے، اور یہ `None` واپس کرکے ایسا کرتا ہے۔ `str_to_array::4("bad060a7")` کے لیے واپسی کی قدر `Some<[0xba, 0xd0, 0x60, 0xa7]>` ہوگی۔ + +```rust + // decode returns Result, _> + let vec = decode(s).ok()?; +``` + +[`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) فنکشن `Result, FromHexError>` واپس کرتا ہے۔ [`Result`](https://doc.rust-lang.org/std/result/) قسم میں یا تو ایک کامیاب نتیجہ (`Ok(value)`) یا ایک خرابی (`Err(error)`) ہو سکتی ہے۔ + +.ok()`طریقہ`Result`کو ایک`Option`میں بدل دیتا ہے، جس کی قدر یا تو کامیاب ہونے پر`Ok()`کی قدر ہوتی ہے یا`None`اگر نہیں۔ آخر میں، [سوالیہ نشان آپریٹر](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) موجودہ فنکشنز کو ختم کر دیتا ہے اور اگر`Option`خالی ہو تو`None`واپس کرتا ہے۔ بصورت دیگر، یہ قدر کو ان ریپ کرتا ہے اور اسے واپس کرتا ہے (اس صورت میں،`vec` کو ایک قدر تفویض کرنے کے لیے)۔ + +یہ غلطیوں کو سنبھالنے کا ایک عجیب و غریب طریقہ لگتا ہے، لیکن `Result` اور `Option` اس بات کو یقینی بناتے ہیں کہ تمام غلطیوں کو کسی نہ کسی طریقے سے سنبھالا جائے۔ + +```rust + if vec.len() != N { return None; } +``` + +اگر بائٹس کی تعداد غلط ہے، تو یہ ایک ناکامی ہے، اور ہم `None` واپس کرتے ہیں۔ + +```rust + // try_into consumes vec and attempts to make [u8; N] + let array: [u8; N] = vec.try_into().ok()?; +``` + +Rust میں دو ایرے کی قسمیں ہیں۔ [ایریز](https://doc.rust-lang.org/std/primitive.array.html) کا ایک مقررہ سائز ہوتا ہے۔ [ویکٹرز](https://doc.rust-lang.org/std/vec/index.html) بڑھ اور سکڑ سکتے ہیں۔ `hex::decode` ایک ویکٹر واپس کرتا ہے، لیکن `eth_stealth_addresses` لائبریری ایریز وصول کرنا چاہتی ہے۔ [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) ایک قدر کو دوسری قسم میں تبدیل کرتا ہے، مثال کے طور پر، ایک ویکٹر کو ایک ایرے میں۔ + +```rust + Some(array) +} +``` + +Rust کو فنکشن کے آخر میں قدر واپس کرتے وقت [`return`](https://doc.rust-lang.org/std/keyword.return.html) کلیدی لفظ استعمال کرنے کی ضرورت نہیں ہوتی۔ + +```rust +#[wasm_bindgen] +pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option { +``` + +یہ فنکشن ایک پبلک میٹا ایڈریس وصول کرتا ہے، جس میں _Vpub_ اور _Kpub_ دونوں شامل ہیں۔ یہ خفیہ پتہ، شائع کرنے کے لیے پبلک کی (_Rpub_)، اور ایک بائٹ کی اسکین ویلیو واپس کرتا ہے جو اس شناخت کو تیز کرتی ہے کہ کون سے شائع شدہ پتے ایلس سے تعلق رکھتے ہیں۔ + +اسکین ویلیو مشترکہ راز (_S = GRprivVpriv_) کا حصہ ہے۔ یہ قدر ایلس کو دستیاب ہے، اور اسے چیک کرنا اس بات کی جانچ سے بہت تیز ہے کہ آیا _f(Kpub+G\*hash(S))_ شائع شدہ پتے کے برابر ہے۔ + +```rust + let (address, r_pub, scan) = + generate_stealth_address(&str_to_array::<66>(stealth_address)?); +``` + +ہم لائبریری کے [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) کا استعمال کرتے ہیں۔ + +```rust + format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}", + encode(address), + encode(r_pub), + encode(&[scan]) + ).into() +} +``` + +JSON-انکوڈڈ آؤٹ پٹ اسٹرنگ تیار کریں۔ + +```rust +#[wasm_bindgen] +pub fn wasm_compute_stealth_key( + address: &str, + bill_pub_key: &str, + view_private_key: &str, + spend_private_key: &str +) -> Option { + . + . + . +} +``` + +یہ فنکشن لائبریری کے [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html) کا استعمال کرتا ہے تاکہ پتے (_Rpriv_) سے رقم نکالنے کے لیے پرائیویٹ کی کا حساب لگایا جا سکے۔ اس حساب کے لیے ان اقدار کی ضرورت ہے: + +- پتہ (_Address=f(Ppub)_) +- بل کے ذریعے بنائی گئی پبلک کی (_Rpub_) +- ویو پرائیویٹ کی (_Vpriv_) +- اسپینڈ پرائیویٹ کی (_Kpriv_) + +```rust +#[wasm_bindgen(start)] +``` + +[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) بتاتا ہے کہ فنکشن اس وقت عمل میں لایا جاتا ہے جب WASM کوڈ شروع ہوتا ہے۔ + +```rust +pub fn main() { + console_error_panic_hook::set_once(); +} +``` + +یہ کوڈ بتاتا ہے کہ پینک آؤٹ پٹ کو جاوا اسکرپٹ کنسول پر بھیجا جائے۔ اسے عمل میں دیکھنے کے لیے، ایپلیکیشن کا استعمال کریں اور بل کو ایک غلط میٹا ایڈریس دیں (صرف ایک ہیکسا ڈیسیمل ہندسہ تبدیل کریں)۔ آپ کو جاوا اسکرپٹ کنسول میں یہ خرابی نظر آئے گی: + +``` +rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9: +assertion `left == right` failed + left: 0 + right: 1 +``` + +اس کے بعد ایک اسٹیک ٹریس ہوتا ہے۔ پھر بل کو درست میٹا ایڈریس دیں، اور ایلس کو یا تو غلط پتہ یا غلط پبلک کی دیں۔ آپ کو یہ خرابی نظر آئے گی: + +``` +rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9: +keys do not generate stealth address +``` + +دوبارہ، اس کے بعد ایک اسٹیک ٹریس ہوتا ہے۔ + +#### یوزر انٹرفیس {#ui} + +یوزر انٹرفیس [React](https://react.dev/) کا استعمال کرتے ہوئے لکھا گیا ہے اور [Vite](https://vite.dev/) کے ذریعے پیش کیا جاتا ہے۔ آپ [اس ٹیوٹوریل](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) کا استعمال کرتے ہوئے ان کے بارے میں جان سکتے ہیں۔ یہاں [WAGMI](https://wagmi.sh/) کی کوئی ضرورت نہیں ہے کیونکہ ہم براہ راست بلاک چین یا والیٹ کے ساتھ تعامل نہیں کرتے ہیں۔ + +یوزر انٹرفیس کا واحد غیر واضح حصہ WASM کنیکٹیویٹی ہے۔ یہ اس طرح کام کرتا ہے۔ + +**`vite.config.js`** + +اس فائل میں [Vite کنفیگریشن](https://vite.dev/config/) شامل ہے۔ + +```js +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' +import wasm from "vite-plugin-wasm"; + +// https://vite.dev/config/ +export default defineConfig({ + plugins: [react(), wasm()], +}) +``` + +ہمیں دو Vite پلگ انز کی ضرورت ہے: [react](https://www.npmjs.com/package/@vitejs/plugin-react) اور [wasm](https://github.com/Menci/vite-plugin-wasm#readme)۔ + +**`App.jsx`** + +یہ فائل ایپلیکیشن کا مرکزی جزو ہے۔ یہ ایک کنٹینر ہے جس میں دو اجزاء شامل ہیں: `Alice` اور `Bill`، ان صارفین کے لیے یوزر انٹرفیس۔ WASM کے لیے متعلقہ حصہ انیشیلائزیشن کوڈ ہے۔ + +```jsx +import init from './rust-wasm/pkg/rust_wasm.js' +``` + +جب ہم [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/) استعمال کرتے ہیں، تو یہ دو فائلیں بناتا ہے جنہیں ہم یہاں استعمال کرتے ہیں: اصل کوڈ کے ساتھ ایک wasm فائل (یہاں، `src/rust-wasm/pkg/rust_wasm_bg.wasm`) اور اسے استعمال کرنے کی تعریفوں کے ساتھ ایک جاوا اسکرپٹ فائل (یہاں، `src/rust_wasm/pkg/rust_wasm.js`)۔ اس جاوا اسکرپٹ فائل کا ڈیفالٹ ایکسپورٹ وہ کوڈ ہے جسے WASM شروع کرنے کے لیے چلانے کی ضرورت ہے۔ + +```jsx +function App() { + . + . + . + useEffect(() => { + const loadWasm = async () => { + try { + await init(); + setWasmReady(true) + } catch (err) { + console.error('Wasm لوڈ کرنے میں خرابی:', err) + alert("Wasm خرابی: " + err) + } + } + + loadWasm() + }, [] + ) +``` + +[`useEffect` ہک](https://react.dev/reference/react/useEffect) آپ کو ایک فنکشن کی وضاحت کرنے دیتا ہے جو اس وقت عمل میں لایا جاتا ہے جب اسٹیٹ متغیرات تبدیل ہوتے ہیں۔ یہاں، اسٹیٹ متغیرات کی فہرست خالی ہے (`[]`)، لہذا یہ فنکشن صرف ایک بار عمل میں لایا جاتا ہے جب صفحہ لوڈ ہوتا ہے۔ + +اثر فنکشن کو فوری طور پر واپس آنا ہوتا ہے۔ غیر مطابقت پذیر کوڈ، جیسے WASM `init` (جسے `.wasm` فائل لوڈ کرنا پڑتا ہے اور اس لیے وقت لگتا ہے) استعمال کرنے کے لیے ہم ایک اندرونی [`async`](https://en.wikipedia.org/wiki/Async/await) فنکشن کی وضاحت کرتے ہیں اور اسے `await` کے بغیر چلاتے ہیں۔ + +**`Bill.jsx`** + +یہ بل کے لیے یوزر انٹرفیس ہے۔ اس کا ایک ہی عمل ہے، ایلس کے ذریعے فراہم کردہ خفیہ میٹا ایڈریس کی بنیاد پر ایک پتہ بنانا۔ + +```jsx +import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js' +``` + +ڈیفالٹ ایکسپورٹ کے علاوہ، `wasm-pack` کے ذریعے تیار کردہ جاوا اسکرپٹ کوڈ WASM کوڈ میں ہر فنکشن کے لیے ایک فنکشن ایکسپورٹ کرتا ہے۔ + +```jsx +