status-im/status-go

package thirdparty

import (
    "fmt"
    "math/big"
    "math/rand"

    "github.com/ethereum/go-ethereum/common"
    "github.com/status-im/status-go/protocol/communities/token"
    "github.com/status-im/status-go/services/wallet/bigint"
    w_common "github.com/status-im/status-go/services/wallet/common"
)

func generateContractType(seed int) w_common.ContractType {
    if seed%2 == 0 {
        return w_common.ContractTypeERC721
    }
    return w_common.ContractTypeERC1155
}

func GenerateTestCollectiblesData(count int) (result []CollectibleData) {
    base := rand.Intn(100) // nolint: gosec

    result = make([]CollectibleData, 0, count)
    for i := base; i < count+base; i++ {
        bigI := big.NewInt(int64(i))
        newCollectible := CollectibleData{
            ID: CollectibleUniqueID{
                ContractID: ContractID{
                    ChainID: w_common.ChainID(i % 4),
                    Address: common.BigToAddress(bigI),
                },
                TokenID: &bigint.BigInt{Int: bigI},
            },
            ContractType:       generateContractType(i),
            Provider:           fmt.Sprintf("provider-%d", i),
            Name:               fmt.Sprintf("name-%d", i),
            Description:        fmt.Sprintf("description-%d", i),
            Permalink:          fmt.Sprintf("permalink-%d", i),
            ImageURL:           fmt.Sprintf("imageurl-%d", i),
            ImagePayload:       []byte(fmt.Sprintf("imagepayload-%d", i)),
            AnimationURL:       fmt.Sprintf("animationurl-%d", i),
            AnimationMediaType: fmt.Sprintf("animationmediatype-%d", i),
            Traits: []CollectibleTrait{
                {
                    TraitType:   fmt.Sprintf("traittype-%d", i),
                    Value:       fmt.Sprintf("traitvalue-%d", i),
                    DisplayType: fmt.Sprintf("displaytype-%d", i),
                    MaxValue:    fmt.Sprintf("maxvalue-%d", i),
                },
                {
                    TraitType:   fmt.Sprintf("traittype-%d", i),
                    Value:       fmt.Sprintf("traitvalue-%d", i),
                    DisplayType: fmt.Sprintf("displaytype-%d", i),
                    MaxValue:    fmt.Sprintf("maxvalue-%d", i),
                },
                {
                    TraitType:   fmt.Sprintf("traittype-%d", i),
                    Value:       fmt.Sprintf("traitvalue-%d", i),
                    DisplayType: fmt.Sprintf("displaytype-%d", i),
                    MaxValue:    fmt.Sprintf("maxvalue-%d", i),
                },
            },
            BackgroundColor: fmt.Sprintf("backgroundcolor-%d", i),
            TokenURI:        fmt.Sprintf("tokenuri-%d", i),
            CommunityID:     fmt.Sprintf("communityid-%d", i%5),
        }
        result = append(result, newCollectible)
    }
    return result
}

func GenerateTestCollectiblesCommunityData(count int) []CollectibleCommunityInfo {
    base := rand.Intn(100) // nolint: gosec

    result := make([]CollectibleCommunityInfo, 0, count)
    for i := base; i < count+base; i++ {
        newCommunityInfo := CollectibleCommunityInfo{
            PrivilegesLevel: token.PrivilegesLevel(i) % (token.CommunityLevel + 1),
        }
        result = append(result, newCommunityInfo)
    }
    return result
}

func GenerateTestCollectiblesOwnership(count int) []AccountBalance {
    base := rand.Intn(100) // nolint: gosec

    ret := make([]AccountBalance, 0, count)
    for i := base; i < count+base; i++ {
        ret = append(ret, AccountBalance{
            Address: common.HexToAddress(fmt.Sprintf("0x%x", i)),
            Balance: &bigint.BigInt{Int: big.NewInt(int64(i))},
        })
    }
    return ret
}

func GenerateTestCollectionsData(count int) (result []CollectionData) {
    base := rand.Intn(100) // nolint: gosec

    result = make([]CollectionData, 0, count)
    for i := base; i < count+base; i++ {
        bigI := big.NewInt(int64(count))
        traits := make(map[string]CollectionTrait)
        for j := 0; j < 3; j++ {
            traits[fmt.Sprintf("traittype-%d", j)] = CollectionTrait{
                Min: float64(i+j) / 2,
                Max: float64(i+j) * 2,
            }
        }

        newCollection := CollectionData{
            ID: ContractID{
                ChainID: w_common.ChainID(i),
                Address: common.BigToAddress(bigI),
            },
            ContractType: generateContractType(i),
            Provider:     fmt.Sprintf("provider-%d", i),
            Name:         fmt.Sprintf("name-%d", i),
            Slug:         fmt.Sprintf("slug-%d", i),
            ImageURL:     fmt.Sprintf("imageurl-%d", i),
            ImagePayload: []byte(fmt.Sprintf("imagepayload-%d", i)),
            Traits:       traits,
            CommunityID:  fmt.Sprintf("community-%d", i),
            Socials:      nil,
        }
        result = append(result, newCollection)
    }
    return result
}

func GenerateTestCommunityInfo(count int) map[string]CommunityInfo {
    base := rand.Intn(100) // nolint: gosec

    result := make(map[string]CommunityInfo)
    for i := base; i < count+base; i++ {
        communityID := fmt.Sprintf("communityid-%d", i)
        newCommunity := CommunityInfo{
            CommunityName:         fmt.Sprintf("communityname-%d", i),
            CommunityColor:        fmt.Sprintf("communitycolor-%d", i),
            CommunityImage:        fmt.Sprintf("communityimage-%d", i),
            CommunityImagePayload: []byte(fmt.Sprintf("communityimagepayload-%d", i)),
        }
        result[communityID] = newCommunity
    }

    return result
}

func GenerateTestFullCollectiblesData(count int) []FullCollectibleData {
    collectiblesData := GenerateTestCollectiblesData(count)
    collectionsData := GenerateTestCollectionsData(count)
    communityInfoMap := GenerateTestCommunityInfo(count)
    communityInfo := make([]CommunityInfo, 0, count)
    for _, info := range communityInfoMap {
        communityInfo = append(communityInfo, info)
    }
    communityData := GenerateTestCollectiblesCommunityData(count)

    ret := make([]FullCollectibleData, 0, count)
    for i := 0; i < count; i++ {
        // Ensure consistent ContracType
        collectionsData[i].ContractType = collectiblesData[i].ContractType

        ret = append(ret, FullCollectibleData{
            CollectibleData:          collectiblesData[i],
            CollectionData:           &collectionsData[i],
            CommunityInfo:            &communityInfo[i],
            CollectibleCommunityInfo: &communityData[i],
            Ownership:                GenerateTestCollectiblesOwnership(rand.Intn(5) + 1), // nolint: gosec
        })
    }
    return ret
}