Merge pull request #7 from everFinance/add-bundles

Implementation ANS104: bundle data

Author: zyjblockchain

.gitignore

@@ -1,3 +1,4 @@
 main.go
+go.sum
 test-keyfile.json
 .DS_Store

README.md

@@ -8,15 +8,14 @@ go get github.com/everFinance/goar
 
 ### Example
 
-Send winston
+#### Send AR or Winston
 
 ```golang
 package main
 
 import (
 	"fmt"
 	"math/big"
-
 	"github.com/everFinance/goar/types"
 	"github.com/everFinance/goar"
 )
@@ -27,54 +26,51 @@ func main() {
 		panic(err)
 	}
 
-	id, err := wallet.SendWinston(
-		big.NewInt(1), // Winston amount
+	id, err := wallet.SendAR(
+  //id, err := wallet.SendWinston( 
+		big.NewFloat(1.0), // AR amount
 		{{target}}, // target address
-		[]types.Tag{
-			types.Tag{
-				Name:  "testSendWinston",
-				Value: "1",
-			},
-		},
+		[]types.Tag{},
 	)
 
 	fmt.Println(id, err) // {{id}}, nil
 }
 
 ```
 
-Send Data
+#### Send Data
 
 ```golang
-package main
-
-import (
-	"fmt"
-
-	"github.com/everFinance/goar/types"
-	"github.com/everFinance/goar"
+id, err := wallet.SendData(
+  []byte("123"), // Data bytes
+  []types.Tag{
+    types.Tag{
+      Name:  "testSendData",
+      Value: "123",
+    },
+  },
 )
 
-func main() {
-	wallet, err := goar.NewWalletFromPath("./test-keyfile.json", "https://arweave.net")
-	if err != nil {
-		panic(err)
-	}
+fmt.Println(id, err) // {{id}}, nil
+```
 
-	id, err := wallet.SendData(
-		[]byte("123"), // Data bytes
-		[]types.Tag{
-			types.Tag{
-				Name:  "testSendData",
-				Value: "123",
-			},
-		},
-	)
+#### Send Data SpeedUp
 
-	fmt.Println(id, err) // {{id}}, nil
-}
-```
+Arweave occasionally experiences congestion, and a low Reward can cause a transaction to fail; use speedUp to accelerate the transaction.
 
+```golang
+speedUp := int64(50) // means reward = reward * 150%
+id, err := wallet.SendDataSpeedUp(
+  []byte("123"), // Data bytes
+  []types.Tag{
+    types.Tag{
+      Name:  "testSendDataSpeedUp",
+      Value: "123",
+    },
+  },speedUp)
+
+fmt.Println(id, err) // {{id}}, nil
+```
 ### Components
 
 #### Client
@@ -93,6 +89,8 @@ func main() {
 - [x] GetLastTransactionID
 - [x] GetBlockByID
 - [x] GetBlockByHeight
+- [x] BatchSendItemToBundler
+- [x] GetBundle
 
 Initialize the instance:
 
@@ -113,6 +111,9 @@ arClient := goar.NewClient("https://arweave.net", proxyUrl)
 - [x] SendData
 - [x] SendDataSpeedUp
 - [x] SendTransaction
+- [x] CreateAndSignBundleItem
+- [x] SendBundleTxSpeedUp
+- [x] SendBundleTx
 
 Initialize the instance, use a keyfile.json:
 
@@ -144,6 +145,7 @@ Package for Arweave develop toolkit.
 - [x] SignTransaction
 - [x] GetSignatureData
 - [x] VerifyTransaction
+- [x] NewBundle
 
 #### RSA Threshold Cryptography
 
@@ -175,8 +177,8 @@ signedData01, err := ts.ThresholdSign(signer01)
 
 // assemble sign
 signedShares := tcrsa.SigShareList{
-signedData01,
-...
+  signedData01,
+  ...
 }
 signature, err := ts.AssembleSigShares(signedShares)
 
@@ -203,66 +205,66 @@ The method of sumbitting a data transaction is to use chunk uploading. This meth
 Simple example:
 
 ```golang
-    arNode := "https://arweave.net"
-	w, err := goar.NewWalletFromPath("../example/testKey.json", arNode) // your wallet private key
-    anchor, err := w.Client.GetTransactionAnchor()
-	if err != nil {
-		return
-	}
-	data, err := ioutil.ReadFile("./2.3MBPhoto.jpg")
-	if err != nil {
-	    return
-	}
-	tx.LastTx = anchor
-    reward, err := w.Client.GetTransactionPrice(data, nil)
-	if err != nil {
-		return
-	}
+arNode := "https://arweave.net"
+w, err := goar.NewWalletFromPath("../example/testKey.json", arNode) // your wallet private key
+anchor, err := w.Client.GetTransactionAnchor()
+if err != nil {
+  return
+}
+data, err := ioutil.ReadFile("./2.3MBPhoto.jpg")
+if err != nil {
+  return
+}
+tx.LastTx = anchor
+reward, err := w.Client.GetTransactionPrice(data, nil)
+if err != nil {
+  return
+}
 
-	tx := &types.Transaction{
-		Format:   2,
-		Target:   "",
-		Quantity: "0",
-		Tags:     utils.TagsEncode(tags),
-		Data:     utils.Base64Encode(data),
-		DataSize: fmt.Sprintf("%d", len(data)),
-		Reward:   fmt.Sprintf("%d", reward*(100+speedFactor)/100),
-	}
-	if err = utils.SignTransaction(tx, w.PubKey, w.PrvKey); err != nil {
-		return
-	}
+tx := &types.Transaction{
+  Format:   2,
+  Target:   "",
+  Quantity: "0",
+  Tags:     utils.TagsEncode(tags),
+  Data:     utils.Base64Encode(data),
+  DataSize: fmt.Sprintf("%d", len(data)),
+  Reward:   fmt.Sprintf("%d", reward*(100+speedFactor)/100),
+}
+if err = utils.SignTransaction(tx, w.PubKey, w.PrvKey); err != nil {
+  return
+}
 
-	id = tx.ID
+id = tx.ID
 
-	uploader, err := goar.CreateUploader(w.Client, tx, nil)
-	if err != nil {
-		return
-	}
-	for !uploader.IsComplete() {
-		err = uploader.UploadChunk()
-		if err != nil {
-			return
-		}
-	}
+uploader, err := goar.CreateUploader(w.Client, tx, nil)
+if err != nil {
+  return
+}
+for !uploader.IsComplete() {
+  err = uploader.UploadChunk()
+  if err != nil {
+    return
+  }
+}
 ```
 
 ##### Breakpoint continuingly
 
 You can resume an upload from a saved uploader object, that you have persisted in storage some using json.marshal(uploader) at any stage of the upload.To resume, parse it back into an object and pass it to getUploader() along with the transactions data:
 
 ```golang
-    uploaderBuf, err := ioutil.ReadFile("./jsonUploaderFile.json")
-	lastUploader := &txType.TransactionUploader{}
-	err = json.Unmarshal(uploaderBuf, lastUploader)
-	assert.NoError(t, err)
-
-	// new uploader object by last time uploader
-	newUploader, err := txType.CreateUploader(wallet.Client, lastUploader.FormatSerializedUploader(), bigData)
-	assert.NoError(t, err)
-	for !newUploader.IsComplete() {
-		err := newUploader.UploadChunk()
-		assert.NoError(t, err)
-	}
+uploaderBuf, err := ioutil.ReadFile("./jsonUploaderFile.json")
+lastUploader := &txType.TransactionUploader{}
+err = json.Unmarshal(uploaderBuf, lastUploader)
+assert.NoError(t, err)
+
+// new uploader object by last time uploader
+newUploader, err := txType.CreateUploader(wallet.Client, lastUploader.FormatSerializedUploader(), bigData)
+assert.NoError(t, err)
+for !newUploader.IsComplete() {
+  err := newUploader.UploadChunk()
+  assert.NoError(t, err)
+}
 ```
 
 When resuming the upload, you must provide the same data as the original upload. When you serialize the uploader object with json.marshal() to save it somewhere, it will not include the data.
@@ -272,17 +274,71 @@ When resuming the upload, you must provide the same data as the original upload.
 You can also resume an upload from just the transaction ID and data, once it has been mined into a block. This can be useful if you didn't save the uploader somewhere but the upload got interrupted. This will re-upload all of the data from the beginning, since we don't know which parts have been uploaded:
 
 ```golang
-    bigData, err := ioutil.ReadFile(filePath)
-    txId := "myTxId"
-
-    // get uploader by txId and post big data by chunks
-	uploader, err := goar.CreateUploader(wallet.Client, txId, bigData)
-	assert.NoError(t, err)
-	for !uploader.IsComplete() {
-		err := uploader.UploadChunk()
-		assert.NoError(t, err)
-	}
+bigData, err := ioutil.ReadFile(filePath)
+txId := "myTxId"
+
+// get uploader by txId and post big data by chunks
+uploader, err := goar.CreateUploader(wallet.Client, txId, bigData)
+assert.NoError(t, err)
+for !uploader.IsComplete() {
+  err := uploader.UploadChunk()
+  assert.NoError(t, err)
+}
 ```
 
 ##### NOTE: About all chunk transfer full example can be viewed in path `./example/chunks_tx_test.go`
+
 ---
+### About Arweave Bundles
+1. `goar` implemented creating,editing,reading and verifying bundles tx
+2. This is the [ANS-104](https://github.com/joshbenaron/arweave-standards/blob/ans104/ans/ANS-104.md) standard protocol and refers to the [arbundles](https://github.com/Bundler-Network/arbundles) js-lib implement
+3. more example can be viewed in path `./example/bundle_test.go`
+
+#### CreateBundle
+```go
+w, err := goar.NewWalletFromPath(privateKey, arNode)
+if err != nil {
+  panic(err)
+}
+
+// Create Item
+data := []byte("upload update...")   
+signatureType := 1 // currently only supply type 1
+target := "" // option 
+anchor := "" // option
+tags := []types.Tags{}{} // bundle item tags
+item01, err := w.CreateAndSignBundleItem(data, 1, target, anchor, tags)    
+// Same as create item
+item02
+item03
+....
+
+items := []types.BundleItem{item01, item02, item03 ...}	
+
+bundle, err := utils.NewBundle(items...)
+
+```
+
+#### Send Item to Bundler
+It is not necessary, The purpose is to create an index for the Bundler gateway
+```go
+resp, err := w.Client.BatchSendItemToBundler(items)
+```
+
+#### Send Bundle Tx
+```go
+txId, err := w.SendBundleTx(bd.BundleBinary, arTxtags)
+```
+
+#### Get Bundle and Verify
+```go
+id := "lt24bnUGms5XLZeVamSPHePl4M2ClpLQyRxZI7weH1k"
+bundle, err := cli.GetBundle(id)
+
+// verify
+for _, item := range bundle.Items {
+  err = utils.VerifyBundleItem(item)
+  assert.NoError(t, err)
+}
+```
+---