Add endpoints for getting possessions and ownerships by universe index

Author: georgmittendorfer

foundation/rpc_server/asset_converter.go

@@ -0,0 +1,80 @@
+package rpc
+
+import (
+	"github.com/pkg/errors"
+	"github.com/qubic/go-node-connector/types"
+	"github.com/qubic/qubic-http/protobuff"
+)
+
+func convertAssetIssuance(source types.AssetIssuance) (*protobuff.AssetIssuance, error) {
+	var issuerIdentity types.Identity
+	issuerIdentity, err := issuerIdentity.FromPubKey(source.Asset.PublicKey, false)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get identity for public key")
+	}
+
+	issuedAsset := protobuff.AssetIssuanceData{
+		IssuerIdentity:        issuerIdentity.String(),
+		Type:                  uint32(source.Asset.Type),
+		Name:                  int8ArrayToString(source.Asset.Name[:]),
+		NumberOfDecimalPlaces: int32(source.Asset.NumberOfDecimalPlaces),
+		UnitOfMeasurement:     int8ArrayToInt32Array(source.Asset.UnitOfMeasurement[:]),
+	}
+
+	asset := protobuff.AssetIssuance{
+		Data:          &issuedAsset,
+		Tick:          source.Tick,
+		UniverseIndex: source.UniverseIndex,
+	}
+
+	return &asset, nil
+}
+
+func convertAssetOwnership(source types.AssetOwnership) (*protobuff.AssetOwnership, error) {
+	var owner types.Identity
+	owner, err := owner.FromPubKey(source.Asset.PublicKey, false)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get identity for public key")
+	}
+
+	ownedAsset := protobuff.AssetOwnershipData{
+		OwnerIdentity:         owner.String(),
+		Type:                  uint32(source.Asset.Type),
+		ManagingContractIndex: uint32(source.Asset.ManagingContractIndex),
+		IssuanceIndex:         source.Asset.IssuanceIndex,
+		NumberOfUnits:         source.Asset.NumberOfUnits,
+	}
+
+	assetOwnership := protobuff.AssetOwnership{
+		Data:          &ownedAsset,
+		Tick:          source.Tick,
+		UniverseIndex: source.UniverseIndex,
+	}
+
+	return &assetOwnership, nil
+}
+
+func convertAssetPossession(source types.AssetPossession) (*protobuff.AssetPossession, error) {
+
+	var possessor types.Identity
+	possessor, err := possessor.FromPubKey(source.Asset.PublicKey, false)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get identity for public key")
+	}
+
+	possessedAsset := protobuff.AssetPossessionData{
+		PossessorIdentity:     possessor.String(),
+		Type:                  uint32(source.Asset.Type),
+		ManagingContractIndex: uint32(source.Asset.ManagingContractIndex),
+		OwnershipIndex:        source.Asset.OwnershipIndex,
+		NumberOfUnits:         source.Asset.NumberOfUnits,
+	}
+
+	assetPossession := protobuff.AssetPossession{
+		Data:          &possessedAsset,
+		Tick:          source.Tick,
+		UniverseIndex: source.UniverseIndex,
+	}
+
+	return &assetPossession, nil
+}

foundation/rpc_server/asset_converter_test.go

@@ -0,0 +1,111 @@
+package rpc
+
+import (
+	"github.com/qubic/go-node-connector/types"
+	"github.com/qubic/qubic-http/protobuff"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestAssetConverter_convertAssetIssuance(t *testing.T) {
+
+	source := types.AssetIssuance{
+		Asset: types.AssetIssuanceData{
+			PublicKey:             [32]byte{},
+			Type:                  1,
+			Name:                  [7]int8{82, 65, 78, 68, 79, 77, 0},
+			NumberOfDecimalPlaces: 0,
+			UnitOfMeasurement:     [7]int8{1, 2, 3, 4, 5, 6, 7},
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}
+
+	converted, err := convertAssetIssuance(source)
+	assert.NoError(t, err)
+
+	assert.Equal(t, &protobuff.AssetIssuance{
+		Data: &protobuff.AssetIssuanceData{
+			IssuerIdentity:        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXIB",
+			Type:                  1,
+			Name:                  "RANDOM",
+			NumberOfDecimalPlaces: 0,
+			UnitOfMeasurement:     []int32{1, 2, 3, 4, 5, 6, 7},
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}, converted)
+
+}
+
+func TestAssetConverter_convertAssetOwnership(t *testing.T) {
+
+	id := types.Identity("TESTIOGXQKYYZEQXOXFSWWAJNYLCDBWFAPNBLNBUZFHDVFMYPJZXGMEEJEGI")
+	pubKey, err := id.ToPubKey(false)
+	assert.NoError(t, err)
+
+	source := types.AssetOwnership{
+		Asset: types.AssetOwnershipData{
+			PublicKey:             pubKey,
+			Type:                  2,
+			Padding:               [1]int8{},
+			ManagingContractIndex: 1,
+			IssuanceIndex:         123,
+			NumberOfUnits:         456,
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}
+
+	converted, err := convertAssetOwnership(source)
+	assert.NoError(t, err)
+
+	assert.Equal(t, &protobuff.AssetOwnership{
+		Data: &protobuff.AssetOwnershipData{
+			OwnerIdentity:         "TESTIOGXQKYYZEQXOXFSWWAJNYLCDBWFAPNBLNBUZFHDVFMYPJZXGMEEJEGI",
+			Type:                  2,
+			ManagingContractIndex: 1,
+			IssuanceIndex:         123,
+			NumberOfUnits:         456,
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}, converted)
+
+}
+
+func TestAssetConverter_convertAssetPossession(t *testing.T) {
+
+	id := types.Identity("TESTIOGXQKYYZEQXOXFSWWAJNYLCDBWFAPNBLNBUZFHDVFMYPJZXGMEEJEGI")
+	pubKey, err := id.ToPubKey(false)
+	assert.NoError(t, err)
+
+	source := types.AssetPossession{
+		Asset: types.AssetPossessionData{
+			PublicKey:             pubKey,
+			Type:                  3,
+			Padding:               [1]int8{},
+			ManagingContractIndex: 1,
+			OwnershipIndex:        123,
+			NumberOfUnits:         456,
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}
+
+	converted, err := convertAssetPossession(source)
+	assert.NoError(t, err)
+
+	assert.Equal(t, &protobuff.AssetPossession{
+		Data: &protobuff.AssetPossessionData{
+			PossessorIdentity:     "TESTIOGXQKYYZEQXOXFSWWAJNYLCDBWFAPNBLNBUZFHDVFMYPJZXGMEEJEGI",
+			Type:                  3,
+			ManagingContractIndex: 1,
+			OwnershipIndex:        123,
+			NumberOfUnits:         456,
+		},
+		Tick:          42,
+		UniverseIndex: 43,
+	}, converted)
+
+}