Support for datasets

README.md

@@ -391,13 +391,4 @@ docker-compose -f trace/zipkin.yml down
 
 ## Creating a Devnet
 
-Refer to [Creating Devnet Demo](./docs/demos/devnet.md) to learn how to create a private devnet (running on a
-custom Primary Network with traffic scoped to the deployer IP) across any number of regions and nodes
-in ~30 minutes with a single script.
-
-/home/ubuntu/avalanche-node/avalanchego --config-file=/home/ubuntu/.avalanchego/configs/node.json
-ubuntu@ip-172-31-39-145:~$ ps -p 10411 -o cmd
-CMD
-/home/ubuntu/.avalanchego/plugins/Nke3kc2vJZWmoVv3hewi3NYUCHa42wTvFuaX4j1sgNp8WCRX4
-
-34.243.81.202
+Refer to [Creating Devnet Demo](./docs/demos/devnet.md) to learn how to create a private devnet (running on a custom Primary Network with traffic scoped to the deployer IP) across any number of regions and nodes in ~30 minutes with a single script.

actions/burn_asset.go → actions/burn_asset_ft.go

@@ -18,32 +18,32 @@ import (
 	nconsts "github.com/nuklai/nuklaivm/consts"
 )
 
-var _ chain.Action = (*BurnAsset)(nil)
+var _ chain.Action = (*BurnAssetFT)(nil)
 
-type BurnAsset struct {
-	// Asset is the [TxID] that created the asset.
+type BurnAssetFT struct {
+	// Asset ID of the asset to burn.
 	Asset ids.ID `json:"asset"`
 
-	// Number of assets to mint to [To].
+	// Number of assets to burn
 	Value uint64 `json:"value"`
 }
 
-func (*BurnAsset) GetTypeID() uint8 {
-	return nconsts.BurnAssetID
+func (*BurnAssetFT) GetTypeID() uint8 {
+	return nconsts.BurnAssetFTID
 }
 
-func (b *BurnAsset) StateKeys(actor codec.Address, _ ids.ID) state.Keys {
+func (b *BurnAssetFT) StateKeys(actor codec.Address, _ ids.ID) state.Keys {
 	return state.Keys{
 		string(storage.AssetKey(b.Asset)):          state.Read | state.Write,
 		string(storage.BalanceKey(actor, b.Asset)): state.Read | state.Write,
 	}
 }
 
-func (*BurnAsset) StateKeysMaxChunks() []uint16 {
+func (*BurnAssetFT) StateKeysMaxChunks() []uint16 {
 	return []uint16{storage.AssetChunks, storage.BalanceChunks}
 }
 
-func (b *BurnAsset) Execute(
+func (b *BurnAssetFT) Execute(
 	ctx context.Context,
 	_ chain.Rules,
 	mu state.Mutable,
@@ -54,47 +54,54 @@ func (b *BurnAsset) Execute(
 	if b.Value == 0 {
 		return nil, ErrOutputValueZero
 	}
-	if err := storage.SubBalance(ctx, mu, actor, b.Asset, b.Value); err != nil {
-		return nil, err
-	}
-	exists, symbol, decimals, metadata, supply, owner, err := storage.GetAsset(ctx, mu, b.Asset)
+
+	exists, assetType, name, symbol, decimals, metadata, uri, totalSupply, maxSupply, admin, mintActor, pauseUnpauseActor, freezeUnfreezeActor, enableDisableKYCAccountActor, err := storage.GetAsset(ctx, mu, b.Asset)
 	if err != nil {
 		return nil, err
 	}
 	if !exists {
 		return nil, ErrOutputAssetMissing
 	}
-	newSupply, err := smath.Sub(supply, b.Value)
+	if assetType != nconsts.AssetFungibleTokenID {
+		return nil, ErrOutputWrongAssetType
+	}
+
+	newSupply, err := smath.Sub(totalSupply, b.Value)
 	if err != nil {
 		return nil, err
 	}
-	if err := storage.SetAsset(ctx, mu, b.Asset, symbol, decimals, metadata, newSupply, owner); err != nil {
+	if err := storage.SetAsset(ctx, mu, b.Asset, assetType, name, symbol, decimals, metadata, uri, newSupply, maxSupply, admin, mintActor, pauseUnpauseActor, freezeUnfreezeActor, enableDisableKYCAccountActor); err != nil {
 		return nil, err
 	}
+
+	if err := storage.SubBalance(ctx, mu, actor, b.Asset, b.Value); err != nil {
+		return nil, err
+	}
+
 	return nil, nil
 }
 
-func (*BurnAsset) ComputeUnits(chain.Rules) uint64 {
+func (*BurnAssetFT) ComputeUnits(chain.Rules) uint64 {
 	return BurnAssetComputeUnits
 }
 
-func (*BurnAsset) Size() int {
+func (*BurnAssetFT) Size() int {
 	return ids.IDLen + consts.Uint64Len
 }
 
-func (b *BurnAsset) Marshal(p *codec.Packer) {
+func (b *BurnAssetFT) Marshal(p *codec.Packer) {
 	p.PackID(b.Asset)
 	p.PackUint64(b.Value)
 }
 
-func UnmarshalBurnAsset(p *codec.Packer) (chain.Action, error) {
-	var burn BurnAsset
+func UnmarshalBurnAssetFT(p *codec.Packer) (chain.Action, error) {
+	var burn BurnAssetFT
 	p.UnpackID(false, &burn.Asset) // can burn native asset
-	burn.Value = p.UnpackUint64(true)
+	burn.Value = p.UnpackUint64(false)
 	return &burn, p.Err()
 }
 
-func (*BurnAsset) ValidRange(chain.Rules) (int64, int64) {
+func (*BurnAssetFT) ValidRange(chain.Rules) (int64, int64) {
 	// Returning -1, -1 means that the action is always valid.
 	return -1, -1
 }

actions/burn_asset_nft.go

@@ -0,0 +1,121 @@
+// Copyright (C) 2024, Nuklai. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package actions
+
+import (
+	"context"
+
+	"github.com/ava-labs/avalanchego/ids"
+	smath "github.com/ava-labs/avalanchego/utils/math"
+
+	"github.com/ava-labs/hypersdk/chain"
+	"github.com/ava-labs/hypersdk/codec"
+	"github.com/ava-labs/hypersdk/state"
+	"github.com/nuklai/nuklaivm/storage"
+
+	nconsts "github.com/nuklai/nuklaivm/consts"
+)
+
+var _ chain.Action = (*BurnAssetNFT)(nil)
+
+type BurnAssetNFT struct {
+	// Asset ID of the asset to burn(this is the nft collection ID)
+	Asset ids.ID `json:"asset"`
+
+	// NFT ID of the asset to burn
+	NftID ids.ID `json:"nftID"`
+}
+
+func (*BurnAssetNFT) GetTypeID() uint8 {
+	return nconsts.BurnAssetNFTID
+}
+
+func (b *BurnAssetNFT) StateKeys(actor codec.Address, _ ids.ID) state.Keys {
+	return state.Keys{
+		string(storage.AssetKey(b.Asset)):          state.Read | state.Write,
+		string(storage.AssetNFTKey(b.NftID)):       state.Read | state.Write,
+		string(storage.BalanceKey(actor, b.Asset)): state.Read | state.Write,
+		string(storage.BalanceKey(actor, b.NftID)): state.Read | state.Write,
+	}
+}
+
+func (*BurnAssetNFT) StateKeysMaxChunks() []uint16 {
+	return []uint16{storage.AssetChunks, storage.AssetNFTChunks, storage.BalanceChunks, storage.BalanceChunks}
+}
+
+func (b *BurnAssetNFT) Execute(
+	ctx context.Context,
+	_ chain.Rules,
+	mu state.Mutable,
+	_ int64,
+	actor codec.Address,
+	_ ids.ID,
+) ([][]byte, error) {
+	exists, assetType, name, symbol, decimals, metadata, uri, totalSupply, maxSupply, admin, mintActor, pauseUnpauseActor, freezeUnfreezeActor, enableDisableKYCAccountActor, err := storage.GetAsset(ctx, mu, b.Asset)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, ErrOutputAssetMissing
+	}
+	if assetType != nconsts.AssetNonFungibleTokenID {
+		return nil, ErrOutputWrongAssetType
+	}
+
+	exists, _, _, _, _, _, err = storage.GetAssetNFT(ctx, mu, b.NftID)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, ErrOutputAssetMissing
+	}
+
+	amountOfToken := uint64(1)
+	newSupply, err := smath.Sub(totalSupply, amountOfToken)
+	if err != nil {
+		return nil, err
+	}
+	if err := storage.SetAsset(ctx, mu, b.Asset, assetType, name, symbol, decimals, metadata, uri, newSupply, maxSupply, admin, mintActor, pauseUnpauseActor, freezeUnfreezeActor, enableDisableKYCAccountActor); err != nil {
+		return nil, err
+	}
+
+	if err := storage.DeleteAssetNFT(ctx, mu, b.NftID); err != nil {
+		return nil, err
+	}
+	if err := storage.SubBalance(ctx, mu, actor, b.NftID, 1); err != nil {
+		return nil, err
+	}
+
+	// Sub balance from collection
+	if err := storage.SubBalance(ctx, mu, actor, b.Asset, amountOfToken); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (*BurnAssetNFT) ComputeUnits(chain.Rules) uint64 {
+	return BurnAssetComputeUnits
+}
+
+func (*BurnAssetNFT) Size() int {
+	return ids.IDLen * 2
+}
+
+func (b *BurnAssetNFT) Marshal(p *codec.Packer) {
+	p.PackID(b.Asset)
+	p.PackID(b.NftID)
+}
+
+func UnmarshalBurnAssetNFT(p *codec.Packer) (chain.Action, error) {
+	var burn BurnAssetNFT
+	p.UnpackID(false, &burn.Asset)
+	p.UnpackID(false, &burn.NftID)
+	return &burn, p.Err()
+}
+
+func (*BurnAssetNFT) ValidRange(chain.Rules) (int64, int64) {
+	// Returning -1, -1 means that the action is always valid.
+	return -1, -1
+}

actions/claim_delegation_stake_rewards.go

@@ -56,6 +56,9 @@ func (c *ClaimDelegationStakeRewards) Execute(
 	if err != nil {
 		return nil, ErrOutputInvalidNodeID
 	}
+	if _, err := codec.AddressBech32(nconsts.HRP, c.UserStakeAddress); err != nil {
+		return nil, err
+	}
 
 	exists, stakeStartBlock, _, _, rewardAddress, _, _ := storage.GetDelegateUserStake(ctx, mu, c.UserStakeAddress, nodeID)
 	if !exists {