From c22b27f84e43ff3b322e10e8330b0d089f36cc44 Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Wed, 22 May 2024 13:21:20 +0300 Subject: [PATCH 1/6] Initial assets implementation. --- go.mod | 1 - go.sum | 2 - qubic.go | 16 +++ types/assets.go | 280 +++++++++++++++++++++++++++++++++++++++++++++++ types/request.go | 6 + 5 files changed, 302 insertions(+), 3 deletions(-) create mode 100644 types/assets.go diff --git a/go.mod b/go.mod index 73d3377..fc7bcd0 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,6 @@ require ( github.com/cloudflare/fourq v0.0.0-20170427000316-8ada258cf9c8 github.com/google/go-cmp v0.6.0 github.com/pkg/errors v0.9.1 - github.com/qubic/cgo-schnorrq v1.0.0 github.com/silenceper/pool v1.0.0 github.com/stretchr/testify v1.2.2 ) diff --git a/go.sum b/go.sum index af2762e..7d6c8a0 100644 --- a/go.sum +++ b/go.sum @@ -12,8 +12,6 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/qubic/cgo-schnorrq v1.0.0 h1:QKZdR2GMTDvq87vrRCrtjgOE5OCBezvicxf0zhLQKZU= -github.com/qubic/cgo-schnorrq v1.0.0/go.mod h1:8oKelQ6gF4sOSmrqYWztLaskcLXqjG+PPbw60hTaHUQ= github.com/silenceper/pool v1.0.0 h1:JTCaA+U6hJAA0P8nCx+JfsRCHMwLTfatsm5QXelffmU= github.com/silenceper/pool v1.0.0/go.mod h1:3DN13bqAbq86Lmzf6iUXWEPIWFPOSYVfaoceFvilKKI= github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= diff --git a/qubic.go b/qubic.go index 3259c98..cacef33 100644 --- a/qubic.go +++ b/qubic.go @@ -59,6 +59,22 @@ func (qc *Client) getPeers(ctx context.Context) (types.PublicPeers, error) { return result, nil } +func (qc *Client) GetOwnedAssets(ctx context.Context, id string) (types.OwnedAssets, error) { + + identity := types.Identity(id) + pubKey, err := identity.ToPubKey(false) + if err != nil { + return types.OwnedAssets{}, errors.Wrap(err, "converting identity to public key") + } + var result types.OwnedAssets + err = qc.sendRequest(ctx, types.OwnedAssetsRequest, pubKey, &result) + if err != nil { + return types.OwnedAssets{}, errors.Wrap(err, "sending req to node") + } + + return result, nil +} + func (qc *Client) GetIdentity(ctx context.Context, id string) (types.AddressInfo, error) { identity := types.Identity(id) pubKey, err := identity.ToPubKey(false) diff --git a/types/assets.go b/types/assets.go new file mode 100644 index 0000000..ff004bc --- /dev/null +++ b/types/assets.go @@ -0,0 +1,280 @@ +package types + +import ( + "encoding/binary" + "github.com/pkg/errors" + "io" +) + +const ( + AssetsDepth = 24 +) + +type AssetInfo struct { + Tick uint32 + UniverseIndex uint32 + Siblings [AssetsDepth][32]byte +} + +func (ai *AssetInfo) UnmarshallBinary(r io.Reader) error { + err := binary.Read(r, binary.LittleEndian, &ai.Tick) + if err != nil { + return errors.Wrap(err, "reading asset tick") + } + + err = binary.Read(r, binary.LittleEndian, &ai.UniverseIndex) + if err != nil { + return errors.Wrap(err, "reading asset universe index") + } + + /* We don't read siblings as it doesn't seem to be implemented on node side yet. */ + return nil +} + +/* Issued asset */ + +type IssuedAssetData struct { + PublicKey [32]byte + Type byte + Name [7]int8 + NumberOfDecimalPlaces int8 + UnitOfMeasurement [7]int8 +} + +type IssuedAsset struct { + Data IssuedAssetData + Info AssetInfo +} + +type IssuedAssets []IssuedAsset + +func (ad *IssuedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) + if err != nil { + return errors.Wrap(err, "reading issued asset public key") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Type) + if err != nil { + return errors.Wrap(err, "reading issued asset type") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Name) + if err != nil { + return errors.Wrap(err, "reading issued asset name") + } + + err = binary.Read(r, binary.LittleEndian, &ad.NumberOfDecimalPlaces) + if err != nil { + return errors.Wrap(err, "reading issued asset number of decimal places") + } + + err = binary.Read(r, binary.LittleEndian, &ad.UnitOfMeasurement) + if err != nil { + return errors.Wrap(err, "reading issued asset unit of measurement") + } + return nil +} + +/* Possessed asset */ + +type PossessedAssetData struct { + PublicKey [32]byte + Type byte + Padding [1]int8 + ManagingContractIndex uint16 + IssuanceIndex uint32 + NumberOfUnits int64 + OwnedAsset OwnedAssetData + IssuedAsset IssuedAssetData +} + +type PossessedAsset struct { + Data PossessedAssetData + Info AssetInfo +} + +type PossessedAssets []PossessedAsset + +func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { + for { + var header RequestResponseHeader + err := binary.Read(r, binary.BigEndian, &header) + if err != nil { + return errors.Wrap(err, "reading header") + } + + if header.Type == EndResponse { + break + } + + if header.Type != PossessedAssetsResponse { + return errors.Errorf("Invalid header type, expected %d, found %d", PossessedAssetsResponse, header.Type) + } + + var possessedAssetData PossessedAssetData + err = possessedAssetData.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "unmarshalling possessed asset data") + } + + var assetInfo AssetInfo + err = assetInfo.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading possessed asset info") + } + + possessedAsset := PossessedAsset{ + Data: possessedAssetData, + Info: assetInfo, + } + + *pa = append(*pa, possessedAsset) + } + + return nil +} + +func (pd *PossessedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &pd.PublicKey) + if err != nil { + return errors.Wrap(err, "reading asset data") + } + + err = binary.Read(r, binary.LittleEndian, &pd.Type) + if err != nil { + return errors.Wrap(err, "reading asset type") + } + + err = binary.Read(r, binary.LittleEndian, &pd.Padding) + if err != nil { + return errors.Wrap(err, "reading asset padding") + } + + err = binary.Read(r, binary.LittleEndian, &pd.ManagingContractIndex) + if err != nil { + return errors.Wrap(err, "reading asset managing contract index") + } + + err = binary.Read(r, binary.LittleEndian, &pd.IssuanceIndex) + if err != nil { + return errors.Wrap(err, "reading asset issuance index") + } + + err = binary.Read(r, binary.LittleEndian, &pd.NumberOfUnits) + if err != nil { + return errors.Wrap(err, "reading asset number of units") + } + + err = pd.OwnedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading owned asset") + } + + err = pd.IssuedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading issued asset") + } + + return nil +} + +/* Owned Asset */ + +type OwnedAssetData struct { + PublicKey [32]byte + Type byte + Padding [1]int8 + ManagingContractIndex uint16 + IssuanceIndex uint32 + NumberOfUnits int64 + IssuedAsset IssuedAssetData +} + +type OwnedAsset struct { + Data OwnedAssetData + Info AssetInfo +} + +type OwnedAssets []OwnedAsset + +func (oa *OwnedAssets) UnmarshallFromReader(r io.Reader) error { + for { + var header RequestResponseHeader + err := binary.Read(r, binary.BigEndian, &header) + if err != nil { + return errors.Wrap(err, "reading header") + } + + if header.Type == EndResponse { + break + } + + if header.Type != OwnedAssetsResponse { + return errors.Errorf("Invalid header type, expected %d, found %d", OwnedAssetsResponse, header.Type) + } + + var ownedAssetData OwnedAssetData + err = ownedAssetData.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "unmarshalling owned asset data") + } + + var assetInfo AssetInfo + err = assetInfo.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading owned asset info") + } + + ownedAsset := OwnedAsset{ + Data: ownedAssetData, + Info: assetInfo, + } + + *oa = append(*oa, ownedAsset) + } + + return nil +} + +func (ad *OwnedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) + if err != nil { + return errors.Wrap(err, "reading asset data") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Type) + if err != nil { + return errors.Wrap(err, "reading asset type") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Padding) + if err != nil { + return errors.Wrap(err, "reading asset padding") + } + + err = binary.Read(r, binary.LittleEndian, &ad.ManagingContractIndex) + if err != nil { + return errors.Wrap(err, "reading asset managing contract index") + } + + err = binary.Read(r, binary.LittleEndian, &ad.IssuanceIndex) + if err != nil { + return errors.Wrap(err, "reading asset issuance index") + } + + err = binary.Read(r, binary.LittleEndian, &ad.NumberOfUnits) + if err != nil { + return errors.Wrap(err, "reading asset number of units") + } + + err = ad.IssuedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading issued asset") + } + + return nil +} diff --git a/types/request.go b/types/request.go index 0a9707f..ad0ee1b 100644 --- a/types/request.go +++ b/types/request.go @@ -4,6 +4,12 @@ import "math/rand" // request and response types const ( + IssuedAssetsRequest = 36 + IssuedAssetsResponse = 37 + OwnedAssetsRequest = 38 + OwnedAssetsResponse = 39 + PossessedAssetsRequest = 40 + PossessedAssetsResponse = 41 CurrentTickInfoRequest = 27 CurrentTickInfoResponse = 28 BroadcastFutureTickData = 8 From 7889cfb4ec4764805f4daab83546233b5bbbe28f Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Wed, 22 May 2024 13:45:36 +0300 Subject: [PATCH 2/6] Add GetPossessedAssets method. Fix Possessed Asset unmarshalling. --- qubic.go | 16 ++++++++++++++++ types/assets.go | 9 +++------ 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/qubic.go b/qubic.go index cacef33..951dba1 100644 --- a/qubic.go +++ b/qubic.go @@ -59,6 +59,22 @@ func (qc *Client) getPeers(ctx context.Context) (types.PublicPeers, error) { return result, nil } +func (qc *Client) GetPossessedAssets(ctx context.Context, id string) (types.PossessedAssets, error) { + + identity := types.Identity(id) + pubKey, err := identity.ToPubKey(false) + if err != nil { + return types.PossessedAssets{}, errors.Wrap(err, "converting identity to public key") + } + var result types.PossessedAssets + err = qc.sendRequest(ctx, types.PossessedAssetsRequest, pubKey, &result) + if err != nil { + return types.PossessedAssets{}, errors.Wrap(err, "sending req to node") + } + + return result, nil +} + func (qc *Client) GetOwnedAssets(ctx context.Context, id string) (types.OwnedAssets, error) { identity := types.Identity(id) diff --git a/types/assets.go b/types/assets.go index ff004bc..ed54178 100644 --- a/types/assets.go +++ b/types/assets.go @@ -2,6 +2,7 @@ package types import ( "encoding/binary" + "fmt" "github.com/pkg/errors" "io" ) @@ -87,7 +88,6 @@ type PossessedAssetData struct { IssuanceIndex uint32 NumberOfUnits int64 OwnedAsset OwnedAssetData - IssuedAsset IssuedAssetData } type PossessedAsset struct { @@ -105,6 +105,8 @@ func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { return errors.Wrap(err, "reading header") } + fmt.Printf("HEADER: %d | %d\n", header.Type, header.GetSize()) + if header.Type == EndResponse { break } @@ -173,11 +175,6 @@ func (pd *PossessedAssetData) UnmarshallBinary(r io.Reader) error { return errors.Wrap(err, "reading owned asset") } - err = pd.IssuedAsset.UnmarshallBinary(r) - if err != nil { - return errors.Wrap(err, "reading issued asset") - } - return nil } From d52971b20cc6f16cecc84b8d62fd2e78a8647b83 Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Wed, 22 May 2024 13:21:20 +0300 Subject: [PATCH 3/6] Initial assets implementation. --- qubic.go | 16 +++ types/assets.go | 280 +++++++++++++++++++++++++++++++++++++++++++++++ types/request.go | 6 + 3 files changed, 302 insertions(+) create mode 100644 types/assets.go diff --git a/qubic.go b/qubic.go index 3259c98..cacef33 100644 --- a/qubic.go +++ b/qubic.go @@ -59,6 +59,22 @@ func (qc *Client) getPeers(ctx context.Context) (types.PublicPeers, error) { return result, nil } +func (qc *Client) GetOwnedAssets(ctx context.Context, id string) (types.OwnedAssets, error) { + + identity := types.Identity(id) + pubKey, err := identity.ToPubKey(false) + if err != nil { + return types.OwnedAssets{}, errors.Wrap(err, "converting identity to public key") + } + var result types.OwnedAssets + err = qc.sendRequest(ctx, types.OwnedAssetsRequest, pubKey, &result) + if err != nil { + return types.OwnedAssets{}, errors.Wrap(err, "sending req to node") + } + + return result, nil +} + func (qc *Client) GetIdentity(ctx context.Context, id string) (types.AddressInfo, error) { identity := types.Identity(id) pubKey, err := identity.ToPubKey(false) diff --git a/types/assets.go b/types/assets.go new file mode 100644 index 0000000..ff004bc --- /dev/null +++ b/types/assets.go @@ -0,0 +1,280 @@ +package types + +import ( + "encoding/binary" + "github.com/pkg/errors" + "io" +) + +const ( + AssetsDepth = 24 +) + +type AssetInfo struct { + Tick uint32 + UniverseIndex uint32 + Siblings [AssetsDepth][32]byte +} + +func (ai *AssetInfo) UnmarshallBinary(r io.Reader) error { + err := binary.Read(r, binary.LittleEndian, &ai.Tick) + if err != nil { + return errors.Wrap(err, "reading asset tick") + } + + err = binary.Read(r, binary.LittleEndian, &ai.UniverseIndex) + if err != nil { + return errors.Wrap(err, "reading asset universe index") + } + + /* We don't read siblings as it doesn't seem to be implemented on node side yet. */ + return nil +} + +/* Issued asset */ + +type IssuedAssetData struct { + PublicKey [32]byte + Type byte + Name [7]int8 + NumberOfDecimalPlaces int8 + UnitOfMeasurement [7]int8 +} + +type IssuedAsset struct { + Data IssuedAssetData + Info AssetInfo +} + +type IssuedAssets []IssuedAsset + +func (ad *IssuedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) + if err != nil { + return errors.Wrap(err, "reading issued asset public key") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Type) + if err != nil { + return errors.Wrap(err, "reading issued asset type") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Name) + if err != nil { + return errors.Wrap(err, "reading issued asset name") + } + + err = binary.Read(r, binary.LittleEndian, &ad.NumberOfDecimalPlaces) + if err != nil { + return errors.Wrap(err, "reading issued asset number of decimal places") + } + + err = binary.Read(r, binary.LittleEndian, &ad.UnitOfMeasurement) + if err != nil { + return errors.Wrap(err, "reading issued asset unit of measurement") + } + return nil +} + +/* Possessed asset */ + +type PossessedAssetData struct { + PublicKey [32]byte + Type byte + Padding [1]int8 + ManagingContractIndex uint16 + IssuanceIndex uint32 + NumberOfUnits int64 + OwnedAsset OwnedAssetData + IssuedAsset IssuedAssetData +} + +type PossessedAsset struct { + Data PossessedAssetData + Info AssetInfo +} + +type PossessedAssets []PossessedAsset + +func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { + for { + var header RequestResponseHeader + err := binary.Read(r, binary.BigEndian, &header) + if err != nil { + return errors.Wrap(err, "reading header") + } + + if header.Type == EndResponse { + break + } + + if header.Type != PossessedAssetsResponse { + return errors.Errorf("Invalid header type, expected %d, found %d", PossessedAssetsResponse, header.Type) + } + + var possessedAssetData PossessedAssetData + err = possessedAssetData.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "unmarshalling possessed asset data") + } + + var assetInfo AssetInfo + err = assetInfo.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading possessed asset info") + } + + possessedAsset := PossessedAsset{ + Data: possessedAssetData, + Info: assetInfo, + } + + *pa = append(*pa, possessedAsset) + } + + return nil +} + +func (pd *PossessedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &pd.PublicKey) + if err != nil { + return errors.Wrap(err, "reading asset data") + } + + err = binary.Read(r, binary.LittleEndian, &pd.Type) + if err != nil { + return errors.Wrap(err, "reading asset type") + } + + err = binary.Read(r, binary.LittleEndian, &pd.Padding) + if err != nil { + return errors.Wrap(err, "reading asset padding") + } + + err = binary.Read(r, binary.LittleEndian, &pd.ManagingContractIndex) + if err != nil { + return errors.Wrap(err, "reading asset managing contract index") + } + + err = binary.Read(r, binary.LittleEndian, &pd.IssuanceIndex) + if err != nil { + return errors.Wrap(err, "reading asset issuance index") + } + + err = binary.Read(r, binary.LittleEndian, &pd.NumberOfUnits) + if err != nil { + return errors.Wrap(err, "reading asset number of units") + } + + err = pd.OwnedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading owned asset") + } + + err = pd.IssuedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading issued asset") + } + + return nil +} + +/* Owned Asset */ + +type OwnedAssetData struct { + PublicKey [32]byte + Type byte + Padding [1]int8 + ManagingContractIndex uint16 + IssuanceIndex uint32 + NumberOfUnits int64 + IssuedAsset IssuedAssetData +} + +type OwnedAsset struct { + Data OwnedAssetData + Info AssetInfo +} + +type OwnedAssets []OwnedAsset + +func (oa *OwnedAssets) UnmarshallFromReader(r io.Reader) error { + for { + var header RequestResponseHeader + err := binary.Read(r, binary.BigEndian, &header) + if err != nil { + return errors.Wrap(err, "reading header") + } + + if header.Type == EndResponse { + break + } + + if header.Type != OwnedAssetsResponse { + return errors.Errorf("Invalid header type, expected %d, found %d", OwnedAssetsResponse, header.Type) + } + + var ownedAssetData OwnedAssetData + err = ownedAssetData.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "unmarshalling owned asset data") + } + + var assetInfo AssetInfo + err = assetInfo.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading owned asset info") + } + + ownedAsset := OwnedAsset{ + Data: ownedAssetData, + Info: assetInfo, + } + + *oa = append(*oa, ownedAsset) + } + + return nil +} + +func (ad *OwnedAssetData) UnmarshallBinary(r io.Reader) error { + + err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) + if err != nil { + return errors.Wrap(err, "reading asset data") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Type) + if err != nil { + return errors.Wrap(err, "reading asset type") + } + + err = binary.Read(r, binary.LittleEndian, &ad.Padding) + if err != nil { + return errors.Wrap(err, "reading asset padding") + } + + err = binary.Read(r, binary.LittleEndian, &ad.ManagingContractIndex) + if err != nil { + return errors.Wrap(err, "reading asset managing contract index") + } + + err = binary.Read(r, binary.LittleEndian, &ad.IssuanceIndex) + if err != nil { + return errors.Wrap(err, "reading asset issuance index") + } + + err = binary.Read(r, binary.LittleEndian, &ad.NumberOfUnits) + if err != nil { + return errors.Wrap(err, "reading asset number of units") + } + + err = ad.IssuedAsset.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading issued asset") + } + + return nil +} diff --git a/types/request.go b/types/request.go index 0a9707f..ad0ee1b 100644 --- a/types/request.go +++ b/types/request.go @@ -4,6 +4,12 @@ import "math/rand" // request and response types const ( + IssuedAssetsRequest = 36 + IssuedAssetsResponse = 37 + OwnedAssetsRequest = 38 + OwnedAssetsResponse = 39 + PossessedAssetsRequest = 40 + PossessedAssetsResponse = 41 CurrentTickInfoRequest = 27 CurrentTickInfoResponse = 28 BroadcastFutureTickData = 8 From 4a9f8d2643b85d65e39f900200e4493a0f1b41dd Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Wed, 22 May 2024 13:45:36 +0300 Subject: [PATCH 4/6] Add GetPossessedAssets method. Fix Possessed Asset unmarshalling. --- qubic.go | 16 ++++++++++++++++ types/assets.go | 9 +++------ 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/qubic.go b/qubic.go index cacef33..951dba1 100644 --- a/qubic.go +++ b/qubic.go @@ -59,6 +59,22 @@ func (qc *Client) getPeers(ctx context.Context) (types.PublicPeers, error) { return result, nil } +func (qc *Client) GetPossessedAssets(ctx context.Context, id string) (types.PossessedAssets, error) { + + identity := types.Identity(id) + pubKey, err := identity.ToPubKey(false) + if err != nil { + return types.PossessedAssets{}, errors.Wrap(err, "converting identity to public key") + } + var result types.PossessedAssets + err = qc.sendRequest(ctx, types.PossessedAssetsRequest, pubKey, &result) + if err != nil { + return types.PossessedAssets{}, errors.Wrap(err, "sending req to node") + } + + return result, nil +} + func (qc *Client) GetOwnedAssets(ctx context.Context, id string) (types.OwnedAssets, error) { identity := types.Identity(id) diff --git a/types/assets.go b/types/assets.go index ff004bc..ed54178 100644 --- a/types/assets.go +++ b/types/assets.go @@ -2,6 +2,7 @@ package types import ( "encoding/binary" + "fmt" "github.com/pkg/errors" "io" ) @@ -87,7 +88,6 @@ type PossessedAssetData struct { IssuanceIndex uint32 NumberOfUnits int64 OwnedAsset OwnedAssetData - IssuedAsset IssuedAssetData } type PossessedAsset struct { @@ -105,6 +105,8 @@ func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { return errors.Wrap(err, "reading header") } + fmt.Printf("HEADER: %d | %d\n", header.Type, header.GetSize()) + if header.Type == EndResponse { break } @@ -173,11 +175,6 @@ func (pd *PossessedAssetData) UnmarshallBinary(r io.Reader) error { return errors.Wrap(err, "reading owned asset") } - err = pd.IssuedAsset.UnmarshallBinary(r) - if err != nil { - return errors.Wrap(err, "reading issued asset") - } - return nil } From ab41eeddc77fe59556b0cd566d4d3783e8f724c9 Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Wed, 22 May 2024 13:50:55 +0300 Subject: [PATCH 5/6] Remove debug print. --- types/assets.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/types/assets.go b/types/assets.go index ed54178..f7d9c37 100644 --- a/types/assets.go +++ b/types/assets.go @@ -2,7 +2,6 @@ package types import ( "encoding/binary" - "fmt" "github.com/pkg/errors" "io" ) @@ -105,8 +104,6 @@ func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { return errors.Wrap(err, "reading header") } - fmt.Printf("HEADER: %d | %d\n", header.Type, header.GetSize()) - if header.Type == EndResponse { break } From d28afd2b9dfb12b894c6158f48fa413f36865a7a Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Thu, 23 May 2024 20:05:54 +0300 Subject: [PATCH 6/6] Add support for fetching issued assets. --- qubic.go | 17 +++++++++++++++ types/assets.go | 55 ++++++++++++++++++++++++++++++++++++++++++------- 2 files changed, 64 insertions(+), 8 deletions(-) diff --git a/qubic.go b/qubic.go index 951dba1..76270fe 100644 --- a/qubic.go +++ b/qubic.go @@ -59,6 +59,23 @@ func (qc *Client) getPeers(ctx context.Context) (types.PublicPeers, error) { return result, nil } +func (qc *Client) GetIssuedAssets(ctx context.Context, id string) (types.IssuedAssets, error) { + + identity := types.Identity(id) + pubKey, err := identity.ToPubKey(false) + if err != nil { + return types.IssuedAssets{}, errors.Wrap(err, "converting identity to public key") + } + var result types.IssuedAssets + err = qc.sendRequest(ctx, types.IssuedAssetsRequest, pubKey, &result) + if err != nil { + return types.IssuedAssets{}, errors.Wrap(err, "sending req to node") + } + + return result, nil + +} + func (qc *Client) GetPossessedAssets(ctx context.Context, id string) (types.PossessedAssets, error) { identity := types.Identity(id) diff --git a/types/assets.go b/types/assets.go index f7d9c37..46c6c7d 100644 --- a/types/assets.go +++ b/types/assets.go @@ -48,6 +48,45 @@ type IssuedAsset struct { type IssuedAssets []IssuedAsset +func (ia *IssuedAssets) UnmarshallFromReader(r io.Reader) error { + for { + var header RequestResponseHeader + err := binary.Read(r, binary.BigEndian, &header) + if err != nil { + return errors.Wrap(err, "reading header") + } + + if header.Type == EndResponse { + break + } + + if header.Type != IssuedAssetsResponse { + return errors.Errorf("Invalid header type, expected %d, found %d", IssuedAssetsResponse, header.Type) + } + + var issuedAssetData IssuedAssetData + err = issuedAssetData.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "unmarshalling issued asset data") + } + + var assetInfo AssetInfo + err = assetInfo.UnmarshallBinary(r) + if err != nil { + return errors.Wrap(err, "reading issued asset info") + } + + issuedAsset := IssuedAsset{ + Data: issuedAssetData, + Info: assetInfo, + } + + *ia = append(*ia, issuedAsset) + } + + return nil +} + func (ad *IssuedAssetData) UnmarshallBinary(r io.Reader) error { err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) @@ -135,39 +174,39 @@ func (pa *PossessedAssets) UnmarshallFromReader(r io.Reader) error { return nil } -func (pd *PossessedAssetData) UnmarshallBinary(r io.Reader) error { +func (ad *PossessedAssetData) UnmarshallBinary(r io.Reader) error { - err := binary.Read(r, binary.LittleEndian, &pd.PublicKey) + err := binary.Read(r, binary.LittleEndian, &ad.PublicKey) if err != nil { return errors.Wrap(err, "reading asset data") } - err = binary.Read(r, binary.LittleEndian, &pd.Type) + err = binary.Read(r, binary.LittleEndian, &ad.Type) if err != nil { return errors.Wrap(err, "reading asset type") } - err = binary.Read(r, binary.LittleEndian, &pd.Padding) + err = binary.Read(r, binary.LittleEndian, &ad.Padding) if err != nil { return errors.Wrap(err, "reading asset padding") } - err = binary.Read(r, binary.LittleEndian, &pd.ManagingContractIndex) + err = binary.Read(r, binary.LittleEndian, &ad.ManagingContractIndex) if err != nil { return errors.Wrap(err, "reading asset managing contract index") } - err = binary.Read(r, binary.LittleEndian, &pd.IssuanceIndex) + err = binary.Read(r, binary.LittleEndian, &ad.IssuanceIndex) if err != nil { return errors.Wrap(err, "reading asset issuance index") } - err = binary.Read(r, binary.LittleEndian, &pd.NumberOfUnits) + err = binary.Read(r, binary.LittleEndian, &ad.NumberOfUnits) if err != nil { return errors.Wrap(err, "reading asset number of units") } - err = pd.OwnedAsset.UnmarshallBinary(r) + err = ad.OwnedAsset.UnmarshallBinary(r) if err != nil { return errors.Wrap(err, "reading owned asset") }