How to subscribe to the event "incoming transaction successful"?

Question

How can I subscribe to the event "incoming transaction successful". That is, I want to know that ether has come to my wallet. How to do it using subscription. I do not understand anything.

package main

import (
  "context"
  "github.com/ethereum/go-ethereum"
  "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/ethclient"
  "log"
)

func main() {
  client, err := ethclient.Dial("wss://mainnet.infura.io/ws/v3/XXXXXXXXXXXXXXXX")
  if err != nil {
    log.Fatal(err)
  }

  accs := map[string]string{
"0x92321477416e93Ea452f16015e2F2a13B3BDe8B7":"12e2cc06fb999fa29306f10db6b366e61a4946b9527286a0c56640c94cebd950",
  }

  keys := make([]common.Address, 0, len(accs))
  for k := range accs {
    keys = append(keys, common.HexToAddress(k))
  }

  var ch = make(chan types.Log)
  sub, err := client.SubscribeFilterLogs(context.Background(), ethereum.FilterQuery{
    BlockHash: nil,
    FromBlock: nil,
    ToBlock:   nil,
    Addresses: keys,
    Topics:    nil,
  }, ch)
  if err != nil {
    log.Fatal(err)
  }
  defer sub.Unsubscribe()

  for l := range ch {
    // ???
  }
}

Help me please. Where i can find example?

enter image description here

Answer 1

I'm looking through infura.io's API documentation and I'm not finding that they have an endpoint for payouts. The image that you linked above is their UI option for email notifications and has nothing to do with the API. In order to subscribe to an action, it would have to be initiated on their end. You would have to provide them with a callback to execute when that action occurs. Your callback would do the alerting, but they would call it when the trigger (a payout) occurred. Do they have a place to enter webhooks? If so, this would be your subscription.

While this option may not be a subscription, a possible workaround would be for you to poll the getBalance endpoint and compare the result to the previous result, and if there is an increase, alert you.

Answer 2

actually go-ethereum already provided a demo in their test script:

import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/ethereum/go-ethereum/ethclient/gethclient"
    "github.com/ethereum/go-ethereum/rpc"
)

const (
    url = "https://mainnet.infura.io/v3/xxxxxxxx"
    wss = "wss://eth-mainnet.alchemyapi.io/v2/xxxxxxxxxxx"
    // wss = "wss://mainnet.infura.io/ws/v3/xxxxxxxx"
)

func watch() {
    backend, err := ethclient.Dial(url)
    if err != nil {
        log.Printf("failed to dial: %v", err)
        return
    }

    rpcCli, err := rpc.Dial(wss)
    if err != nil {
        log.Printf("failed to dial: %v", err)
        return
    }
    gcli := gethclient.New(rpcCli)

    txch := make(chan common.Hash, 100)
    _, err = gcli.SubscribePendingTransactions(context.Background(), txch)
    if err != nil {
        log.Printf("failed to SubscribePendingTransactions: %v", err)
        return
    }
    for {
        select {
        case txhash := <-txch:
            tx, _, err := backend.TransactionByHash(context.Background(), txhash)
            if err != nil {
                continue
            }
            data, _ := tx.MarshalJSON()
            log.Printf("tx: %v", string(data))
        }
    }
}

func DoTest() {
    go watch()
    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
    <-signalChan
}

Answer 3

My solution

sub, err := client.SubscribeNewHead(context.Background(), ch)

get block

b, err := client.BlockByNumber(context.Background(), l.Number)

check all transactions

 for _, tx := range b.Transactions() {
       msg, err := tx.AsMessage(types.NewEIP155Signer(tx.ChainId()))
   }

in msg.To() address )))