update the svr searcher documentation and add code snippets in ts/go (#2542)

* update the svr searcher documentation and add code snippets in ts/go

* nit editorial update

* nit numbering

* nit editorial update

* nit editorial update

* nit editorial update

* update feed addresses

* Implement dynamic fetching of SVR feed addresses

---------

Co-authored-by: Karim <[email protected]>

Author: KMontag42

public/samples/DataFeeds/SVR/broadcaster.go

@@ -0,0 +1,45 @@
+type MevBundle struct {
+    Hash      common.Hash
+    Tx        []byte
+    CanRevert bool
+}
+
+type Inclusion struct {
+    Block       *big.Int
+    MaxBlock    *big.Int
+}
+
+type BundleParams struct {
+    Body []MevBundle
+    inclusion Inclusion
+}
+
+// ... create and sign your transaction
+tx := types.NewTransaction(...)
+signedTx, err := types.SignTx(tx, ...)
+txBytes := signedTx.MarshalBinary()
+
+bundle := []MevBundle {
+    {
+        Hash: event.EventHash,
+    },
+    {
+        Tx:        &txBytes,
+        CanRevert: false,
+    },
+}
+
+params := BundleParams {
+    Body:      bundle,
+    Inclusion: Inclusion{blockNumber, blockNumber+1},
+}
+
+byteParams, err := json.Marshal(params)
+body := []byte(fmt.Sprintf(`{"jsonrpc":"2.0","method":"mev_sendBundle","params":["%s"], "id":1}`, string(byteParams)))
+bodyReader := bytes.NewReader(body)
+postReq, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://relay.flashbots.net/", bodyReader)
+
+hashedBody := crypto.Keccak256Hash(body).Hex()
+signedMessage, err := crypto.Sign(accounts.TextHash([]byte(hashedBody)), privKey)
+postReq.Header.Add("X-Flashbots-signature", address.String()+":"+hexutil.Encode(signedMessage))
+resp, err := http.DefaultClient.Do(postReq)

public/samples/DataFeeds/SVR/broadcaster.ts

@@ -0,0 +1,20 @@
+async function sendBackrunBundle(pendingTx: IPendingTransaction) {
+  const currentBlock = await provider.getBlockNumber()
+  const signedBackrunTx = await buildDummyBackrunTx(pendingTx)
+  const bundleParams: BundleParams = {
+    inclusion: {
+      block: currentBlock + 1,
+      maxBlock: currentBlock + TARGET_BUNDLE_BLOCK_DELAY,
+    },
+    body: [{ hash: pendingTx.hash }, { tx: signedBackrunTx, canRevert: false }],
+  }
+
+  const sendBundleResult = await mevShareClient.sendBundle(bundleParams)
+  return sendBundleResult
+}
+
+async function buildDummyBackrunTx(pendingTx: IPendingTransaction) {
+  const backrunTx = { data: {}, maxFeePerGas: 22000, maxPriorityFeePerGas: 22000 }
+  const signedBackrunTx = await executorWallet.signTransaction(backrunTx)
+  return signedBackrunTx
+}

public/samples/DataFeeds/SVR/decoder.go

@@ -0,0 +1,46 @@
+decoded, err := hex.DecodeString(strings.TrimPrefix(strings.ToLower(tx.CallData), "0x"))
+contractAddress := "0x" + strings.ToLower(strings.TrimLeft(hex.EncodeToString(decoded[4:36]), "0"))
+
+ff := strings.ToLower(strings.TrimLeft(hex.EncodeToString(decoded[100:104]), "0"))
+if strings.Compare(ff, "ba0cb29e") != 0 {
+return nil, fmt.Errorf("event doesn't invoke svr method: ba0cb29e, instead: %s", ff)
+}
+
+transmitSecondaryElems := make(map[string]interface{})
+err := getTransmissionTypes().UnpackIntoMap(transmitSecondaryElems, decoded[104:])
+
+report, exists := transmitSecondaryElems["report"]
+return MedianFromReport(report.([]byte))
+
+func MedianFromReport(report []byte) (*big.Int, error) {
+	reportElems := map[string]interface{}{}
+	err := getReportTypes().UnpackIntoMap(reportElems, report)
+	observationsIface, ok := reportElems["observations"]
+	observations, ok := observationsIface.([]*big.Int)
+	median := observations[len(observations)/2]
+	return median, nil
+}
+
+func getReportTypes() abi.Arguments {
+	return abi.Arguments([]abi.Argument{
+		{Name: "observationsTimestamp", Type: mustNewType("uint32")},
+		{Name: "rawObservers", Type: mustNewType("bytes32")},
+		{Name: "observations", Type: mustNewType("int192[]")},
+		{Name: "juelsPerFeeCoin", Type: mustNewType("int192")},
+	})
+}
+
+func getTransmissionTypes() abi.Arguments {
+	return abi.Arguments([]abi.Argument{
+		{Name: "reportContext", Type: mustNewType("bytes32[3]")},
+		{Name: "report", Type: mustNewType("bytes")},
+		{Name: "rs", Type: mustNewType("bytes32[]")},
+		{Name: "ss", Type: mustNewType("bytes32[]")},
+		{Name: "rawVs", Type: mustNewType("bytes32")},
+	})
+}
+
+func mustNewType(t string) abi.Type {
+	result, err := abi.NewType(t, "", nil)
+	return result
+}

public/samples/DataFeeds/SVR/decoder.ts

@@ -0,0 +1,42 @@
+const decodeInterface = new ethers.Interface(EXAMPLE_ABI)
+
+function decodeForwarderCall(callData: string) {
+  const decodedForward = decodeInterface.decodeFunctionData("forward", callData)
+  return { to: decodedForward[0], callData: decodedForward[1] }
+}
+
+function decodeTransmitSecondary(callData: string) {
+  try {
+    const decodedTransmitSecondary = decodeInterface.decodeFunctionData("transmitSecondary", callData)
+    return { report: decodedTransmitSecondary[1] }
+  } catch (error) {
+    console.error("not transmit secondary call", error)
+    return {}
+  }
+}
+
+function decodeReport(reportRaw: string) {
+  const decodedReport = ethers.AbiCoder.defaultAbiCoder().decode(["uint32", "bytes32", "int192[]", "int192"], reportRaw)
+
+  return { observations: decodedReport[2] }
+}
+
+function updatedPrice(observations: bigint[]) {
+  const medianObservation = observations[Math.floor(observations.length / 2)]
+  return medianObservation
+}
+
+async function processTransaction(pendingTx: IPendingTransaction) {
+  if (pendingTx.functionSelector !== CHAINLINK_PRICE_FEED_FUNCTION_SELECTOR) {
+    return null
+  }
+
+  const { to, callData } = decodeForwarderCall(pendingTx.callData)
+  const { report } = decodeTransmitSecondary(callData)
+  if (report) {
+    const { observations } = decodeReport(report)
+    const newPrice = updatedPrice(observations)
+  }
+
+  // calculate health factors for affected users ...
+}

public/samples/DataFeeds/SVR/decoding-abi.json

@@ -0,0 +1,25 @@
+[
+  {
+    "type": "function",
+    "name": "forward",
+    "inputs": [
+      { "name": "to", "type": "address" },
+      { "name": "callData", "type": "bytes" }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transmitSecondary",
+    "inputs": [
+      { "name": "reportContext", "type": "bytes32[3]", "internalType": "bytes32[3]" },
+      { "name": "report", "type": "bytes", "internalType": "bytes" },
+      { "name": "rs", "type": "bytes32[]", "internalType": "bytes32[]" },
+      { "name": "ss", "type": "bytes32[]", "internalType": "bytes32[]" },
+      { "name": "rawVs", "type": "bytes32", "internalType": "bytes32" }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]

public/samples/DataFeeds/SVR/listener.go

@@ -0,0 +1,30 @@
+type MevShareEvent struct {
+	Hash common.Hash          `json:"hash"`
+	Txs  []PendingTransaction `json:"txs"`
+}
+
+type PendingTransaction struct {
+	To               common.Address `json:"to"`
+	FunctionSelector string         `json:"functionSelector"`
+	CallData         string         `json:"callData"`
+}
+
+req, err := http.NewRequestWithContext(
+  ctx,
+  "GET",
+  "https://mev-share.flashbots.net",
+  nil,
+)
+
+// ... read the event data from the response
+
+var event MevShareEvent
+err := json.Unmarshal(responseData, &event)
+
+// ... check if tx is calling the forward method
+if strings.Compare(
+  strings.ToLower(tx.FunctionSelector),
+  "0x6fadcf72",
+) != 0 {
+	continue
+}

public/samples/DataFeeds/SVR/listener.ts

@@ -0,0 +1,13 @@
+import MevShareClient, { IPendingBundle, IPendingTransaction } from "@flashbots/mev-share-client"
+
+const mevShareClient = MevShareClient.useEthereumMainnet(authSigner)
+
+const txHandler = mevShareClient.on("transaction", async (tx: IPendingTransaction) => {
+  if (tx.functionSelector === "6fadc72") {
+    // Do something with the pending tx here.
+  }
+})
+
+// call before your program terminates:
+txHandler.close()
+bundleHandler.close()