Merge pull request #27 from everFinance/pst

Pst

Author: zyjblockchain

README.md

@@ -116,6 +116,7 @@ arClient := goar.NewClient("https://arweave.net", proxyUrl)
 - [x] CreateAndSignBundleItem
 - [x] SendBundleTxSpeedUp
 - [x] SendBundleTx
+- [x] SendPst
 
 Initialize the instance, use a keyfile.json:
 
@@ -324,7 +325,7 @@ bundle, err := utils.NewBundle(items...)
 #### Send Item to Bundler
 Bundler network provides guaranteed data seeding and instant data accessibility
 ```go
-resp, err := w.Client.BatchSendItemToBundler(items)
+resp, err := w.Client.BatchSendItemToBundler(items,"") // The second parameter is the bundler gateway url，"" means use default url
 ```
 
 #### Send Bundle Tx
@@ -343,4 +344,36 @@ for _, item := range bundle.Items {
   assert.NoError(t, err)
 }
 ```
+
+### notice
+if you call `w.Client.BatchSendItemToBundler(items,"")` 
+and return `panic: send to bundler request failed; http code: 402`        
+means that you have to pay ar to the bundler service address    
+must use item signature address to transfer funds   
+
+##### how to get bundler service address?
+```go
+curl --location --request GET 'https://node1.bundlr.network/info'
+
+response:
+{
+"uptime": 275690.552536824,
+"address": "OXcT1sVRSA5eGwt2k6Yuz8-3e3g9WJi5uSE99CWqsBs",
+"gateway": "arweave.net"
+}
+```
+This "address" is the bundler service receive ar address.    
+You need to transfer a certain amount of ar to this address    
+and wait for 25 blocks to confirm the transaction before you can use the bundler service.    
+
+You can also use the following api to query the balance in the bundler service.   
+```
+curl --location --request GET 'https://node1.bundlr.network/account/balance?address=Ii5wAMlLNz13n26nYY45mcZErwZLjICmYd46GZvn4ck'
+
+response:
+{
+    "balance": 1000000000
+}
+```
+
 ---

client.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/inconshreveable/log15"
 	"io/ioutil"
 	"math/big"
 	"net/http"
@@ -13,12 +14,12 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/everFinance/sandy_log/log"
-
 	"github.com/everFinance/goar/types"
 	"github.com/everFinance/goar/utils"
 )
 
+var log = log15.New("module", "goar")
+
 // arweave HTTP API: https://docs.arweave.org/developers/server/http-api
 
 type Client struct {
@@ -33,7 +34,7 @@ func NewClient(nodeUrl string, proxyUrl ...string) *Client {
 		pUrl := proxyUrl[0]
 		proxyUrl, err := url.Parse(pUrl)
 		if err != nil {
-			log.Errorf("url parse error: %v", err)
+			log.Error("url parse", "error", err)
 			panic(err)
 		}
 		tr := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}

client_broadcast.go

@@ -3,8 +3,36 @@ package goar
 import (
 	"errors"
 	"fmt"
+	"github.com/everFinance/goar/types"
 )
 
+func (c *Client) BroadcastData(txId string, data []byte, numOfNodes int64) error {
+	peers, err := c.GetPeers()
+	if err != nil {
+		return err
+	}
+
+	count := int64(0)
+	for _, peer := range peers {
+		arNode := NewClient("http://" + peer)
+		uploader, err := CreateUploader(arNode, txId, data)
+		if err != nil {
+			continue
+		}
+
+		if err = uploader.Once(); err != nil {
+			continue
+		}
+
+		count++
+		if count >= numOfNodes {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("upload tx data to peers failed, txId: %s", txId)
+}
+
 func (c *Client) GetTxDataFromPeers(txId string) ([]byte, error) {
 	peers, err := c.GetPeers()
 	if err != nil {
@@ -15,40 +43,51 @@ func (c *Client) GetTxDataFromPeers(txId string) ([]byte, error) {
 		pNode := NewClient("http://" + peer)
 		data, err := pNode.DownloadChunkData(txId)
 		if err != nil {
-			fmt.Printf("get tx data error:%v, peer: %s\n", err, peer)
+			log.Error("get tx data", "err", err, "peer", peer)
 			continue
 		}
-		fmt.Printf("success get tx data; peer: %s\n", peer)
 		return data, nil
 	}
 
 	return nil, errors.New("get tx data from peers failed")
 }
 
-func (c *Client) BroadcastData(txId string, data []byte, numOfNodes int64) error {
+func (c *Client) GetBlockFromPeers(height int64) (*types.Block, error) {
 	peers, err := c.GetPeers()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	count := int64(0)
 	for _, peer := range peers {
-		fmt.Printf("upload peer: %s, count: %d\n", peer, count)
-		arNode := NewClient("http://" + peer)
-		uploader, err := CreateUploader(arNode, txId, data)
+		pNode := NewClient("http://" + peer)
+		block, err := pNode.GetBlockByHeight(height)
 		if err != nil {
+			fmt.Printf("get block error:%v, peer: %s\n", err, peer)
 			continue
 		}
+		fmt.Printf("success get block; peer: %s\n", peer)
+		return block, nil
+	}
 
-		if err = uploader.Once(); err != nil {
-			continue
-		}
+	return nil, errors.New("get block from peers failed")
+}
 
-		count++
-		if count >= numOfNodes {
-			return nil
+func (c *Client) GetTxFromPeers(arId string) (*types.Transaction, error) {
+	peers, err := c.GetPeers()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, peer := range peers {
+		pNode := NewClient("http://" + peer)
+		tx, err := pNode.GetTransactionByID(arId)
+		if err != nil {
+			fmt.Printf("get tx error:%v, peer: %s\n", err, peer)
+			continue
 		}
+		fmt.Printf("success get tx; peer: %s\n", peer)
+		return tx, nil
 	}
 
-	return fmt.Errorf("upload tx data to peers failed, txId: %s", txId)
+	return nil, errors.New("get tx from peers failed")
 }

client_bundle.go

@@ -20,9 +20,12 @@ func (c *Client) GetBundle(arId string) (*types.Bundle, error) {
 }
 
 // SendItemToBundler send bundle bundleItem to bundler gateway
-func (c *Client) SendItemToBundler(itemBinary []byte) (*types.BundlerResp, error) {
+func (c *Client) SendItemToBundler(itemBinary []byte, gateway string) (*types.BundlerResp, error) {
+	if gateway == "" {
+		gateway = types.BUNDLER_HOST
+	}
 	// post to bundler
-	resp, err := http.DefaultClient.Post(types.BUNDLER_HOST+"/tx", "application/octet-stream", bytes.NewReader(itemBinary))
+	resp, err := http.DefaultClient.Post(gateway+"/tx", "application/octet-stream", bytes.NewReader(itemBinary))
 	if err != nil {
 		return nil, err
 	}
@@ -43,7 +46,7 @@ func (c *Client) SendItemToBundler(itemBinary []byte) (*types.BundlerResp, error
 	return br, nil
 }
 
-func (c *Client) BatchSendItemToBundler(bundleItems []types.BundleItem) ([]*types.BundlerResp, error) {
+func (c *Client) BatchSendItemToBundler(bundleItems []types.BundleItem, gateway string) ([]*types.BundlerResp, error) {
 	respList := make([]*types.BundlerResp, 0, len(bundleItems))
 	for _, item := range bundleItems {
 		itemBinary := item.ItemBinary
@@ -53,7 +56,7 @@ func (c *Client) BatchSendItemToBundler(bundleItems []types.BundleItem) ([]*type
 			}
 			itemBinary = item.ItemBinary
 		}
-		resp, err := c.SendItemToBundler(itemBinary)
+		resp, err := c.SendItemToBundler(itemBinary, gateway)
 		if err != nil {
 			return nil, err
 		}

client_test.go

@@ -1,10 +1,9 @@
 package goar
 
 import (
-	"testing"
-
 	"github.com/everFinance/goar/utils"
 	"github.com/stretchr/testify/assert"
+	"testing"
 )
 
 // import (
@@ -179,9 +178,9 @@ func TestClient_GetTransactionTags(t *testing.T) {
 func TestClient_GetBlockByHeight(t *testing.T) {
 	arNode := "https://arweave.net"
 	cli := NewClient(arNode)
-	block, err := cli.GetBlockByHeight(737432)
+	block, err := cli.GetBlockByHeight(793791)
 	assert.NoError(t, err)
-	assert.Equal(t, "7YeJpe53rFsEE03yKjGcBQAAw6efgVfSeGNLmPRGY4c", block.Nonce)
+	assert.Equal(t, "ci2uJhYmdldgkHbScDClCwAA0eqn7dCduAEpLfRorSA", block.Nonce)
 }
 
 func TestClient_GetTransactionDataByGateway(t *testing.T) {
@@ -228,3 +227,18 @@ func TestClient_BroadcastData(t *testing.T) {
 	err = cli.BroadcastData(txId, data, 20)
 	assert.NoError(t, err)
 }
+
+func TestClient_GetBlockFromPeers(t *testing.T) {
+	cli := NewClient("https://arweave.net")
+	block, err := cli.GetBlockFromPeers(793755)
+	assert.NoError(t, err)
+	t.Log(block.Txs)
+}
+
+func TestClient_GetTxFromPeers(t *testing.T) {
+	cli := NewClient("https://arweave.net")
+	arId := "kPKtoTyn-HVvLQ9ml12YLqrYbpbzVpp2wk_bqxUtXQs"
+	tx, err := cli.GetTxFromPeers(arId)
+	assert.NoError(t, err)
+	t.Log(tx)
+}

example/bundle_test.go

@@ -47,11 +47,11 @@ func TestBundle_SendBundleTx(t *testing.T) {
 
 	// // send item to bundler gateway
 	// for _, item := range items {
-	// 	resp, err := w.Client.SendItemToBundler(item.ItemBinary)
+	// 	resp, err := w.Client.SendItemToBundler(item.ItemBinary,"")
 	// 	assert.NoError(t, err)
 	// 	t.Log(resp.Id)
 	// }
-	resp, err := w.Client.BatchSendItemToBundler(items)
+	resp, err := w.Client.BatchSendItemToBundler(items, "")
 	assert.NoError(t, err)
 	t.Log(resp)
 

go.mod

@@ -4,9 +4,11 @@ go 1.15
 
 require (
 	github.com/everFinance/gojwk v1.0.0
-	github.com/everFinance/sandy_log v1.0.3
 	github.com/everFinance/ttcrsa v1.1.3
+	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/hamba/avro v1.5.6
+	github.com/inconshreveable/log15 v0.0.0-20201112154412-8562bdadbbac
+	github.com/mattn/go-colorable v0.1.11 // indirect
 	github.com/shopspring/decimal v1.2.0
 	github.com/stretchr/testify v1.7.0
 )

threshold.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/everFinance/sandy_log/log"
 	tcrsa "github.com/everFinance/ttcrsa"
 )
 
@@ -28,10 +27,10 @@ func CreateTcKeyPair(bitSize, k, l int) (shares tcrsa.KeyShareList, meta *tcrsa.
 	now := time.Now()
 	keyShares, keyMeta, err := tcrsa.NewKey(bitSize, uint16(k), uint16(l), nil)
 	if err != nil {
-		log.Errorf("tcrsa newKey error; bitSize: %d, k: %d, l: %d; err: %v", bitSize, k, l, err)
+		log.Error("tcrsa newKey", "err", err, "bitSize", bitSize, "k", k, "l", l)
 		return nil, nil, err
 	}
-	log.Debugf("Create bit size = %d rsa threshold keyPair spend time: %s", bitSize, time.Since(now).String())
+	log.Debug("Create rsa threshold keyPair success", "bitSize", bitSize, "spendTime", time.Since(now).String())
 	return keyShares, keyMeta, nil
 }
 
@@ -81,20 +80,20 @@ func (ts *TcSign) AssembleSigShares(signedShares tcrsa.SigShareList) ([]byte, er
 	// verify each signer share
 	for _, sd := range signedShares {
 		if err := sd.Verify(ts.pssData, ts.keyMeta); err != nil {
-			log.Errorf("verify signer %d sign failed; err: %v", sd.Id, err)
+			log.Error("verify signer sign failed", "err", err, "signer", sd.Id)
 			return nil, err
 		}
 	}
 	signature, err := signedShares.Join(ts.pssData, ts.keyMeta)
 	if err != nil {
-		log.Errorf("signedShares.Join(signDataByPss, meta) error: %v", err)
+		log.Error("signedShares.Join(signDataByPss, meta)", "err", err)
 		return nil, err
 	}
 
 	// verify
 	signHashed := sha256.Sum256(ts.signData)
 	if err := rsa.VerifyPSS(ts.keyMeta.PublicKey, crypto.SHA256, signHashed[:], signature, nil); err != nil {
-		log.Errorf("verify signature error; %v", err)
+		log.Error("verify signature", "err", err)
 		return nil, err
 	}
 	return signature, nil

types/const.go

@@ -45,6 +45,6 @@ var FATAL_CHUNK_UPLOAD_ERRORS = map[string]struct{}{
 
 // about bundle
 const (
-	BUNDLER_HOST           = "http://bundler.arweave.net:10000"
+	BUNDLER_HOST           = "https://node1.bundlr.network"
 	MIN_BUNDLE_BINARY_SIZE = 1044
 )

types/swc.go

@@ -0,0 +1,17 @@
+package types
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type Input map[string]interface{}
+
+func (i Input) ToString() (string, error) {
+	bb, err := json.Marshal(i)
+	if err != nil {
+		fmt.Println(fmt.Errorf("json marshal input err: %v", err))
+		return "", err
+	}
+	return string(bb), nil
+}

types/types.go

@@ -17,7 +17,7 @@ type Block struct {
 	PreviousBlock string        `json:"previous_block"`
 	Timestamp     int64         `json:"timestamp"`
 	LastRetarget  int64         `json:"last_retarget"`
-	Diff          string        `json:"diff"`
+	Diff          interface{}   `json:"diff"`
 	Height        int64         `json:"height"`
 	Hash          string        `json:"hash"`
 	IndepHash     string        `json:"indep_hash"`