From 9849aeda673104e6467c383eefd03d6a360176fe Mon Sep 17 00:00:00 2001 From: Daniel Akhterov Date: Fri, 13 Dec 2019 19:50:46 -0800 Subject: [PATCH] Implement various queries and transactions --- account_delete_transaction.go | 56 ++++++++++++++++++ account_info_query.go | 61 ++++++++++++++++++++ account_update_transaction.go | 76 +++++++++++++++++++++++++ contact_execute_transaction.go | 71 +++++++++++++++++++++++ contract_bytecode_query.go | 33 +++++++++++ contract_create_transaction.go | 101 +++++++++++++++++++++++++++++++++ contract_delete_transaction.go | 56 ++++++++++++++++++ contract_info_query.go | 54 ++++++++++++++++++ contract_update_transaction.go | 81 ++++++++++++++++++++++++++ file_append_transaction.go | 61 ++++++++++++++++++++ file_contents_query.go | 31 ++++++++++ file_create_transaction.go | 82 ++++++++++++++++++++++++++ file_delete_transaction.go | 56 ++++++++++++++++++ file_info_query.go | 48 ++++++++++++++++ file_update_transaction.go | 72 +++++++++++++++++++++++ time.go | 4 ++ 16 files changed, 943 insertions(+) create mode 100644 account_delete_transaction.go create mode 100644 account_info_query.go create mode 100644 account_update_transaction.go create mode 100644 contact_execute_transaction.go create mode 100644 contract_bytecode_query.go create mode 100644 contract_create_transaction.go create mode 100644 contract_delete_transaction.go create mode 100644 contract_info_query.go create mode 100644 contract_update_transaction.go create mode 100644 file_append_transaction.go create mode 100644 file_contents_query.go create mode 100644 file_create_transaction.go create mode 100644 file_delete_transaction.go create mode 100644 file_info_query.go create mode 100644 file_update_transaction.go diff --git a/account_delete_transaction.go b/account_delete_transaction.go new file mode 100644 index 000000000..02013cefc --- /dev/null +++ b/account_delete_transaction.go @@ -0,0 +1,56 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type AccountDeleteTransaction struct { + TransactionBuilder + pb *proto.CryptoDeleteTransactionBody +} + +func NewAccountDeleteTransaction() AccountDeleteTransaction { + pb := &proto.CryptoDeleteTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_CryptoDelete{pb} + + builder := AccountDeleteTransaction{inner, pb} + + return builder +} + +func (builder AccountDeleteTransaction) SetAccountId(id AccountID) AccountDeleteTransaction { + builder.pb.DeleteAccountID = id.toProto() + return builder +} + +func (builder AccountDeleteTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder AccountDeleteTransaction) SetMaxTransactionFee(maxTransactionFee uint64) AccountDeleteTransaction { + return AccountDeleteTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder AccountDeleteTransaction) SetMemo(memo string) AccountDeleteTransaction { + return AccountDeleteTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder AccountDeleteTransaction) SetTransactionValidDuration(validDuration time.Duration) AccountDeleteTransaction { + return AccountDeleteTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder AccountDeleteTransaction) SetTransactionID(transactionID TransactionID) AccountDeleteTransaction { + return AccountDeleteTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder AccountDeleteTransaction) SetNodeAccountID(nodeAccountID AccountID) AccountDeleteTransaction { + return AccountDeleteTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/account_info_query.go b/account_info_query.go new file mode 100644 index 000000000..902993fdd --- /dev/null +++ b/account_info_query.go @@ -0,0 +1,61 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type AccountInfoQuery struct { + QueryBuilder + pb *proto.CryptoGetInfoQuery +} + +type AccountInfo struct { + AccountID AccountID + ContractAccountID string + Deleted bool + ProxyAccountID AccountID + ProxyReceived int64 + Key Ed25519PublicKey + Balance uint64 + GenerateSendRecordThreshold uint64 + GenerateReceiveRecordThreshold uint64 + ReceiverSigRequired bool + ExpirationTime time.Time + AutoRenewPeriod time.Duration +} + +func NewAccountInfoQuery() *AccountInfoQuery { + pb := &proto.CryptoGetInfoQuery{Header: &proto.QueryHeader{}} + + inner := newQueryBuilder(pb.Header) + inner.pb.Query = &proto.Query_CryptoGetInfo{pb} + + return &AccountInfoQuery{inner, pb} +} + +func (builder *AccountInfoQuery) SetAccountID(id AccountID) *AccountInfoQuery { + builder.pb.AccountID = id.toProto() + return builder +} + +func (builder *AccountInfoQuery) Execute(client *Client) (AccountInfo, error) { + resp, err := builder.execute(client) + if err != nil { + return AccountInfo{}, err + } + + return AccountInfo{ + AccountID: accountIDFromProto(resp.GetCryptoGetInfo().AccountInfo.AccountID), + ContractAccountID: resp.GetCryptoGetInfo().AccountInfo.ContractAccountID, + Deleted: resp.GetCryptoGetInfo().AccountInfo.Deleted, + ProxyAccountID: accountIDFromProto(resp.GetCryptoGetInfo().AccountInfo.ProxyAccountID), + ProxyReceived: resp.GetCryptoGetInfo().AccountInfo.ProxyReceived, + Key: Ed25519PublicKey{keyData: resp.GetCryptoGetInfo().AccountInfo.Key.GetEd25519()}, + Balance: resp.GetCryptoGetInfo().AccountInfo.Balance, + GenerateSendRecordThreshold: resp.GetCryptoGetInfo().AccountInfo.GenerateSendRecordThreshold, + GenerateReceiveRecordThreshold: resp.GetCryptoGetInfo().AccountInfo.GenerateReceiveRecordThreshold, + ReceiverSigRequired: resp.GetCryptoGetInfo().AccountInfo.ReceiverSigRequired, + ExpirationTime: timeFromProto(resp.GetCryptoGetInfo().AccountInfo.ExpirationTime), + }, nil +} diff --git a/account_update_transaction.go b/account_update_transaction.go new file mode 100644 index 000000000..24e2cd003 --- /dev/null +++ b/account_update_transaction.go @@ -0,0 +1,76 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type AccountUpdateTransaction struct { + TransactionBuilder + pb *proto.CryptoUpdateTransactionBody +} + +func NewAccountUpdateTransaction() AccountUpdateTransaction { + pb := &proto.CryptoUpdateTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_CryptoUpdateAccount{pb} + + builder := AccountUpdateTransaction{inner, pb} + + return builder +} + +func (builder AccountUpdateTransaction) SetAccountID(id AccountID) AccountUpdateTransaction { + builder.pb.AccountIDToUpdate = id.toProto() + return builder +} + +func (builder AccountUpdateTransaction) SetKey(publicKey Ed25519PublicKey) AccountUpdateTransaction { + builder.pb.Key = publicKey.toProto() + return builder +} + +func (builder AccountUpdateTransaction) SetProxyAccountID(id AccountID) AccountUpdateTransaction { + builder.pb.ProxyAccountID = id.toProto() + return builder +} + +func (builder AccountUpdateTransaction) SetAutoRenewPeriod(autoRenewPeriod time.Duration) AccountUpdateTransaction { + builder.pb.AutoRenewPeriod = durationToProto(autoRenewPeriod) + return builder +} + +func (builder AccountUpdateTransaction) SetExpirationTime(expiration time.Time) AccountUpdateTransaction { + builder.pb.ExpirationTime = timeToProto(expiration) + return builder +} + +func (builder AccountUpdateTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder AccountUpdateTransaction) SetMaxTransactionFee(maxTransactionFee uint64) AccountUpdateTransaction { + return AccountUpdateTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder AccountUpdateTransaction) SetMemo(memo string) AccountUpdateTransaction { + return AccountUpdateTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder AccountUpdateTransaction) SetTransactionValidDuration(validDuration time.Duration) AccountUpdateTransaction { + return AccountUpdateTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder AccountUpdateTransaction) SetTransactionID(transactionID TransactionID) AccountUpdateTransaction { + return AccountUpdateTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder AccountUpdateTransaction) SetNodeAccountID(nodeAccountID AccountID) AccountUpdateTransaction { + return AccountUpdateTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/contact_execute_transaction.go b/contact_execute_transaction.go new file mode 100644 index 000000000..62b5941f1 --- /dev/null +++ b/contact_execute_transaction.go @@ -0,0 +1,71 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type ContractExecuteTransaction struct { + TransactionBuilder + pb *proto.ContractCallTransactionBody +} + +func NewContractExecuteTransaction() ContractExecuteTransaction { + pb := &proto.ContractCallTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_ContractCall{pb} + + builder := ContractExecuteTransaction{inner, pb} + + return builder +} + +func (builder ContractExecuteTransaction) SetContractID(id ContractID) ContractExecuteTransaction { + builder.pb.ContractID = id.toProto() + return builder +} + +func (builder ContractExecuteTransaction) SetGas(gas uint64) ContractExecuteTransaction { + builder.pb.Gas = int64(gas) + return builder +} + +func (builder ContractExecuteTransaction) SetAmount(amount uint64) ContractExecuteTransaction { + builder.pb.Amount = int64(amount) + return builder +} + +func (builder ContractExecuteTransaction) SetFunctionParameters(params []byte) ContractExecuteTransaction { + builder.pb.FunctionParameters = params + return builder +} + +func (builder ContractExecuteTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder ContractExecuteTransaction) SetMaxTransactionFee(maxTransactionFee uint64) ContractExecuteTransaction { + return ContractExecuteTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder ContractExecuteTransaction) SetMemo(memo string) ContractExecuteTransaction { + return ContractExecuteTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder ContractExecuteTransaction) SetTransactionValidDuration(validDuration time.Duration) ContractExecuteTransaction { + return ContractExecuteTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder ContractExecuteTransaction) SetTransactionID(transactionID TransactionID) ContractExecuteTransaction { + return ContractExecuteTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder ContractExecuteTransaction) SetNodeAccountID(nodeAccountID AccountID) ContractExecuteTransaction { + return ContractExecuteTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/contract_bytecode_query.go b/contract_bytecode_query.go new file mode 100644 index 000000000..ae010d233 --- /dev/null +++ b/contract_bytecode_query.go @@ -0,0 +1,33 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" +) + +type ContractBytecodeQuery struct { + QueryBuilder + pb *proto.ContractGetBytecodeQuery +} + +func NewContractBytecodeQuery() *ContractBytecodeQuery { + pb := &proto.ContractGetBytecodeQuery{Header: &proto.QueryHeader{}} + + inner := newQueryBuilder(pb.Header) + inner.pb.Query = &proto.Query_ContractGetBytecode{pb} + + return &ContractBytecodeQuery{inner, pb} +} + +func (builder *ContractBytecodeQuery) SetContractId(id ContractID) *ContractBytecodeQuery { + builder.pb.ContractID = id.toProto() + return builder +} + +func (builder *ContractBytecodeQuery) Execute(client *Client) ([]byte, error) { + resp, err := builder.execute(client) + if err != nil { + return []byte{}, err + } + + return resp.GetContractGetBytecodeResponse().Bytecode, nil +} diff --git a/contract_create_transaction.go b/contract_create_transaction.go new file mode 100644 index 000000000..f7e800dc8 --- /dev/null +++ b/contract_create_transaction.go @@ -0,0 +1,101 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type ContractCreateTransaction struct { + TransactionBuilder + pb *proto.ContractCreateTransactionBody +} + +func NewContractCreateTransaction() ContractCreateTransaction { + pb := &proto.ContractCreateTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_ContractCreateInstance{pb} + + builder := ContractCreateTransaction{inner, pb} + + return builder +} + +func (builder ContractCreateTransaction) SetBytecodeFile(id FileID) ContractCreateTransaction { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder ContractCreateTransaction) SetAdminKey(publicKey Ed25519PublicKey) ContractCreateTransaction { + builder.pb.AdminKey = publicKey.toProto() + return builder +} + +func (builder ContractCreateTransaction) SetGas(gas uint64) ContractCreateTransaction { + builder.pb.Gas = int64(gas) + return builder +} + +func (builder ContractCreateTransaction) SetInitialBalance(tinyBars uint64) ContractCreateTransaction { + builder.pb.InitialBalance = int64(tinyBars) + return builder +} + +func (builder ContractCreateTransaction) SetProxyAccountID(id AccountID) ContractCreateTransaction { + builder.pb.ProxyAccountID = id.toProto() + return builder +} + +func (builder ContractCreateTransaction) SetAutoRenewPeriod(autoRenewPeriod time.Duration) ContractCreateTransaction { + builder.pb.AutoRenewPeriod = durationToProto(autoRenewPeriod) + return builder +} + +func (builder ContractCreateTransaction) SetConstructorParams(params []byte) ContractCreateTransaction { + builder.pb.ConstructorParameters = params + return builder +} + +func (builder ContractCreateTransaction) Build(client *Client) Transaction { + // If a shard/realm is not set, it is inferred from the Operator on the Client + + if builder.pb.ShardID == nil { + builder.pb.ShardID = &proto.ShardID{ + ShardNum: int64(client.operator.accountID.Shard), + } + } + + if builder.pb.RealmID == nil { + builder.pb.RealmID = &proto.RealmID{ + ShardNum: int64(client.operator.accountID.Shard), + RealmNum: int64(client.operator.accountID.Realm), + } + } + + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder ContractCreateTransaction) SetMaxTransactionFee(maxTransactionFee uint64) ContractCreateTransaction { + return ContractCreateTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder ContractCreateTransaction) SetMemo(memo string) ContractCreateTransaction { + return ContractCreateTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder ContractCreateTransaction) SetTransactionValidDuration(validDuration time.Duration) ContractCreateTransaction { + return ContractCreateTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder ContractCreateTransaction) SetTransactionID(transactionID TransactionID) ContractCreateTransaction { + return ContractCreateTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder ContractCreateTransaction) SetNodeAccountID(nodeAccountID AccountID) ContractCreateTransaction { + return ContractCreateTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/contract_delete_transaction.go b/contract_delete_transaction.go new file mode 100644 index 000000000..7ab834cb4 --- /dev/null +++ b/contract_delete_transaction.go @@ -0,0 +1,56 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type ContractDeleteTransaction struct { + TransactionBuilder + pb *proto.ContractDeleteTransactionBody +} + +func NewContractDeleteTransaction() ContractDeleteTransaction { + pb := &proto.ContractDeleteTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_ContractDeleteInstance{pb} + + builder := ContractDeleteTransaction{inner, pb} + + return builder +} + +func (builder ContractDeleteTransaction) SetContractID(id ContractID) ContractDeleteTransaction { + builder.pb.ContractID = id.toProto() + return builder +} + +func (builder ContractDeleteTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder ContractDeleteTransaction) SetMaxTransactionFee(maxTransactionFee uint64) ContractDeleteTransaction { + return ContractDeleteTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder ContractDeleteTransaction) SetMemo(memo string) ContractDeleteTransaction { + return ContractDeleteTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder ContractDeleteTransaction) SetTransactionValidDuration(validDuration time.Duration) ContractDeleteTransaction { + return ContractDeleteTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder ContractDeleteTransaction) SetTransactionID(transactionID TransactionID) ContractDeleteTransaction { + return ContractDeleteTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder ContractDeleteTransaction) SetNodeAccountID(nodeAccountID AccountID) ContractDeleteTransaction { + return ContractDeleteTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/contract_info_query.go b/contract_info_query.go new file mode 100644 index 000000000..93200ac47 --- /dev/null +++ b/contract_info_query.go @@ -0,0 +1,54 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type ContractInfoQuery struct { + QueryBuilder + pb *proto.ContractGetInfoQuery +} + +type ContractInfo struct { + AccountID AccountID + ContractID ContractID + ContractAccountID string + AdminKey Ed25519PublicKey + ExpirationTime time.Time + AutoRenewPeriod time.Duration + Storage uint64 + Memo string +} + +func NewContractInfoQuery() *ContractInfoQuery { + pb := &proto.ContractGetInfoQuery{Header: &proto.QueryHeader{}} + + inner := newQueryBuilder(pb.Header) + inner.pb.Query = &proto.Query_ContractGetInfo{pb} + + return &ContractInfoQuery{inner, pb} +} + +func (builder *ContractInfoQuery) SetContractID(id ContractID) *ContractInfoQuery { + builder.pb.ContractID = id.toProto() + return builder +} + +func (builder *ContractInfoQuery) Execute(client *Client) (ContractInfo, error) { + resp, err := builder.execute(client) + if err != nil { + return ContractInfo{}, err + } + + return ContractInfo{ + AccountID: accountIDFromProto(resp.GetContractGetInfo().ContractInfo.AccountID), + ContractID: contractIDFromProto(resp.GetContractGetInfo().ContractInfo.ContractID), + ContractAccountID: resp.GetContractGetInfo().ContractInfo.ContractAccountID, + AdminKey: Ed25519PublicKey{keyData: resp.GetContractGetInfo().ContractInfo.AdminKey.GetEd25519()}, + ExpirationTime: timeFromProto(resp.GetContractGetInfo().ContractInfo.ExpirationTime), + AutoRenewPeriod: durationFromProto(resp.GetContractGetInfo().ContractInfo.AutoRenewPeriod), + Storage: uint64(resp.GetContractGetInfo().ContractInfo.Storage), + Memo: resp.GetContractGetInfo().ContractInfo.Memo, + }, nil +} diff --git a/contract_update_transaction.go b/contract_update_transaction.go new file mode 100644 index 000000000..e8e52bcf2 --- /dev/null +++ b/contract_update_transaction.go @@ -0,0 +1,81 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type ContractUpdateTransaction struct { + TransactionBuilder + pb *proto.ContractUpdateTransactionBody +} + +func NewContractUpdateTransaction() ContractUpdateTransaction { + pb := &proto.ContractUpdateTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_ContractUpdateInstance{pb} + + builder := ContractUpdateTransaction{inner, pb} + + return builder +} + +func (builder ContractUpdateTransaction) SetContractID(id ContractID) ContractUpdateTransaction { + builder.pb.ContractID = id.toProto() + return builder +} + +func (builder ContractUpdateTransaction) SetBytecodeFile(id FileID) ContractUpdateTransaction { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder ContractUpdateTransaction) SetAdminKey(publicKey Ed25519PublicKey) ContractUpdateTransaction { + builder.pb.AdminKey = publicKey.toProto() + return builder +} + +func (builder ContractUpdateTransaction) SetProxyAccountID(id AccountID) ContractUpdateTransaction { + builder.pb.ProxyAccountID = id.toProto() + return builder +} + +func (builder ContractUpdateTransaction) SetAutoRenewPeriod(autoRenewPeriod time.Duration) ContractUpdateTransaction { + builder.pb.AutoRenewPeriod = durationToProto(autoRenewPeriod) + return builder +} + +func (builder ContractUpdateTransaction) SetExpirationTime(expiration time.Time) ContractUpdateTransaction { + builder.pb.ExpirationTime = timeToProto(expiration) + return builder +} + +func (builder ContractUpdateTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder ContractUpdateTransaction) SetMaxTransactionFee(maxTransactionFee uint64) ContractUpdateTransaction { + return ContractUpdateTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder ContractUpdateTransaction) SetMemo(memo string) ContractUpdateTransaction { + return ContractUpdateTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder ContractUpdateTransaction) SetTransactionValidDuration(validDuration time.Duration) ContractUpdateTransaction { + return ContractUpdateTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder ContractUpdateTransaction) SetTransactionID(transactionID TransactionID) ContractUpdateTransaction { + return ContractUpdateTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder ContractUpdateTransaction) SetNodeAccountID(nodeAccountID AccountID) ContractUpdateTransaction { + return ContractUpdateTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/file_append_transaction.go b/file_append_transaction.go new file mode 100644 index 000000000..217d86b33 --- /dev/null +++ b/file_append_transaction.go @@ -0,0 +1,61 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type FileAppendTransaction struct { + TransactionBuilder + pb *proto.FileAppendTransactionBody +} + +func NewFileAppendTransaction() FileAppendTransaction { + pb := &proto.FileAppendTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_FileAppend{pb} + + builder := FileAppendTransaction{inner, pb} + + return builder +} + +func (builder FileAppendTransaction) SetFileID(id FileID) FileAppendTransaction { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder FileAppendTransaction) SetContents(contents []byte) FileAppendTransaction { + builder.pb.Contents = contents + return builder +} + +func (builder FileAppendTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder FileAppendTransaction) SetMaxTransactionFee(maxTransactionFee uint64) FileAppendTransaction { + return FileAppendTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder FileAppendTransaction) SetMemo(memo string) FileAppendTransaction { + return FileAppendTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder FileAppendTransaction) SetTransactionValidDuration(validDuration time.Duration) FileAppendTransaction { + return FileAppendTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder FileAppendTransaction) SetTransactionID(transactionID TransactionID) FileAppendTransaction { + return FileAppendTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder FileAppendTransaction) SetNodeAccountID(nodeAccountID AccountID) FileAppendTransaction { + return FileAppendTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/file_contents_query.go b/file_contents_query.go new file mode 100644 index 000000000..585e8cfd6 --- /dev/null +++ b/file_contents_query.go @@ -0,0 +1,31 @@ +package hedera + +import "github.com/hashgraph/hedera-sdk-go/proto" + +type FileContentsQuery struct { + QueryBuilder + pb *proto.FileGetContentsQuery +} + +func NewFileContentsQuery() *FileContentsQuery { + pb := &proto.FileGetContentsQuery{Header: &proto.QueryHeader{}} + + inner := newQueryBuilder(pb.Header) + inner.pb.Query = &proto.Query_FileGetContents{pb} + + return &FileContentsQuery{inner, pb} +} + +func (builder *FileContentsQuery) SetFileID(id FileID) *FileContentsQuery { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder *FileContentsQuery) Execute(client *Client) ([]byte, error) { + resp, err := builder.execute(client) + if err != nil { + return []byte{}, err + } + + return resp.GetFileGetContents().FileContents.Contents, nil +} diff --git a/file_create_transaction.go b/file_create_transaction.go new file mode 100644 index 000000000..e768ba493 --- /dev/null +++ b/file_create_transaction.go @@ -0,0 +1,82 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type FileCreateTransaction struct { + TransactionBuilder + pb *proto.FileCreateTransactionBody +} + +func NewFileCreateTransaction() FileCreateTransaction { + pb := &proto.FileCreateTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_FileCreate{pb} + + builder := FileCreateTransaction{inner, pb} + builder.SetExpirationTime(time.Now().Add(7890000 * time.Second)) + + return builder +} + +func (builder FileCreateTransaction) AddKey(publicKey Ed25519PublicKey) FileCreateTransaction { + builder.pb.Keys.Keys = append(builder.pb.Keys.GetKeys(), publicKey.toProto()) + return builder +} + +func (builder FileCreateTransaction) SetExpirationTime(expiration time.Time) FileCreateTransaction { + builder.pb.ExpirationTime = timeToProto(expiration) + return builder +} + +func (builder FileCreateTransaction) SetContents(contents []byte) FileCreateTransaction { + builder.pb.Contents = contents + return builder +} + +func (builder FileCreateTransaction) Build(client *Client) Transaction { + // If a shard/realm is not set, it is inferred from the Operator on the Client + + if builder.pb.ShardID == nil { + builder.pb.ShardID = &proto.ShardID{ + ShardNum: int64(client.operator.accountID.Shard), + } + } + + if builder.pb.RealmID == nil { + builder.pb.RealmID = &proto.RealmID{ + ShardNum: int64(client.operator.accountID.Shard), + RealmNum: int64(client.operator.accountID.Realm), + } + } + + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder FileCreateTransaction) SetMaxTransactionFee(maxTransactionFee uint64) FileCreateTransaction { + return FileCreateTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder FileCreateTransaction) SetMemo(memo string) FileCreateTransaction { + return FileCreateTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder FileCreateTransaction) SetTransactionValidDuration(validDuration time.Duration) FileCreateTransaction { + return FileCreateTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder FileCreateTransaction) SetTransactionID(transactionID TransactionID) FileCreateTransaction { + return FileCreateTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder FileCreateTransaction) SetNodeAccountID(nodeAccountID AccountID) FileCreateTransaction { + return FileCreateTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/file_delete_transaction.go b/file_delete_transaction.go new file mode 100644 index 000000000..c3104e446 --- /dev/null +++ b/file_delete_transaction.go @@ -0,0 +1,56 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type FileDeleteTransaction struct { + TransactionBuilder + pb *proto.FileDeleteTransactionBody +} + +func NewFileDeleteTransaction() FileDeleteTransaction { + pb := &proto.FileDeleteTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_FileDelete{pb} + + builder := FileDeleteTransaction{inner, pb} + + return builder +} + +func (builder FileDeleteTransaction) SetFileID(id FileID) FileDeleteTransaction { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder FileDeleteTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder FileDeleteTransaction) SetMaxTransactionFee(maxTransactionFee uint64) FileDeleteTransaction { + return FileDeleteTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder FileDeleteTransaction) SetMemo(memo string) FileDeleteTransaction { + return FileDeleteTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder FileDeleteTransaction) SetTransactionValidDuration(validDuration time.Duration) FileDeleteTransaction { + return FileDeleteTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder FileDeleteTransaction) SetTransactionID(transactionID TransactionID) FileDeleteTransaction { + return FileDeleteTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder FileDeleteTransaction) SetNodeAccountID(nodeAccountID AccountID) FileDeleteTransaction { + return FileDeleteTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/file_info_query.go b/file_info_query.go new file mode 100644 index 000000000..6e92c83f5 --- /dev/null +++ b/file_info_query.go @@ -0,0 +1,48 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type FileInfoQuery struct { + QueryBuilder + pb *proto.FileGetInfoQuery +} + +type FileInfo struct { + FileID FileID + Size int64 + ExpirationTime time.Time + Deleted bool + // TODO: When KeyList is implemented + // Keys []Keys +} + +func NewFileInfoQuery() *FileInfoQuery { + pb := &proto.FileGetInfoQuery{Header: &proto.QueryHeader{}} + + inner := newQueryBuilder(pb.Header) + inner.pb.Query = &proto.Query_FileGetInfo{pb} + + return &FileInfoQuery{inner, pb} +} + +func (builder *FileInfoQuery) SetFileID(id FileID) *FileInfoQuery { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder *FileInfoQuery) Execute(client *Client) (FileInfo, error) { + resp, err := builder.execute(client) + if err != nil { + return FileInfo{}, err + } + + return FileInfo{ + FileID: fileIDFromProto(resp.GetFileGetInfo().FileInfo.FileID), + Size: resp.GetFileGetInfo().FileInfo.Size, + ExpirationTime: timeFromProto(resp.GetFileGetInfo().FileInfo.ExpirationTime), + Deleted: resp.GetFileGetInfo().FileInfo.Deleted, + }, nil +} diff --git a/file_update_transaction.go b/file_update_transaction.go new file mode 100644 index 000000000..0b7e3dd46 --- /dev/null +++ b/file_update_transaction.go @@ -0,0 +1,72 @@ +package hedera + +import ( + "github.com/hashgraph/hedera-sdk-go/proto" + "time" +) + +type FileUpdateTransaction struct { + TransactionBuilder + pb *proto.FileUpdateTransactionBody +} + +func NewFileUpdateTransaction() FileUpdateTransaction { + pb := &proto.FileUpdateTransactionBody{} + + inner := newTransactionBuilder() + inner.pb.Data = &proto.TransactionBody_FileUpdate{pb} + + builder := FileUpdateTransaction{inner, pb} + builder.SetExpirationTime(time.Now().Add(7890000 * time.Second)) + + return builder +} + +func (builder FileUpdateTransaction) SetFileID(id FileID) FileUpdateTransaction { + builder.pb.FileID = id.toProto() + return builder +} + +func (builder FileUpdateTransaction) AddKey(publicKey Ed25519PublicKey) FileUpdateTransaction { + builder.pb.Keys.Keys = append(builder.pb.Keys.GetKeys(), publicKey.toProto()) + return builder +} + +func (builder FileUpdateTransaction) SetExpirationTime(expiration time.Time) FileUpdateTransaction { + builder.pb.ExpirationTime = timeToProto(expiration) + return builder +} + +func (builder FileUpdateTransaction) SetContents(contents []byte) FileUpdateTransaction { + builder.pb.Contents = contents + return builder +} + +func (builder FileUpdateTransaction) Build(client *Client) Transaction { + return builder.TransactionBuilder.Build(client) +} + +// +// The following _5_ must be copy-pasted at the bottom of **every** _transaction.go file +// We override the embedded fluent setter methods to return the outer type +// + +func (builder FileUpdateTransaction) SetMaxTransactionFee(maxTransactionFee uint64) FileUpdateTransaction { + return FileUpdateTransaction{builder.TransactionBuilder.SetMaxTransactionFee(maxTransactionFee), builder.pb} +} + +func (builder FileUpdateTransaction) SetMemo(memo string) FileUpdateTransaction { + return FileUpdateTransaction{builder.TransactionBuilder.SetMemo(memo), builder.pb} +} + +func (builder FileUpdateTransaction) SetTransactionValidDuration(validDuration time.Duration) FileUpdateTransaction { + return FileUpdateTransaction{builder.TransactionBuilder.SetTransactionValidDuration(validDuration), builder.pb} +} + +func (builder FileUpdateTransaction) SetTransactionID(transactionID TransactionID) FileUpdateTransaction { + return FileUpdateTransaction{builder.TransactionBuilder.SetTransactionID(transactionID), builder.pb} +} + +func (builder FileUpdateTransaction) SetNodeAccountID(nodeAccountID AccountID) FileUpdateTransaction { + return FileUpdateTransaction{builder.TransactionBuilder.SetNodeAccountID(nodeAccountID), builder.pb} +} diff --git a/time.go b/time.go index b8e118998..72be37d9f 100644 --- a/time.go +++ b/time.go @@ -11,6 +11,10 @@ func durationToProto(duration time.Duration) *proto.Duration { } } +func durationFromProto(pb *proto.Duration) time.Duration { + return time.Until(time.Unix(pb.Seconds, 0)) +} + func timeToProto(t time.Time) *proto.Timestamp { return &proto.Timestamp{ Seconds: t.Unix(),