goar

package module
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 17, 2024 License: Apache-2.0 Imports: 28 Imported by: 1

README

goar

Install
go get github.com/permadao/goar
Example
Send AR or Winston
package main

import (
	"fmt"
	"math/big"
	"github.com/permadao/goar/schema"
	"github.com/permadao/goar"
)

func main() {
	wallet, err := goar.NewWalletFromPath("./test-keyfile.json", "https://arweave.net")
	if err != nil {
		panic(err)
	}

	tx, err := wallet.SendAR(
  //id, err := wallet.SendWinston( 
		big.NewFloat(1.0), // AR amount
		{{target}}, // target address
		[]schema.Tag{},
	)

	fmt.Println(tx.ID, err)
}
Send Data
tx, err := wallet.SendData(
  []byte("123"), // Data bytes
  []schema.Tag{
    schema.Tag{
      Name:  "testSendData",
      Value: "123",
    },
  },
)

fmt.Println(id, err) // {{id}}, nil
Send Data SpeedUp

Arweave occasionally experiences congestion, and a low Reward can cause a transaction to fail; use speedUp to accelerate the transaction.

speedUp := int64(50) // means reward = reward * 150%
tx, err := wallet.SendDataSpeedUp(
  []byte("123"), // Data bytes
  []schema.Tag{
    schema.Tag{
      Name:  "testSendDataSpeedUp",
      Value: "123",
    },
  },speedUp)

fmt.Println(tx.ID, err)
Components
Client
  • GetInfo
  • GetTransactionByID
  • GetTransactionStatus
  • GetTransactionField
  • GetTransactionData
  • GetTransactionPrice
  • GetTransactionAnchor
  • SubmitTransaction
  • Arql(Deprecated)
  • GraphQL
  • GetWalletBalance
  • GetLastTransactionID
  • GetBlockByID
  • GetBlockByHeight
  • BatchSendItemToBundler
  • GetBundle
  • GetTxDataFromPeers
  • BroadcastData
  • GetUnconfirmedTx
  • GetPendingTxIds
  • GetBlockHashList
  • ConcurrentDownloadChunkData

Initialize the instance:

arClient := goar.NewClient("https://arweave.net")

// if your network is not good, you can config http proxy
proxyUrl := "http://127.0.0.1:8001"
arClient := goar.NewClient("https://arweave.net", proxyUrl)
Wallet
  • SendAR
  • SendARSpeedUp
  • SendWinston
  • SendWinstonSpeedUp
  • SendData
  • SendDataSpeedUp
  • SendTransaction
  • CreateAndSignBundleItem
  • SendBundleTxSpeedUp
  • SendBundleTx
  • SendPst

Initialize the instance, use a keyfile.json:

arWallet := goar.NewWalletFromPath("./keyfile.json")

// if your network is not good, you can config http proxy
proxyUrl := "http://127.0.0.1:8001"
arWallet := NewWalletFromPath("./keyfile.json", "https://arweave.net", proxyUrl)
Signer
  • SignTx
  • SignMsg
  • Owner
signer := goar.NewSignerFromPath("./keyfile.json")
Utils

Package for Arweave develop toolkit.

  • Base64Encode
  • Base64Decode
  • Sign
  • Verify
  • DeepHash
  • GenerateChunks
  • ValidatePath
  • OwnerToAddress
  • OwnerToPubKey
  • TagsEncode
  • TagsDecode
  • PrepareChunks
  • GetChunk
  • SignTransaction
  • GetSignatureData
  • VerifyTransaction
  • NewBundle
  • NewBundleItem
  • SubmitItemToBundlr
  • SubmitItemToArSeed
Development
Test
make test
About chunks
  1. First, we use Chunk transactions for all types of transactions in this library, so we only support transactions where format equals 2.
  2. Second, the library already encapsulates a common interface for sending transactions : e.g SendAR; SendData. The user only needs to call this interface to send the transaction and do not need to worry about the usage of chunks.
  3. The third，If the user needs to control the transaction such as breakpoint retransmission and breakpoint continuation operations. Here is how to do it.
chunked uploading advanced options
upload all transaction data

The method of submitting a data transaction is to use chunk uploading. This method will allow larger transaction sizes, resuming a transaction upload if it's interrupted and give progress updates while uploading. Simple example:

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
}

reward, err := w.Client.GetTransactionPrice(data, nil)
if err != nil {
  return
}

tx := &schema.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),
}

tx.LastTx = anchor
tx.Owner = utils.Base64Encode(w.PubKey.N.Bytes())

if err = utils.SignTransaction(tx, w.PubKey, w.Signer.PrvKey); err != nil {
  return
}

id = tx.ID

uploader, err := goar.CreateUploader(w.Client, tx, nil)
if err != nil {
  return
}

err = uploader.Once()
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:

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.

Breakpoint retransmission

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:

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)
assert.NoError(t, uploader.Once())
About Arweave Bundles
  1. goar implemented creating, editing, reading and verifying bundles tx
  2. This is the ANS-104 standard protocol and refers to the arbundles js-lib implement
Create Bundle Item
signer, err := goar.NewSignerFromPath("./testKey.json") // rsa signer
// or 
signer, err := goether.NewSigner("0x.....") // ecdsa signer

bundler, err := goar.NewBundler(signer)

// Create Item
data := []byte("aa bb cc dd")
target := "" // option 
anchor := "" // option
tags := []schema.Tags{}{} // option bundle item tags
item01, err := bundler.CreateAndSignItem(data, target, anchor, tags)    
// Same as create item
item02
item03
....
assemble bundle and send to arweave network

You can send items directly to the arweave network


items := []schema.BundleItem{item01, item02, item03 ...}
bundle, err := utils.NewBundle(items...)

w, err := goar.NewWalletFromPath("./key.json", arNode)

arTxTags := []schema.Tags{}{} // option
tx, err := w.SendBundleTx(bd.BundleBinary, arTxtags)
Verify Bundle Items

// verify
for _, item := range bundle.Items {
  err = utils.VerifyBundleItem(item)
  assert.NoError(t, err)
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Bundler 

type Bundler struct {
	SignType int

	Owner   string // only rsa has owner
	Address string
	// contains filtered or unexported fields
}

func NewBundler 

func NewBundler(signer interface{}) (*Bundler, error)

func (*Bundler) CreateAndSignItem 

func (b *Bundler) CreateAndSignItem(data []byte, target string, anchor string, tags []schema.Tag) (bItem schema.BundleItem, err error)

func (*Bundler) CreateAndSignNestedItem 

func (b *Bundler) CreateAndSignNestedItem(target string, anchor string, tags []schema.Tag, items ...schema.BundleItem) (schema.BundleItem, error)

func (*Bundler) Sign 

func (b *Bundler) Sign(item *schema.BundleItem) error

type Client 

type Client struct {
	// contains filtered or unexported fields
}

func NewClient 

func NewClient(nodeUrl string, proxyUrl ...string) *Client

func NewTempConn 

func NewTempConn() *Client

func (*Client) Arql 

func (c *Client) Arql(arql string) (ids []string, err error)

Arql is Deprecated, recommended to use GraphQL

func (*Client) BroadcastData 

func (c *Client) BroadcastData(txId string, data []byte, numOfNodes int64, peers ...string) error

func (*Client) ConcurrentDownloadChunkData 

func (c *Client) ConcurrentDownloadChunkData(id string, concurrentNum int) ([]byte, error)

func (*Client) ConcurrentDownloadChunkDataStream 

func (c *Client) ConcurrentDownloadChunkDataStream(id string, concurrentNum int) (dataFile *os.File, err error)

func (*Client) DataSyncRecord 

func (c *Client) DataSyncRecord(endOffset string, intervalsNum int) ([]string, error)

DataSyncRecord you can use GET /data_sync_record/<end_offset>/<number_of_intervals> to fetch the first intervals with end offset >= end_offset; set Content-Type: application/json to get the reply in JSON

func (*Client) DownloadChunkData 

func (c *Client) DownloadChunkData(id string) ([]byte, error)

func (*Client) DownloadChunkDataStream 

func (c *Client) DownloadChunkDataStream(id string) (*os.File, error)

func (*Client) ExistTxData 

func (c *Client) ExistTxData(arId string) (bool, error)

func (*Client) GetBlockByHeight 

func (c *Client) GetBlockByHeight(height int64) (block *schema.Block, err error)

func (*Client) GetBlockByID 

func (c *Client) GetBlockByID(id string) (block *schema.Block, err error)

Block

func (*Client) GetBlockFromPeers 

func (c *Client) GetBlockFromPeers(height int64, peers ...string) (*schema.Block, error)

func (*Client) GetBlockHashList 

func (c *Client) GetBlockHashList(from, to int) ([]string, error)

func (*Client) GetBundleItems 

func (c *Client) GetBundleItems(bundleInId string, itemsIds []string) (items []*schema.BundleItem, err error)

func (*Client) GetInfo 

func (c *Client) GetInfo() (info *schema.NetworkInfo, err error)

func (*Client) GetLastTransactionID 

func (c *Client) GetLastTransactionID(address string) (id string, err error)

func (*Client) GetPeers 

func (c *Client) GetPeers() ([]string, error)

func (*Client) GetPendingTxIds 

func (c *Client) GetPendingTxIds() ([]string, error)

func (*Client) GetTransactionAnchor 

func (c *Client) GetTransactionAnchor() (anchor string, err error)

func (*Client) GetTransactionByID 

func (c *Client) GetTransactionByID(id string) (tx *schema.Transaction, err error)

GetTransactionByID status: Pending/Invalid hash/overspend

func (*Client) GetTransactionData 

func (c *Client) GetTransactionData(id string, extension ...string) ([]byte, error)

func (*Client) GetTransactionDataByGateway 

func (c *Client) GetTransactionDataByGateway(id string) (body []byte, err error)

GetTransactionDataByGateway

func (*Client) GetTransactionDataStream 

func (c *Client) GetTransactionDataStream(id string, extension ...string) (*os.File, error)

func (*Client) GetTransactionDataStreamByGateway 

func (c *Client) GetTransactionDataStreamByGateway(id string) (*os.File, error)

func (*Client) GetTransactionField 

func (c *Client) GetTransactionField(id string, field string) (string, error)

func (*Client) GetTransactionPrice 

func (c *Client) GetTransactionPrice(dataSize int, target *string) (reward int64, err error)

func (*Client) GetTransactionStatus 

func (c *Client) GetTransactionStatus(id string) (*schema.TxStatus, error)

GetTransactionStatus

func (*Client) GetTransactionTags 

func (c *Client) GetTransactionTags(id string) ([]schema.Tag, error)

func (*Client) GetTxDataFromPeers 

func (c *Client) GetTxDataFromPeers(txId string, peers ...string) ([]byte, error)

func (*Client) GetTxFromPeers 

func (c *Client) GetTxFromPeers(arId string, peers ...string) (*schema.Transaction, error)

func (*Client) GetUnconfirmedTx 

func (c *Client) GetUnconfirmedTx(arId string) (*schema.Transaction, error)

func (*Client) GetUnconfirmedTxFromPeers 

func (c *Client) GetUnconfirmedTxFromPeers(arId string, peers ...string) (*schema.Transaction, error)

func (*Client) GetWalletBalance 

func (c *Client) GetWalletBalance(address string) (arAmount *big.Float, err error)

Wallet

func (*Client) GetWalletWinstonBalance 

func (c *Client) GetWalletWinstonBalance(address string) (arAmount *big.Int, err error)

func (*Client) GraphQL 

func (c *Client) GraphQL(query string) ([]byte, error)

func (*Client) SetTempConnUrl 

func (c *Client) SetTempConnUrl(url string)

func (*Client) SetTimeout 

func (c *Client) SetTimeout(timeout time.Duration)

func (*Client) SubmitChunks 

func (c *Client) SubmitChunks(gc *schema.GetChunk) (status string, code int, err error)

func (*Client) SubmitToWarp 

func (c *Client) SubmitToWarp(tx *schema.Transaction) ([]byte, error)

func (*Client) SubmitTransaction 

func (c *Client) SubmitTransaction(tx *schema.Transaction) (status string, code int, err error)

type SerializedUploader 

type SerializedUploader struct {
	// contains filtered or unexported fields
}

type Signer 

type Signer struct {
	Address string
	PubKey  *rsa.PublicKey
	PrvKey  *rsa.PrivateKey
}

func NewSigner 

func NewSigner(b []byte) (*Signer, error)

func NewSignerByPrivateKey 

func NewSignerByPrivateKey(privateKey *rsa.PrivateKey) *Signer

func NewSignerFromPath 

func NewSignerFromPath(path string) (*Signer, error)

func (*Signer) Owner 

func (s *Signer) Owner() string

func (*Signer) SignMsg 

func (s *Signer) SignMsg(msg []byte) ([]byte, error)

func (*Signer) SignTx 

func (s *Signer) SignTx(tx *schema.Transaction) error

type TransactionUploader 

type TransactionUploader struct {
	Client             *Client `json:"-"`
	ChunkIndex         int
	TxPosted           bool
	Transaction        *schema.Transaction
	Data               []byte
	DataReader         *os.File
	LastRequestTimeEnd int64
	TotalErrors        int // Not serialized.
	LastResponseStatus int
	LastResponseError  string
}

func CreateUploader 

func CreateUploader(api *Client, upload interface{}, data []byte) (*TransactionUploader, error)

CreateUploader @param upload: Transaction | SerializedUploader | string, @param Data the Data of the Transaction. Required when resuming an upload.

func (*TransactionUploader) ConcurrentOnce 

func (tt *TransactionUploader) ConcurrentOnce(ctx context.Context, concurrentNum int) error

func (*TransactionUploader) FormatSerializedUploader 

func (tt *TransactionUploader) FormatSerializedUploader() *SerializedUploader

func (*TransactionUploader) FromSerialized 

func (tt *TransactionUploader) FromSerialized(serialized *SerializedUploader, data []byte) (*TransactionUploader, error)

*

  • Reconstructs an upload from its serialized state and data.
  • Checks if data matches the expected data_root. *
  • @param serialized
  • @param data

func (*TransactionUploader) FromTransactionId 

func (tt *TransactionUploader) FromTransactionId(id string) (*SerializedUploader, error)

*

  • Reconstruct an upload from the tx metadata, ie /tx/<id>. *
  • @param api
  • @param id
  • @param data

func (*TransactionUploader) IsComplete 

func (tt *TransactionUploader) IsComplete() bool

func (*TransactionUploader) Once 

func (tt *TransactionUploader) Once() (err error)

func (*TransactionUploader) PctComplete 

func (tt *TransactionUploader) PctComplete() float64

func (*TransactionUploader) TotalChunks 

func (tt *TransactionUploader) TotalChunks() int

func (*TransactionUploader) UploadChunk 

func (tt *TransactionUploader) UploadChunk() error

*

  • Uploads the next part of the Transaction.
  • On the first call this posts the Transaction
  • itself and on any subsequent calls uploads the
  • next chunk until it completes.

func (*TransactionUploader) UploadedChunks 

func (tt *TransactionUploader) UploadedChunks() int

type Wallet 

type Wallet struct {
	Client *Client
	Signer *Signer
}

func NewWallet 

func NewWallet(b []byte, clientUrl string, proxyUrl ...string) (w *Wallet, err error)

func NewWalletFrom added in v1.1.1 

func NewWalletFrom(path string, clientUrl string, proxyUrl ...string) (*Wallet, error)

func NewWalletFromPath 

func NewWalletFromPath(path string, clientUrl string, proxyUrl ...string) (*Wallet, error)

proxyUrl: option

func NewWalletWithSigner added in v1.1.1 

func NewWalletWithSigner(signer *Signer, clientUrl string, proxyUrl ...string) *Wallet

func (*Wallet) Owner 

func (w *Wallet) Owner() string

func (*Wallet) SendAR 

func (w *Wallet) SendAR(amount *big.Float, target string, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendARSpeedUp 

func (w *Wallet) SendARSpeedUp(amount *big.Float, target string, tags []schema.Tag, speedFactor int64) (schema.Transaction, error)

func (*Wallet) SendBundleTx 

func (w *Wallet) SendBundleTx(ctx context.Context, concurrentNum int, bundleBinary []byte, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendBundleTxSpeedUp 

func (w *Wallet) SendBundleTxSpeedUp(ctx context.Context, concurrentNum int, bundleBinary interface{}, tags []schema.Tag, txSpeed int64) (schema.Transaction, error)

func (*Wallet) SendBundleTxStream 

func (w *Wallet) SendBundleTxStream(ctx context.Context, concurrentNum int, bundleReader *os.File, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendData 

func (w *Wallet) SendData(data []byte, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendDataConcurrentSpeedUp 

func (w *Wallet) SendDataConcurrentSpeedUp(ctx context.Context, concurrentNum int, data interface{}, tags []schema.Tag, speedFactor int64) (schema.Transaction, error)

func (*Wallet) SendDataSpeedUp 

func (w *Wallet) SendDataSpeedUp(data []byte, tags []schema.Tag, speedFactor int64) (schema.Transaction, error)

SendDataSpeedUp set speedFactor for speed up eg: speedFactor = 10, reward = 1.1 * reward

func (*Wallet) SendDataStream 

func (w *Wallet) SendDataStream(data *os.File, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendDataStreamSpeedUp 

func (w *Wallet) SendDataStreamSpeedUp(data *os.File, tags []schema.Tag, speedFactor int64) (schema.Transaction, error)

func (*Wallet) SendTransaction 

func (w *Wallet) SendTransaction(tx *schema.Transaction) (schema.Transaction, error)

SendTransaction: if send success, should return pending

func (*Wallet) SendTransactionConcurrent 

func (w *Wallet) SendTransactionConcurrent(ctx context.Context, concurrentNum int, tx *schema.Transaction) (schema.Transaction, error)

func (*Wallet) SendWinston 

func (w *Wallet) SendWinston(amount *big.Int, target string, tags []schema.Tag) (schema.Transaction, error)

func (*Wallet) SendWinstonSpeedUp 

func (w *Wallet) SendWinstonSpeedUp(amount *big.Int, target string, tags []schema.Tag, speedFactor int64) (schema.Transaction, error)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.