区块链项目（algorand）开发过程全记录（二）

最新推荐文章于 2021-04-07 21:10:26 发布
最新推荐文章于 2021-04-07 21:10:26 发布
阅读量714 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41009600/article/details/115495554
版权

使用sdk对algorand区块链进行交易、建立账户等基本操作

可以选用python、js、java、go语言的sdk，我这里使用的是go-sdk，所以我下面执行的主程序都是在go-algorand-sdk环境下运行的

package main

import (
	"fmt"

	"github.com/algorand/go-algorand-sdk/crypto"
	"github.com/algorand/go-algorand-sdk/mnemonic"
)

func main() {
	account := crypto.GenerateAccount()
	passphrase, err := mnemonic.FromPrivateKey(account.PrivateKey)

	if err != nil {
		fmt.Printf("Error creating transaction: %s\n", err)
	} else {
		fmt.Printf("My address: %s\n", account.Address)
		fmt.Printf("My passphrase: %s\n", passphrase)
	}

}

```输出
My address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
My passphrase: essay broccoli sunset upon midnight hope paper picnic choice pulp chalk fluid they plug scan coffee curious around yellow depart feel bacon matter above differ
  • 查询账户余额：（执行前请在此为账户添加资金）增加资金
package main

import (
	"context"
	"crypto/ed25519"
	"fmt"
	"github.com/algorand/go-algorand-sdk/client/v2/algod"
	"github.com/algorand/go-algorand-sdk/mnemonic"
	"github.com/algorand/go-algorand-sdk/types"

)

const algodAddress = "http://127.0.0.1:8080"
const algodToken = "adaad27f70e451e97d0fbbbbe2095220e8798099fe69252e88e51db11d0cd97c"

func main() {
	algodClient, err := algod.MakeClient(algodAddress, algodToken)
	if err != nil {
		fmt.Printf("Issue with creating algod client: %s\n", err)
		return
	}
	passphrase := "essay broccoli sunset upon midnight hope paper picnic choice pulp chalk fluid they plug scan coffee curious around yellow depart feel bacon matter above differ"
	privateKey, err := mnemonic.ToPrivateKey(passphrase)
	if err != nil {
		fmt.Printf("Issue with mnemonic conversion: %s\n", err)
		return
	}
	var myAddress types.Address
	publicKey := privateKey.Public()
	cpk := publicKey.(ed25519.PublicKey)
	copy(myAddress[:], cpk[:])
	fmt.Printf("My address: %s\n", myAddress.String())

	accountInfo, err := algodClient.AccountInformation(myAddress.String()).Do(context.Background())
	if err != nil {
		fmt.Printf("Error getting account info: %s\n", err)
		return
	}
	fmt.Printf("Account balance: %d microAlgos\n", accountInfo.Amount)
}
输出：
My address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Account balance: 10000000 microAlgos
  • 进行你的第一笔交易：
package main

import (
	"context"
	"github.com/algorand/go-algorand-sdk/mnemonic"

	//"crypto/ed25519"
	"encoding/json"
	"fmt"
	"github.com/algorand/go-algorand-sdk/client/v2/algod"
	"github.com/algorand/go-algorand-sdk/crypto"
	//"github.com/algorand/go-algorand-sdk/mnemonic"
	"github.com/algorand/go-algorand-sdk/transaction"
	//"github.com/algorand/go-algorand-sdk/types"
)

const algodAddress = "http://127.0.0.1:8080"
const algodToken = "adaad27f70e451e97d0fbbbbe2095220e8798099fe69252e88e51db11d0cd97c"

// Function that waits for a given txId to be confirmed by the network
func waitForConfirmation(txID string, client *algod.Client) {
	status, err := client.Status().Do(context.Background())
	if err != nil {
		fmt.Printf("error getting algod status: %s\n", err)
		return
	}
	lastRound := status.LastRound
	for {
		pt, _, err := client.PendingTransactionInformation(txID).Do(context.Background())
		if err != nil {
			fmt.Printf("error getting pending transaction: %s\n", err)
			return
		}
		if pt.ConfirmedRound > 0 {
			fmt.Printf("Transaction "+txID+" confirmed in round %d\n", pt.ConfirmedRound)
			break
		}
		fmt.Printf("waiting for confirmation\n")
		lastRound++
		status, err = client.StatusAfterBlock(lastRound).Do(context.Background())
	}
}



func main() {
	algodClient, err := algod.MakeClient(algodAddress, algodToken)
	if err != nil {
		fmt.Printf("Issue with creating algod client: %s\n", err)
		return
	}

	passphrase := "essay broccoli sunset upon midnight hope paper picnic choice pulp chalk fluid they plug scan coffee curious around yellow depart feel bacon matter above differ"

	privateKey, err := mnemonic.ToPrivateKey(passphrase)
	if err != nil {
		fmt.Printf("Issue with mnemonic conversion: %s\n", err)
		return
	}


/*	var myAddress types.Address
	publicKey := privateKey.Public()
	cpk := publicKey.(ed25519.PublicKey)
	copy(myAddress[:], cpk[:])
	fmt.Printf("My address: %s\n", myAddress.String())
*/
	// Construct the transaction
*/	txParams, err := algodClient.SuggestedParams().Do(context.Background())
	if err != nil {
		fmt.Printf("Error getting suggested tx params: %s\n", err)
		return
	}
	// comment out the next two (2) lines to use suggested fees
	txParams.FlatFee = true
	txParams.Fee = 1000

	fromAddr := "DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM"
	toAddr := "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
	var amount uint64 = 1000000
	var minFee uint64 = 1000
	note := []byte("Hello World")
	genID := txParams.GenesisID
	genHash := txParams.GenesisHash
	firstValidRound := uint64(txParams.FirstRoundValid)
	lastValidRound := uint64(txParams.LastRoundValid)

	txn, err := transaction.MakePaymentTxnWithFlatFee(fromAddr, toAddr, minFee, amount, firstValidRound, lastValidRound, note, "", genID, genHash)
	if err != nil {
		fmt.Printf("Error creating transaction: %s\n", err)
		return
	}
	// Sign the transaction
	txID, signedTxn, err := crypto.SignTransaction(privateKey, txn)
	if err != nil {
		fmt.Printf("Failed to sign transaction: %s\n", err)
		return
	}
	fmt.Printf("Signed txid: %s\n", txID)

	// Submit the transaction
	sendResponse, err := algodClient.SendRawTransaction(signedTxn).Do(context.Background())
	if err != nil {
		fmt.Printf("failed to send transaction: %s\n", err)
		return
	}
	fmt.Printf("Submitted transaction %s\n", sendResponse)

	// Wait for confirmation
	waitForConfirmation(txID, algodClient)

	// Read transaction
	confirmedTxn, stxn, err := algodClient.PendingTransactionInformation(txID).Do(context.Background())
	if err != nil {
		fmt.Printf("Error retrieving transaction %s\n", txID)
		return
	}
	txnJSON, err := json.MarshalIndent(confirmedTxn.Transaction.Txn, "", "\t")
	if err != nil {
		fmt.Printf("Can not marshall txn data: %s\n", err)
	}
	fmt.Printf("Transaction information: %s\n", txnJSON)
	fmt.Printf("Decoded note: %s\n", string(stxn.Txn.Note))
}

输出：
Signed txid: OHNIWTIUCRZBGIPDRJCPX7M36SUNDSA5OMEFLUHZQICABKYGRAZA
Submitted transaction OHNIWTIUCRZBGIPDRJCPX7M36SUNDSA5OMEFLUHZQICABKYGRAZA
waiting for confirmation
Transaction OHNIWTIUCRZBGIPDRJCPX7M36SUNDSA5OMEFLUHZQICABKYGRAZA confirmed in round 13343745
Transaction information: {
 "Type": "pay",
 "Sender": [
 28,96,180,53,177,1,128,220,18,170,232,69,138,205,196,139,3,95,174,20,222,112,83,0,64,221,197,125,128,58,225,254
 ],
 "Fee": 1000,
 "FirstValid": 13343743,
 "LastValid": 13344743,
 "Note": "SGVsbG8gV29ybGQ=",
 "GenesisID": "testnet-v1.0",
 "GenesisHash": [
  72,99,181,24,164,179,200,78,200,16,242,45,79,16,129,203,15,113,240, 89,167,172,32,222,198,47,127,112,229,9,58,34
 ],
 ...

进行一笔多重签名交易：

package main

import (
	"fmt"

	"github.com/algorand/go-algorand-sdk/client/algod"
	"github.com/algorand/go-algorand-sdk/crypto"
	"github.com/algorand/go-algorand-sdk/transaction"
	"github.com/algorand/go-algorand-sdk/types"
)

// Change these values for your own algod.token and algod.net values
const algodAddress = "http://127.0.0.1:8080"
const algodToken = "adaad27f70e451e97d0fbbbbe2095220e8798099fe69252e88e51db11d0cd97c"

func main() {

	// Initialize an algodClient
	algodClient, err := algod.MakeClient(algodAddress, algodToken)
	if err != nil {
		fmt.Printf("failed to make algod client: %v\n", err)
		return
	}

	txParams, err := algodClient.SuggestedParams()
	if err != nil {
		fmt.Printf("error getting suggested tx params: %s\n", err)
		return
	}

	// Generate Accounts
	acct1 := crypto.GenerateAccount()
	acct2 := crypto.GenerateAccount()
	acct3 := crypto.GenerateAccount()

	// Decode the account addresses
	addr1, _ := types.DecodeAddress(acct1.Address.String())
	addr2, _ := types.DecodeAddress(acct2.Address.String())
	addr3, _ := types.DecodeAddress(acct3.Address.String())

	ma, err := crypto.MultisigAccountWithParams(1, 2, []types.Address{
		addr1,
		addr2,
		addr3,
	})
	if err != nil {
		panic("invalid multisig parameters")
	}

	// declare txn parameters
	fee := txParams.Fee
	firstRound := txParams.LastRound
	lastRound := txParams.LastRound + 1000
	genesisID := txParams.GenesisID     // replace me
	genesisHash := txParams.GenesisHash // replace me
	const amount1 = 2000
	const amount2 = 1500
	var note []byte
	closeRemainderTo := ""

	fromAddr, _ := ma.Address()
	toAddr := "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"

	// Create the transaction
	txn, err := transaction.MakePaymentTxn(fromAddr.String(), toAddr, fee, amount1, firstRound, lastRound, note, closeRemainderTo, genesisID, genesisHash)

	// First signature on PST
	txid, preStxBytes, err := crypto.SignMultisigTransaction(acct1.PrivateKey, ma, txn)
	if err != nil {
		panic("could not sign multisig transaction")
	}
	fmt.Printf("Made partially-signed multisig transaction with TxID %s \n", txid)

	// Second signature on PST
	txid2, stxBytes, err := crypto.AppendMultisigTransaction(acct2.PrivateKey, ma, preStxBytes)
	if err != nil {
		panic("could not sign multisig transaction")
	}
	fmt.Printf("Made partially-signed multisig transaction with TxID %s \n", txid2)

	// Print multisig account
	fmt.Printf("Here is your multisig address : %s \n", fromAddr)

	fmt.Println("Please go to: https://bank.testnet.algorand.network/ to fund your multisig account.")
	fmt.Scanln() // wait for Enter Key

	// Send transaction to the network
	sendResponse, err := algodClient.SendRawTransaction(stxBytes)
	if err != nil {
		fmt.Printf("Failed to create payment transaction: %v\n", err)
		return
	}
	fmt.Printf("Transaction ID: %s\n", sendResponse.TxID)
}
输出：
Made partially-signed multisig transaction with TxID SGFLXVNYM3RXY6FAXH54QLPFY4YXJJYG3SA73MU7GOI5AX6745SQ 
Made partially-signed multisig transaction with TxID SGFLXVNYM3RXY6FAXH54QLPFY4YXJJYG3SA73MU7GOI5AX6745SQ 
Here is your multisig address : FFNL2YUDFP5X253RGPDQ7X4MWL77MM7XS6SGXA7BNUZ6P3IPCYBARIIXYU 
Please go to: https://bank.testnet.algorand.network/ to fund your multisig account.
//注意这里需要跳转到上述网站分发资金后，回到IDE按回车才会输出交易ID
Transaction ID: SGFLXVNYM3RXY6FAXH54QLPFY4YXJJYG3SA73MU7GOI5AX6745SQ

Process finished with exit code 0
  • (未)签名交易保存到文件中:-这里将两项操作合并到一个文件中，执行时注意区分

package main

import (
	"fmt"
	"io/ioutil"

	"golang.org/x/crypto/ed25519"

	"github.com/algorand/go-algorand-sdk/client/algod"
	"github.com/algorand/go-algorand-sdk/crypto"
	"github.com/algorand/go-algorand-sdk/mnemonic"
	"github.com/algorand/go-algorand-sdk/transaction"
	"github.com/algorand/go-algorand-sdk/types"
)

// Function that waits for a given txId to be confirmed by the network
func waitForConfirmation(algodClient algod.Client, txID string) {
	for {
		pt, err := algodClient.PendingTransactionInformation(txID)
		if err != nil {
			fmt.Printf("waiting for confirmation... (pool error, if any): %s\n", err)
			continue
		}
		if pt.ConfirmedRound > 0 {
			fmt.Printf("Transaction "+pt.TxID+" confirmed in round %d\n", pt.ConfirmedRound)
			break
		}
		nodeStatus, err := algodClient.Status()
		if err != nil {
			fmt.Printf("error getting algod status: %s\n", err)
			return
		}
		algodClient.StatusAfterBlock( nodeStatus.LastRound + 1)
	}
}
// utility function to recover account and return sk and address
func recoverAccount()(string, ed25519.PrivateKey) {
	const passphrase = "essay broccoli sunset upon midnight hope paper picnic choice pulp chalk fluid they plug scan coffee curious around yellow depart feel bacon matter above differ"

		sk, err := mnemonic.ToPrivateKey(passphrase)
	if err != nil {
		fmt.Printf("error recovering account: %s\n", err)
		return "", nil
	}
	pk := sk.Public()
	var a types.Address
	cpk := pk.(ed25519.PublicKey)
	copy(a[:], cpk[:])
	fmt.Printf("Address: %s\n", a.String())
	address := a.String()
	return address, sk
}
// utility funciton to setup connection to node
func setupConnection()( algod.Client ){
	const algodAddress = "http://127.0.0.1:8080"
	const algodToken = "adaad27f70e451e97d0fbbbbe2095220e8798099fe69252e88e51db11d0cd97c"
		algodClient, err := algod.MakeClient(algodAddress, algodToken)
	if err != nil {
		fmt.Printf("failed to make algod client: %s\n", err)
	}
	return algodClient
}

func saveUnsignedTransaction() {

	// setup connection
	algodClient := setupConnection()

	// recover account for example
	addr, _ := recoverAccount();

	// get network suggested parameters
	txParams, err := algodClient.SuggestedParams()
	if err != nil {
		fmt.Printf("error getting suggested tx params: %s\n", err)
		return
	}

	// create transaction
	toAddr := "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
		genID := txParams.GenesisID
	tx, err := transaction.MakePaymentTxn(addr, toAddr, 1, 100000,
		txParams.LastRound, txParams.LastRound+100, nil, "",
		genID, txParams.GenesisHash)
	if err != nil {
		fmt.Printf("Error creating transaction: %s\n", err)
		return
	}
	unsignedTx := types.SignedTxn{
		Txn:  tx,
	}

	// save unsigned Transaction to file
	err = ioutil.WriteFile("./unsigned.txn", msgpack.Encode(unsignedTx), 0644)
	if err == nil {
		fmt.Printf("Saved unsigned transaction to file\n")
		return
	}
	fmt.Printf("Failed in saving trx to file, error %s\n", err)

}
func readUnsignedTransaction(){

	// setup connection
	algodClient := setupConnection()

	// read unsigned transaction from file
	dat, err := ioutil.ReadFile("./unsigned.txn")
	if err != nil {
		fmt.Printf("Error reading transaction from file: %s\n", err)
		return
	}
	var unsignedTxRaw types.SignedTxn
	var unsignedTxn types.Transaction

	msgpack.Decode(dat, &unsignedTxRaw)

	unsignedTxn = unsignedTxRaw.Txn

	// recover account and sign transaction
	addr, sk := recoverAccount();
	fmt.Printf("Address is: %s\n", addr)
	txid, stx, err := crypto.SignTransaction(sk, unsignedTxn)
	if err != nil {
		fmt.Printf("Failed to sign transaction: %s\n", err)
		return
	}
	fmt.Printf("Transaction id: %s\n", txid)

	// send transaction to the network
	sendResponse, err := algodClient.SendRawTransaction(stx)
	if err != nil {
		fmt.Printf("failed to send transaction: %s\n", err)
		return
	}
	fmt.Printf("Transaction ID: %s\n", sendResponse.TxID)
	waitForConfirmation(algodClient, sendResponse.TxID)
}


func saveSignedTransaction() {

	// setup connection
	algodClient := setupConnection()

	// recover account
	addr, sk := recoverAccount();

	// get network suggested parameters
	txParams, err := algodClient.SuggestedParams()
	if err != nil {
		fmt.Printf("error getting suggested tx params: %s\n", err)
		return
	}

	// create transaction
	toAddr := "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
		genID := txParams.GenesisID
	tx, err := transaction.MakePaymentTxn(addr, toAddr, 1, 100000,
		txParams.LastRound, txParams.LastRound+100, nil, "",
		genID, txParams.GenesisHash)
	if err != nil {
		fmt.Printf("Error creating transaction: %s\n", err)
		return
	}

	// sign the Transaction, msgpack encoding happens in sign
	txid, stx, err := crypto.SignTransaction(sk, tx)
	if err != nil {
		fmt.Printf("Failed to sign transaction: %s\n", err)
		return
	}
	fmt.Printf("Made signed transaction with TxID %s: %x\n", txid, stx)

	//Save the signed transaction to file
	err = ioutil.WriteFile("./signed.stxn", stx, 0644)
	if err == nil {
		fmt.Printf("Saved signed transaction to file\n")
		return
	}
	fmt.Printf("Failed in saving trx to file, error %s\n", err)

}
func readSignedTransaction(){

	// setup connection
	algodClient := setupConnection()

	// read unsigned transaction from file
	dat, err := ioutil.ReadFile("./signed.stxn")
	if err != nil {
		fmt.Printf("Error reading signed transaction from file: %s\n", err)
		return
	}

	// send the transaction to the network
	sendResponse, err := algodClient.SendRawTransaction(dat)
	if err != nil {
		fmt.Printf("failed to send transaction: %s\n", err)
		return
	}

	fmt.Printf("Transaction ID: %s\n", sendResponse.TxID)
	waitForConfirmation(algodClient, sendResponse.TxID)
}
func main() {
	//saveUnsignedTransaction()
	//readUnsignedTransaction()

	saveSignedTransaction()
	readSignedTransaction()

}
输出：
未签名交易保存到文件中:
Address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Saved unsigned transaction to file
Address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Address is: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Transaction id: D72GNKEOFSGQ7G7AHYV67YDTTXLGK6GCOVLP64UEI4MZKVK7J2TA
Transaction ID: D72GNKEOFSGQ7G7AHYV67YDTTXLGK6GCOVLP64UEI4MZKVK7J2TA
Transaction D72GNKEOFSGQ7G7AHYV67YDTTXLGK6GCOVLP64UEI4MZKVK7J2TA confirmed in round 13369740

Process finished with exit code 0

签名交易保存到文件中
Address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Made signed transaction with TxID 2277MTRKGJJOMDJMBMPRFUUPGAW5K5DFMTIIDHPHVZWPWMM52SRA: 82a3736967c44089ac1676e8a784d75a50f4f1a892fbf7a42458b3e10a03b7aa76c18099d664e05ebc194b6ec0825c1d8dca94946add9cb91052a509ce1262b9d11f0993a03a01a374786e89a3616d74ce000186a0a3666565cd03e8a26676ce00cc01caa367656eac746573746e65742d76312e30a26768c4204863b518a4b3c84ec810f22d4f1081cb0f71f059a7ac20dec62f7f70e5093a22a26c76ce00cc022ea3726376c42030fdcc231b9d8c3609af7f7bb1e5ef8f963a48b07213528defbd886d96ae4884a3736e64c4201c60b435b10180dc12aae8458acdc48b035fae14de70530040ddc57d803ae1fea474797065a3706179
Saved signed transaction to file
Transaction ID: 2277MTRKGJJOMDJMBMPRFUUPGAW5K5DFMTIIDHPHVZWPWMM52SRA
Transaction 2277MTRKGJJOMDJMBMPRFUUPGAW5K5DFMTIIDHPHVZWPWMM52SRA confirmed in round 13369804

Process finished with exit code 0
  • 生成参与密钥:
~/node$ ./goal account addpartkey -a "DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM" --roundFirstValid="13391134" --roundLastValid="13392134" --keyDilution="10000" -d ~/node/data
Participation key generation successful
$ ./goal account listpartkeys -d ~/node/data
Registered	Filename                                                                        	Parent address                                              	 First round	  Last round	   First key
no        	DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM.13389730.13390730.partkey	DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM  	    13389730	    13390730	   1340.1150
no        	DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM.13391134.13392134.partkey	DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM  	    13391134	    13392134	      1339.0

-创建在线密钥注册交易:

package main

import (
	"encoding/base64"
	"fmt"
	"github.com/algorand/go-algorand-sdk/crypto"
	"github.com/algorand/go-algorand-sdk/encoding/msgpack"
	"github.com/algorand/go-algorand-sdk/mnemonic"
	"io/ioutil"
	"golang.org/x/crypto/ed25519"

	"github.com/algorand/go-algorand-sdk/client/algod"
	"github.com/algorand/go-algorand-sdk/transaction"
	"github.com/algorand/go-algorand-sdk/types"
)
// Function that waits for a given txId to be confirmed by the network
func waitForConfirmation(algodClient algod.Client, txID string) {
	for {
		pt, err := algodClient.PendingTransactionInformation(txID)
		if err != nil {
			fmt.Printf("waiting for confirmation... (pool error, if any): %s\n", err)
			continue
		}
		if pt.ConfirmedRound > 0 {
			fmt.Printf("Transaction "+pt.TxID+" confirmed in round %d\n", pt.ConfirmedRound)
			break
		}
		nodeStatus, err := algodClient.Status()
		if err != nil {
			fmt.Printf("error getting algod status: %s\n", err)
			return
		}
		algodClient.StatusAfterBlock( nodeStatus.LastRound + 1)
	}
}
// utility function to recover account and return sk and address
func recoverAccount()(string, ed25519.PrivateKey) {
	const passphrase = "essay broccoli sunset upon midnight hope paper picnic choice pulp chalk fluid they plug scan coffee curious around yellow depart feel bacon matter above differ"

	sk, err := mnemonic.ToPrivateKey(passphrase)
	if err != nil {
		fmt.Printf("error recovering account: %s\n", err)
		return "", nil
	}
	pk := sk.Public()
	var a types.Address
	cpk := pk.(ed25519.PublicKey)
	copy(a[:], cpk[:])
	fmt.Printf("Address: %s\n", a.String())
	address := a.String()
	return address, sk
}
// utility funciton to setup connection to node
func setupConnection()( algod.Client ){
	const algodAddress = "http://127.0.0.1:8080"
	const algodToken = "adaad27f70e451e97d0fbbbbe2095220e8798099fe69252e88e51db11d0cd97c"
	algodClient, err := algod.MakeClient(algodAddress, algodToken)
	if err != nil {
		fmt.Printf("failed to make algod client: %s\n", err)
	}
	return algodClient
}

func saveUnsignedTransaction() {

	// setup connection
	algodClient := setupConnection()

	// get network suggested parameters
	txParams, err := algodClient.SuggestedParams()
	if err != nil {
		fmt.Printf("error getting suggested tx params: %s\n", err)
		return
	}

	// create transaction
	fromAddr := "DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM"
	genID := txParams.GenesisID
	genesisHash := base64.StdEncoding.EncodeToString(txParams.GenesisHash)
	voteKey := "eXq34wzh2UIxCZaI1leALKyAvSz/+XOe0wqdHagM+bw="
	selKey := "X84ReKTmp+yfgmMCbbokVqeFFFrKQeFZKEXG89SXwm4="
	voteFirst := uint64(13389730)
	voteLast := uint64(16389730)
	keyDilution := uint64(10000)
	tx, err := transaction.MakeKeyRegTxnWithFlatFee(fromAddr, 2000, 13391134,
		13392134, nil, genID, genesisHash, voteKey, selKey, voteFirst, voteLast,
		keyDilution)
	if err != nil {
		fmt.Printf("Error creating transaction: %s\n", err)
		return
	}
	unsignedTx := types.SignedTxn{
		Txn: tx,
	}
	// save unsigned Transaction to file
	err = ioutil.WriteFile("./unsigned.txn", msgpack.Encode(unsignedTx), 0644)
	if err == nil {
		fmt.Printf("Saved unsigned transaction to file\n")
		return
	}
	fmt.Printf("Failed in saving trx to file, error %s\n", err)

}

func readUnsignedTransaction(){

	// setup connection
	algodClient := setupConnection()

	// read unsigned transaction from file
	dat, err := ioutil.ReadFile("./unsigned.txn")
	if err != nil {
		fmt.Printf("Error reading transaction from file: %s\n", err)
		return
	}
	var unsignedTxRaw types.SignedTxn
	var unsignedTxn types.Transaction

	msgpack.Decode(dat, &unsignedTxRaw)

	unsignedTxn = unsignedTxRaw.Txn

	// recover account and sign transaction
	addr, sk := recoverAccount();
	fmt.Printf("Address is: %s\n", addr)
	txid, stx, err := crypto.SignTransaction(sk, unsignedTxn)
	if err != nil {
		fmt.Printf("Failed to sign transaction: %s\n", err)
		return
	}
	fmt.Printf("Transaction id: %s\n", txid)

	// send transaction to the network
	sendResponse, err := algodClient.SendRawTransaction(stx)
	if err != nil {
		fmt.Printf("failed to send transaction: %s\n", err)
		return
	}
	fmt.Printf("Transaction ID: %s\n", sendResponse.TxID)
	waitForConfirmation(algodClient, sendResponse.TxID)
}
func main() {
	saveUnsignedTransaction()
	readUnsignedTransaction()


}
输出：
Saved unsigned transaction to file
Address: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Address is: DRQLINNRAGANYEVK5BCYVTOERMBV7LQU3ZYFGACA3XCX3AB24H7OKCZ7AM
Transaction id: AXQEMH7KSI55I5LP4XCZS2AYKJOB372DSZ7Y2LKE5NQMK7HZUXDA
Transaction ID: AXQEMH7KSI55I5LP4XCZS2AYKJOB372DSZ7Y2LKE5NQMK7HZUXDA
Transaction AXQEMH7KSI55I5LP4XCZS2AYKJOB372DSZ7Y2LKE5NQMK7HZUXDA confirmed in round 13391174

Process finished with exit code 0

至此algorand区块链的一些基本操作均已在go-sdk实现。

赶路的等车人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
区块链开发详解
CDdajian的博客
05-19 6501
开发业务层区块链应用 Hyperledger fabric目前支持java，nodejs，go和python语言的sdk，供用户选择用不同的语言开发上层应用，使用相应的sdk调用部署在区块链上的链码。以下示例中我们选择使用go语言开发业务层应用。 步骤1：配置fabric sdk Hyperledger fabric官方提供了我们需要的go sdk文件包。目前BCS服务使用的版本commit号是035e4f9。 我们需要为fabric sdk生成相应的配置文件和访问区块链节点的组织证书。SDK配置文件主要包
algo-builder:自动开发Algorand资产和智能合约的框架
03-15
算法生成器 自动开发Algorand资产和智能合约的框架： algob ：工具 types/algosdk ：algosdk-js的TypeScript types/algosdk runtime ：light algorand运行时和TEAL解释器 目标 Algo Builder是Algorand dapps（去中心化应用程序）的可信赖框架。 其主要目标是使Algorand应用程序的运输变得简单，高效和可扩展。 可以将其视为Algorand的松露套件。 该框架通过algob工具提供以下功能： REPL（控制台读取-评估-打印循环）可快速轻松地与Algorand标准资产和智能合约进行交互 集成测试框架， 有用的样板，使开发人员可以专注于用例，而不是代码组织，示例 阿尔戈兰德私人网 轻松入门过程的教程。 为了吸引更多的Web开发人员，我们计划为带有TypeScript绑定（用于TE
区块链应用 项目开发步骤
软件工程小施同学 的专栏
08-26 2473
1、哪些数据可以“上链”？ 只有多方要在交易过程中用到的、必须共享的关键数据要上链，比如公共账本的账目。 2、合约里写什么逻辑？ 应该是写多方共同参与、协作记账、必须全局共识的关键逻辑，而不是牵涉密集计算的逻辑。 3、用户身份？ 分布式身份标识（DID）是一套涵盖了分布式身份管理、可信数据交换的规范。权威机构为用户完成KYC，颁发凭据。用户将身份标识的摘要公布到链上，而将自己隐私数据存在链下（这一点非常重要）。 使用时，用户采用“明确授权”和“选择性披露”的策略，仅需出示少量的信息或加密证明，与.
区块链项目（algorand）开发过程全记录（一）
qq_41009600的博客
04-07 695
blog2 这个项目里里外外花了1、2个月才算弄明白，走了许多弯路，将过程记录如下，希望能为老铁们提供些许经验。 这篇文章主要分为go-algorand和go-algorand-sdk两部分，想查看sdk开发过程的小伙伴请移步：区块链项目（algorand）开发过程全记录（二） Algorand介绍 Algorand是一种新的加密货币，确认交易一分钟左右延迟，同时可扩展到许多用户。 Algorand确保用户永远不会就已确认交易的视图产生分歧，即使某些用户是恶意的和网络已临时分区。相反，现有的加密货币允许暂时
AlgorandStudio:一个为Algorand区块链开发Algorand智能合约（ASC1）的IDE
05-01
阿尔戈兰德工作室 Algorand Studio是用于为开发的 。 它包括代码编辑器和编译器， 集成，Algorand节点，密钥对管理器和块浏览器。 IDE还可以帮助构建Algorand事务，包括，多签名事务， 创建/转移/以及 和合同执行。 安装 下载 中提供了安装软件包。 请根据您的操作系统选择适当的格式（对于Mac OS为.dmg或.zip ，对于Linux为.AppImage ）。 安装 MacOS ：双击以打开AlgorandStudio-xxxdmg并将Algorand Studio拖到Applications文件夹中。 Linux右键单击AlgorandStudio-xxxAppImage ，选择Properties => Permissions => Execute ，然后选中选项Allow executing file as progrom 。 关闭属性窗口，然后双击应
区块链项目开发实战.zip
08-22
区块链项目开发指南
JAVA区块链项目实战视频课程
08-24
JAVA区块链项目实战视频课程分享下载，完整版，提供源码！ 全国首套，基于java的区块链实战教程。目的是让更多的java编程者了解区块链，掌握区块链开发。
区块链项目开发
06-12
区块链项目开发指南（区块链技术丛书）。亚马逊原版书。
项目开发流程说明
Science Explorer
08-17 1101
项目开发流程示意图如下：
Go-Algorand的Go官方实现
08-14
Algorand是一个免授权，纯粹的股权证明区块链，可提供分散，可扩展性，安全性和交易终结性。
algorand论文
09-16
Algorand是权益证明(POS)的一个升级，彻底消除区块链分叉的可能性，可以在一小段时间内确认交易，Algorand的核心使用称为BA⋆的拜占庭协议，同时扩展到许多用户。即使一些用户是恶意的，网络被临时分区，Algorand也确保用户从未对已确认的交易有不同意见。在Algorand的BA⋆协议中，除了私钥之外，用户不会保留任何私有状态。
php-algorand-sdk:一个用于与Algorand网络交互PHP库（SDK）
04-01
PHP Algorand SDK（算法，kmd和索引器） 一个用于与Algorand网络交互PHP库。 该目录中的所有文件将向您展示在将php-algorand-sdk实施到项目中时应执行的最佳操作。 要求 PHP 7.2及更高版本。 内置的libcurl支持。 快速开始 要运行此示例，您需要先安装php-algorand-sdk库，然后启动该节点。 $ git clone https://github.com/ffsolutions/php-algorand-sdk $ ./goal node start -d data $ ./goal kmd start -d data $ ./algorand-indexer daemon -h -d data 克隆存储库后，您需要包括php-algorand-sdk ： require_once 'sdk/algorand.php' ;
py-algorand-sdk：Algorand Python SDK
02-17
py-algorand-sdk 用于与Algorand网络交互的python库。 安装 运行$ pip3 install py-algorand-sdk来安装软件包。 或者，选择一个，然后运行$ pip3 install [file name] 。 SDK开发 使用make docker-test运行make docker-test 快速开始 这是一个简单的示例，您可以在没有节点的情况下运行。 from algosdk import account , encoding # generate an account private_key , address = account . generate_account () print ( "Private key:" , private_key ) print ( "Address:" , address ) # check if th
Pollarizer：Pollarizer是一个非常简单的dApp，您可以在其中使用Algorand的区块链和IPFS的API以及Node.js和Vue.js作为软件堆栈来参与或创建新的民意调查
02-02
极化器 项目设置 npm install 编译和热重装以进行开发 npm run serve 编译并最小化生产 npm run build 整理和修复文件 npm run lint 自定义配置 请参阅。
[转] 项目开发的基本流程
xu13879531489的专栏
06-11 245
不记得是某位仁兄总结的了，但是挺好，贴出来，以便以后可以看看：一 应用规划：※确定功能。※必须的界面及界面跳转的流程。※需要的数据及数据的来源及格式。※是否需要服务端支持。※是否需要本地数据库支持。※是否需要特殊权限。※是否需要后台服务。二 架构设计：※分层。※网络连接。※数据处理-xml、domain。※封装Activity。三 界面设计：※主界面确定。※模块界面、列表、查看、编辑界面。※菜单、...
Algorand正式开放测试网TestNet！
weixin_42651541的博客
04-18 424
Algorand正式开放测试网TestNet 图灵奖得主Silvio Micali的基础区块链平台，带着数百位内测活跃用户正式对公众开放测试网！ 马萨诸塞州波士顿 - 2019年4月16日 - 开源软件和区块链技术公司Algorand今天宣布向公众开放其TestNet测试网。在拥有数百名参与者的内测时期之后，Algorand现在邀请所有企业，开发人员和用户参与测试网TestNet，并欢迎提供有关T...
Algorand
热门推荐
桑安琪的成长之路
12-19 1万+
Algorand是权益证明(POS)的一个升级，彻底消除区块链分叉的可能性，可以在一小段时间内确认交易，Algorand的核心使用称为BA⋆的拜占庭协议，同时扩展到许多用户。即使一些用户是恶意的，网络被临时分区，Algorand也确保用户从未对已确认的交易有不同意见。在Algorand的BA⋆协议中，除了私钥之外，用户不会保留任何私有状态。 两种共识： 最终共识： BA⋆（）将不会
Algorand抽签算法详解
飞久
07-31 5607
Algorand是图灵奖得主Micali教授提出的一种新的共识算法，论文地址： https://people.csail.mit.edu/nickolai/papers/gilad-algorand.pdf 和目前流行的DPOS+BFT共识相比，最主要的创新是将proposer和validator的选举随机化： proposer：根据随机数选出26个左右的proposer，从...
hyperledger(超级账本)fabric区块链项目开发实战视频教程
最新发布
02-07
而Hyperledger Fabric区块链项目开发实战视频教程则是为那些对区块链技术感兴趣的开发者和企业提供的实用指南。 这个视频教程将会包括从入门到精通的内容，让学习者能够深入了解Hyperledger Fabric的架构、设计原则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值