feat(webhook): add webhook

.vscode/settings.json

@@ -4,17 +4,21 @@
     "editor.defaultFormatter": "dbaeumer.vscode-eslint"
   },
   "[typescriptreact]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
   },
   "eslint.workingDirectories": [
-    { "directory": "packages/contracts", "changeProcessCWD": true }
+    {
+      "directory": "packages/contracts",
+      "changeProcessCWD": true
+    }
   ],
   "eslint.nodePath": "./node_modules/eslint/bin/",
   "eslint.format.enable": true,
   "editorconfig.generateAuto": false,
   "files.trimTrailingWhitespace": true,
   "solidity.packageDefaultDependenciesContractsDirectory": "contracts",
   "solidity.packageDefaultDependenciesDirectory": "lib",
-  "solidity.compileUsingRemoteVersion": "v0.8.17",
-  "solidity.formatter": "prettier"
-}
+  "solidity.compileUsingRemoteVersion": "v0.8.17+commit.8df45f5f",
+  "solidity.formatter": "prettier",
+  "solidity.defaultCompiler": "remote"
+}

contrib/screener-api/client/client.go

@@ -3,17 +3,28 @@
 
 import (
 	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
+	"strings"
+	"time"
+
 	"github.com/dubonzi/otelresty"
 	"github.com/go-resty/resty/v2"
 	"github.com/google/uuid"
 	"github.com/synapsecns/sanguine/core/ginhelper"
 	"github.com/synapsecns/sanguine/core/metrics"
 )
 
+var (
+	BlacklistEndpoint = "/api/data/sync/"
+)
+
 // ScreenerClient is an interface for the Screener API.
 type ScreenerClient interface {
 	ScreenAddress(ctx context.Context, ruleset, address string) (blocked bool, err error)
+	BlacklistAddress(ctx context.Context, body BlackListBody) (string, error)
 }
 
 type clientImpl struct {
@@ -54,6 +65,58 @@
 	return blockedRes.Blocked, nil
 }
 
+type BlackListBody struct {
+	TypeReq string `json:"typereq"`
+	Id      string `json:"id"`
+	Data    string `json:"data"`
+	Address string `json:"address"`
+	Network string `json:"network"`
+	Tag     string `json:"tag"`
+	Remark  string `json:"remark"`
+}
+
+type blacklistResponse struct {
+	Status string `json:"status"`
+	Error  string `json:"error"`
+}
+
+func (c clientImpl) BlacklistAddress(ctx context.Context, body BlackListBody) (string, error) {
+	var blacklistRes blacklistResponse
+
+	// TODO: remove, just for testing purposes
+	// future, take it from some .env or something
+	appsecret := "appsecret"
+	appid := "appid"
+
+	nonce := strings.Replace(uuid.New().String(), "-", "", -1)[:32]
+	timestamp := fmt.Sprintf("%d", time.Now().Unix())
+	queryString := "" // there is no query string in this post request, ask about this
+
+	signature := GenerateSignature(appsecret, appid, timestamp, nonce, queryString, body)
+
+	resp, err := c.rClient.R().
+		SetContext(ctx).
+		SetHeader("Content-Type", "application/json").
+		SetHeader("appid", appid).
+		SetHeader("timestamp", timestamp).
+		SetHeader("nonce", nonce).
+		SetHeader("queryString", queryString).
+		SetHeader("signature", signature).
+		SetResult(&blacklistRes).
+		SetBody(body).
+		Post(BlacklistEndpoint)
+
+	if err != nil {
+		return resp.Status(), fmt.Errorf("error from server: %s: %w", resp.String(), err)
+	}
+
+	if resp.IsError() {
+		return resp.Status(), fmt.Errorf("error from server: %s", resp.String())
+	}
+
+	return blacklistRes.Status, nil
+}
+
 // NewNoOpClient creates a new no-op client for the Screener API.
 // it returns false for every address.
 func NewNoOpClient() (ScreenerClient, error) {
@@ -66,4 +129,35 @@
 	return false, nil
 }
 
+func (n noOpClient) BlacklistAddress(_ context.Context, _ BlackListBody) (string, error) {
+	return "", nil
+}
+
+func GenerateSignature(secret string,
+	appid string,
+	timestamp string,
+	nonce string,
+	queryString string,
+	body BlackListBody,
+) string {
+	key := []byte(secret)
+
+	// concatenate the body
+	message := fmt.Sprintf(
+		"%s%s%s%s%s%s%s",
+		appid,
+		timestamp,
+		nonce,
+		"POST",
+		BlacklistEndpoint,
+		queryString,
+		body,
+	)
+	h := hmac.New(sha256.New, key)
+	// hash it
+	h.Write([]byte(message))
+
+	return strings.ToLower(hex.EncodeToString(h.Sum(nil)))
+}
+
 var _ ScreenerClient = noOpClient{}

contrib/screener-api/db/db.go

@@ -4,10 +4,27 @@
 import (
 	"context"
 	"errors"
-	"github.com/synapsecns/sanguine/contrib/screener-api/trmlabs"
 	"time"
+
+	"github.com/synapsecns/sanguine/contrib/screener-api/trmlabs"
 )
 
+// TODO: make a general db interface.
+type BlacklistedAddressWriterDB interface {
+	PutBlacklistedAddress(ctx context.Context, body BlacklistedAddress) error
+	DeleteBlacklistedAddress(ctx context.Context, id string) error
+	UpdateBlacklistedAddress(ctx context.Context, id string, body BlacklistedAddress) error
+}
+
+type BlacklistedAddressReaderDB interface {
+	GetBlacklistedAddress(ctx context.Context, address string) (*BlacklistedAddress, error)
+}
+
+type BlacklistedAddressDB interface {
+	BlacklistedAddressWriterDB
+	BlacklistedAddressReaderDB
+}
+
 // RuleWriterDB is the interface for writing rules to the database.
 type RuleWriterDB interface {
 	PutAddressIndicators(ctx context.Context, address string, riskIndicator []trmlabs.AddressRiskIndicator) error
@@ -24,5 +41,11 @@
 	RuleReaderDB
 }
 
+// DB is the general database interface for the screener-api
+type DB interface {
+	BlacklistedAddressDB
+	RuleDB
+}
+
 // ErrNoAddressNotCached is returned when an address is not cached.
 var ErrNoAddressNotCached = errors.New("address not cached")

contrib/screener-api/db/db_test.go

@@ -1,14 +1,16 @@
 package db_test
 
 import (
+	"time"
+
 	"github.com/brianvoe/gofakeit/v6"
 	"github.com/synapsecns/sanguine/contrib/screener-api/db"
 	"github.com/synapsecns/sanguine/contrib/screener-api/trmlabs"
-	"time"
+	"gorm.io/gorm"
 )
 
 func (d *DBSuite) TestEmpty() {
-	d.RunOnAllDBs(func(testDB db.RuleDB) {
+	d.RunOnAllDBs(func(testDB db.DB) {
 		testAddress := gofakeit.BitcoinAddress()
 
 		// 5 mins ago
@@ -28,8 +30,8 @@ func (d *DBSuite) TestEmpty() {
 	})
 }
 
-func (d *DBSuite) TestAdressUpdate() {
-	d.RunOnAllDBs(func(testDB db.RuleDB) {
+func (d *DBSuite) TestAddressUpdate() {
+	d.RunOnAllDBs(func(testDB db.DB) {
 		testAddress := gofakeit.BitcoinAddress()
 
 		// 5 mins ago
@@ -64,3 +66,52 @@ func (d *DBSuite) TestAdressUpdate() {
 		d.Require().Error(err, db.ErrNoAddressNotCached)
 	})
 }
+
+func (d *DBSuite) TestBlacklist() {
+	d.RunOnAllDBs(func(testDB db.DB) {
+
+		testAddress := gofakeit.BitcoinAddress()
+
+		blacklistBody := db.BlacklistedAddress{
+			TypeReq: "create",
+			Id:      "testId",
+			Address: testAddress,
+			Network: "bitcoin",
+			Tag:     "testTag",
+			Remark:  "testRemark",
+		}
+
+		// blacklist the address
+		err := testDB.PutBlacklistedAddress(d.GetTestContext(), blacklistBody)
+		d.Require().NoError(err)
+		blacklistedAddress, err := testDB.GetBlacklistedAddress(d.GetTestContext(), blacklistBody.Address)
+		d.Require().NoError(err)
+		d.Require().NotNil(blacklistedAddress)
+
+		// update the address
+		blacklistBody.TypeReq = "update"
+		blacklistBody.Remark = "testRemarkUpdated"
+		err = testDB.UpdateBlacklistedAddress(d.GetTestContext(), blacklistBody.Id, blacklistBody)
+		d.Require().NoError(err)
+
+		// check to make sure it updated
+		blacklistedAddress, err = testDB.GetBlacklistedAddress(d.GetTestContext(), blacklistBody.Address)
+		d.Require().NoError(err)
+		d.Require().NotNil(blacklistedAddress)
+		d.Require().Equal("testRemarkUpdated", blacklistedAddress.Remark)
+
+		// check for non blacklisted address
+		res, err := testDB.GetBlacklistedAddress(d.GetTestContext(), gofakeit.BitcoinAddress())
+		d.Require().EqualError(err, gorm.ErrRecordNotFound.Error())
+		d.Require().Nil(res)
+
+		// delete it
+		err = testDB.DeleteBlacklistedAddress(d.GetTestContext(), blacklistBody.Id)
+		d.Require().NoError(err)
+
+		// delete nonexistent
+		err = testDB.DeleteBlacklistedAddress(d.GetTestContext(), "NonexistentId")
+		d.Require().NoError(err)
+
+	})
+}

contrib/screener-api/db/models.go

@@ -8,12 +8,61 @@
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/synapsecns/sanguine/contrib/screener-api/trmlabs"
-	"gorm.io/gorm/schema"
 	"strings"
 	"time"
+
+	"github.com/synapsecns/sanguine/contrib/screener-api/trmlabs"
+	"gorm.io/gorm/schema"
 )
 
+// BlacklistedAddress is a blacklisted address.
+type BlacklistedAddress struct {
+	CreatedAt time.Time
+	UpdatedAt time.Time
+
+	TypeReq string `gorm:"column:typereq"`
+	Id      string `gorm:"column:id;primary_key"`
+	Data    string `gorm:"column:data"`
+	Address string `gorm:"column:address"`
+	Network string `gorm:"column:network"`
+	Tag     string `gorm:"column:tag"`
+	Remark  string `gorm:"column:remark"`
+}
+
+func (b BlacklistedAddress) GormDataType() string {
+	return "json"
+}
+
+func (b BlacklistedAddress) Value() (driver.Value, error) {
+	if b == (BlacklistedAddress{}) {
+		return nil, nil
+	}
+	ba, err := json.Marshal(b)
+	return string(ba), err
+}
+
+func (b *BlacklistedAddress) Scan(val interface{}) error {
+	if val == nil {
+		*b = BlacklistedAddress{}
+		return nil
+	}
+	var ba []byte
+	switch v := val.(type) {
+	case []byte:
+		ba = v
+	case string:
+		ba = []byte(v)
+	default:
+		return errors.New(fmt.Sprint("Failed to unmarshal JSONB value:", val))
+	}
+	rd := bytes.NewReader(ba)
+	decoder := json.NewDecoder(rd)
+	decoder.UseNumber()
+	err := decoder.Decode(b)
+	//nolint: wrapcheck
+	return err
+}
+
 // AddressIndicators is the address indicators for a given address.
 type AddressIndicators struct {
 	CreatedAt time.Time
@@ -93,3 +142,7 @@
 var _ schema.GormDataTypeInterface = addressRiskIndicators{}
 var _ driver.Value = addressRiskIndicators{}
 var _ sql.Scanner = &addressRiskIndicators{}
+
+var _ schema.GormDataTypeInterface = BlacklistedAddress{}
+var _ driver.Value = BlacklistedAddress{}
+var _ sql.Scanner = &BlacklistedAddress{}