Collections

from near_sdk_py import view, call, init
from near_sdk_py.collections import Vector, LookupMap, UnorderedMap, LookupSet, UnorderedSet

class MyContract:
    @init
    def new(self): # Create a Vector with prefix "v"
        self.my_vector = Vector("v")

        # Create a LookupMap with prefix "m"
        self.my_lookup_map = LookupMap("m")

        # Create an UnorderedMap with prefix "um"
        self.my_unordered_map = UnorderedMap("um")

        # Create a LookupSet with prefix "s"
        self.my_lookup_set = LookupSet("s")

        # Create an UnorderedSet with prefix "us"
        self.my_unordered_set = UnorderedSet("us")

        # For nested collections, use different prefixes
        self.nested_maps = UnorderedMap("nested")

        return True

    @call
    def create_nested_map(self, key: str):
        # Create a new map that will be stored inside another map
        inner_map = UnorderedMap(f"inner_{key}")
        self.nested_maps[key] = inner_map
        return {"success": True}

from near_sdk_py import view, call, init
from near_sdk_py.collections import Vector

class VectorExample:
    @init
    def new(self):
        # Create a Vector with prefix "v"
        self.my_vector = Vector("v")
        
    @call
    def add_number(self, number):
        # Append a value to the vector
        self.my_vector.append(number)
        return len(self.my_vector)
        
    @view
    def get_number(self, index):
        # Get a value at specific index
        try:
            return self.my_vector[index]
        except Exception:
            return None
            
    @view
    def get_all_numbers(self):
        # Convert entire vector to a list
        return [num for num in self.my_vector]

from near_sdk_py import view, call, init
from near_sdk_py.collections import LookupMap

class LookupMapExample:
    @init
    def new(self):
        # Create a LookupMap with prefix "m"
        self.balances = LookupMap("m")
        
    @call
    def set_balance(self, account_id, amount):
        # Set a value for a key
        self.balances[account_id] = amount
        return True
        
    @view
    def get_balance(self, account_id):
        # Get a value for a key with a default
        return self.balances.get(account_id, 0)
        
    @call
    def remove_balance(self, account_id):
        # Remove a key
        if account_id in self.balances:
            del self.balances[account_id]
            return True
        return False

from near_sdk_py import view, call, init
from near_sdk_py.collections import UnorderedMap

class UnorderedMapExample:
    @init
    def new(self):
        # Create an UnorderedMap with prefix "um"
        self.user_data = UnorderedMap("um")
        
    @call
    def set_user_data(self, account_id, data):
        # Set a value for a key
        self.user_data[account_id] = data
        return True
        
    @view
    def get_user_data(self, account_id):
        # Get a value for a key
        try:
            return self.user_data[account_id]
        except Exception:
            return None
        
    @view
    def list_all_users(self):
        # Iterate through keys and values
        return {
            "keys": self.user_data.keys(),
            "values": self.user_data.values(),
            "items": self.user_data.items()
        }

from near_sdk_py import view, call, init
from near_sdk_py.collections import LookupSet

class LookupSetExample:
    @init
    def new(self):
        # Create a LookupSet with prefix "s"
        self.whitelist = LookupSet("s")
        
    @call
    def add_to_whitelist(self, account_id):
        # Add a value to the set
        self.whitelist.add(account_id)
        return True
        
    @view
    def is_whitelisted(self, account_id):
        # Check if a value exists in the set
        return account_id in self.whitelist
        
    @call
    def remove_from_whitelist(self, account_id):
        # Remove a value from the set
        try:
            self.whitelist.remove(account_id)
            return True
        except Exception:
            return False

from near_sdk_py import view, call, init
from near_sdk_py.collections import UnorderedSet

class UnorderedSetExample:
    @init
    def new(self):
        # Create an UnorderedSet with prefix "us"
        self.owners = UnorderedSet("us")
        
    @call
    def register_owner(self, account_id):
        # Add a value to the set
        self.owners.add(account_id)
        return True
        
    @view
    def is_owner(self, account_id):
        # Check if a value exists in the set
        return account_id in self.owners
        
    @view
    def list_all_owners(self):
        # Get all values as a list
        return self.owners.values()
        
    @call
    def remove_owner(self, account_id):
        # Try to remove a value if it exists
        self.owners.discard(account_id)
        return True

from near_sdk_py import view, call, init
from near_sdk_py.collections import TreeMap

class TreeMapExample:
    @init
    def new(self):
        # Create a TreeMap with prefix "tm"
        self.scores = TreeMap("tm")
        
    @call
    def add_score(self, user_id, score):
        # Set score for a user
        self.scores[user_id] = score
        return True
        
    @view
    def get_top_scores(self, limit=10):
        # Get top scores using ordered keys
        # This returns highest scores first
        top_users = []
        max_key = self.scores.max_key()
        current_key = max_key
        count = 0
        
        while current_key is not None and count < limit:
            top_users.append({
                "user": current_key,
                "score": self.scores[current_key]
            })
            current_key = self.scores.floor_key(current_key - 1)  # Get next highest key
            count += 1
            
        return top_users

from near_sdk_py import view, call, init
from near_sdk_py.collections import UnorderedMap, Vector
from near_sdk_py.collections import create_prefix_guard

class NestedCollectionsExample:
    @init
    def new(self):
        # Main map of users to their assets
        self.user_assets = UnorderedMap("users")

    @call
    def add_asset(self, user_id, asset_id, metadata):
        # Get or create the user's assets vector with a unique prefix
        if user_id not in self.user_assets:
            # Create a prefix guard to ensure unique prefixes for this user
            prefix = f"assets:{user_id}"
            # Create a new vector for this user's assets
            self.user_assets[user_id] = Vector(prefix)

        # Add the asset to the user's assets vector
        user_assets = self.user_assets[user_id]
        user_assets.append({
            "asset_id": asset_id,
            "metadata": metadata
        })

        # Update the vector in the map
        self.user_assets[user_id] = user_assets
        return True

    @view
    def get_user_assets(self, user_id):
        if user_id not in self.user_assets:
            return []

        # Get all assets for the user
        user_assets = self.user_assets[user_id]
        return [asset for asset in user_assets]

  /// Returns multiple elements from the `UnorderedMap`.
  /// - `from_index` is the index to start from.
  /// - `limit` is the maximum number of elements to return.
  @view({})
  get_updates({ from_index, limit }: { from_index: number, limit:number }) {
    return this.status_updates.toArray().slice(from_index, limit);
  }

# With Python this can be done using standard list slicing.

@view
def get_updates(self, from_index: int = 0, limit: int = 50) -> list:
    """Returns multiple elements from the collection with pagination.
    
    Args:
        from_index: The index to start from
        limit: The maximum number of elements to return
        
    Returns:
        A list of elements from the collection
    """
    # Get all values from the collection
    all_items = self.status_updates.values()
    
    # Apply pagination with list slicing
    start = min(from_index, len(all_items))
    end = min(start + limit, len(all_items))
    
    return all_items[start:end]