Pointer Precompile

// Import ethers for contract interactions
import { ethers } from 'ethers';
import { POINTER_PRECOMPILE_ADDRESS, POINTER_PRECOMPILE_ABI } from '@sei-js/precompiles';
 

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
 
interface IPointerPrecompile {
    function addNativePointer(
        string memory token
    ) external returns (address ret);
 
    function addCW20Pointer(
        string memory cwAddr
    ) external returns (address ret);
 
    function addCW721Pointer(
        string memory cwAddr
    ) external returns (address ret);
 
    function addCW1155Pointer(
        string memory cwAddr
    ) external returns (address ret);
}

// Using EVM-compatible wallet as the signer and provider
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = await provider.getSigner();
 
// Create a contract instance for the Pointer precompile
const pointer = new ethers.Contract(POINTER_PRECOMPILE_ADDRESS, POINTER_PRECOMPILE_ABI, signer);

// Initialize the contract instance in your Solidity code
contract PointerManager {
    IPointerPrecompile constant POINTER = IPointerPrecompile(0x000000000000000000000000000000000000100B);
}

// Create a pointer for native SEI tokens
async function createNativePointer() {
  const tokenDenom = 'tokenfactory/....'; // Native SEI denomination
 
  try {
    console.log('Creating native pointer for:', tokenDenom);
 
    // Create the pointer
    const tx = await pointer.addNativePointer(tokenDenom, {
      gasLimit: 3000000n
    });
 
    const receipt = await tx.wait();
    console.log('Transaction successful:', receipt.transactionHash);
 
    // Extract the pointer address from events/logs
    // The returned address will be in the transaction logs
    console.log('Native pointer created successfully');
 
    // The actual pointer address would be returned by the function
    // You can call the function as a view to get the address without creating
    return receipt;
  } catch (error) {
    console.error('Failed to create native pointer:', error.message);
 
    if (error.message.includes('pointer already exists')) {
      console.log('Pointer for this token already exists');
    } else if (error.message.includes('invalid token denom')) {
      console.error('Invalid token denomination');
    }
 
    throw error;
  }
}

contract NativePointerManager {
    IPointerPrecompile constant POINTER = IPointerPrecompile(0x000000000000000000000000000000000000100B);
 
    // Store created pointers
    mapping(string => address) public nativePointers;
 
    event NativePointerCreated(string indexed tokenDenom, address pointerAddress);
 
    function createNativePointer(string memory tokenDenom) external returns (address pointerAddr) {
        // Check if pointer already exists
        require(nativePointers[tokenDenom] == address(0), "Pointer already exists");
 
        // Create the native pointer
        pointerAddr = POINTER.addNativePointer(tokenDenom);
 
        // Store the pointer address
        nativePointers[tokenDenom] = pointerAddr;
 
        emit NativePointerCreated(tokenDenom, pointerAddr);
 
        return pointerAddr;
    }
 
    function getNativePointer(string memory tokenDenom) external view returns (address) {
        return nativePointers[tokenDenom];
    }
}

// Create a pointer for a CW20 token
async function createCW20Pointer() {
  // Example CW20 contract address (use actual contract address)
  const cw20Address = 'sei1hrpna9v7vs3stzyd4z3xf00676kf78zpe2u5ksvljswn2vnjp3yqtxqz3t';
 
  try {
    console.log('Creating CW20 pointer for:', cw20Address);
 
    // Create the pointer
    const tx = await pointer.addCW20Pointer(cw20Address);
    const receipt = await tx.wait();
 
    console.log('CW20 pointer created:', receipt.transactionHash);
 
    // The pointer address would be available in the transaction logs
    // or returned by the function call
    return receipt;
  } catch (error) {
    console.error('Failed to create CW20 pointer:', error.message);
 
    if (error.message.includes('contract does not exist')) {
      console.error('CW20 contract not found at the provided address');
    } else if (error.message.includes('not a CW20 contract')) {
      console.error('Contract exists but is not a valid CW20 contract');
    }
 
    throw error;
  }
}

contract CW20PointerManager {
    IPointerPrecompile constant POINTER = IPointerPrecompile(0x000000000000000000000000000000000000100B);
 
    // Store created CW20 pointers
    mapping(string => address) public cw20Pointers;
    string[] public cw20Contracts;
 
    event CW20PointerCreated(string indexed contractAddr, address pointerAddress);
 
    function createCW20Pointer(string memory contractAddr) external returns (address pointerAddr) {
        // Validate input
        require(bytes(contractAddr).length > 0, "Contract address cannot be empty");
        require(cw20Pointers[contractAddr] == address(0), "Pointer already exists");
 
        // Create the CW20 pointer
        pointerAddr = POINTER.addCW20Pointer(contractAddr);
 
        // Store the pointer address
        cw20Pointers[contractAddr] = pointerAddr;
        cw20Contracts.push(contractAddr);
 
        emit CW20PointerCreated(contractAddr, pointerAddr);
 
        return pointerAddr;
    }
 
    function getCW20Pointer(string memory contractAddr) external view returns (address) {
        return cw20Pointers[contractAddr];
    }
 
    function getAllCW20Contracts() external view returns (string[] memory) {
        return cw20Contracts;
    }
 
    function getCW20ContractCount() external view returns (uint256) {
        return cw20Contracts.length;
    }
}

// Create a pointer for a CW721 NFT contract
async function createCW721Pointer() {
  // Example CW721 contract address (use actual contract address)
  const cw721Address = 'sei1nft789abcdef123456789abcdef123456789abcdef123456789abcdef12';
 
  try {
    console.log('Creating CW721 pointer for:', cw721Address);
 
    // Create the pointer with higher gas limit for NFT operations
    const tx = await pointer.addCW721Pointer(cw721Address, {
      gasLimit: 3000000n
    });
 
    const receipt = await tx.wait();
    console.log('CW721 pointer created:', receipt.transactionHash);
 
    // The erc721 compatible contract is now available at the returned address
    console.log('NFT collection is now EVM-compatible');
 
    return receipt;
  } catch (error) {
    console.error('Failed to create CW721 pointer:', error.message);
 
    if (error.message.includes('contract does not exist')) {
      console.error('CW721 contract not found at the provided address');
    } else if (error.message.includes('not a CW721 contract')) {
      console.error('Contract exists but is not a valid CW721 contract');
    }
 
    throw error;
  }
}

contract CW721PointerManager {
    IPointerPrecompile constant POINTER = IPointerPrecompile(0x000000000000000000000000000000000000100B);
 
    // Store created CW721 pointers
    mapping(string => address) public cw721Pointers;
    string[] public cw721Contracts;
 
    struct NFTCollection {
        string contractAddr;
        address pointerAddr;
        uint256 createdAt;
        address creator;
    }
 
    mapping(string => NFTCollection) public collections;
 
    event CW721PointerCreated(
        string indexed contractAddr,
        address indexed pointerAddress,
        address indexed creator
    );
 
    function createCW721Pointer(string memory contractAddr) external returns (address pointerAddr) {
        // Validate input
        require(bytes(contractAddr).length > 0, "Contract address cannot be empty");
        require(cw721Pointers[contractAddr] == address(0), "Pointer already exists");
 
        // Create the CW721 pointer
        pointerAddr = POINTER.addCW721Pointer(contractAddr);
 
        // Store the pointer address and collection info
        cw721Pointers[contractAddr] = pointerAddr;
        cw721Contracts.push(contractAddr);
 
        collections[contractAddr] = NFTCollection({
            contractAddr: contractAddr,
            pointerAddr: pointerAddr,
            createdAt: block.timestamp,
            creator: msg.sender
        });
 
        emit CW721PointerCreated(contractAddr, pointerAddr, msg.sender);
 
        return pointerAddr;
    }
 
    function getCW721Pointer(string memory contractAddr) external view returns (address) {
        return cw721Pointers[contractAddr];
    }
 
    function getCollectionInfo(string memory contractAddr) external view returns (NFTCollection memory) {
        return collections[contractAddr];
    }
 
    function getAllCW721Contracts() external view returns (string[] memory) {
        return cw721Contracts;
    }
 
    function getCW721ContractCount() external view returns (uint256) {
        return cw721Contracts.length;
    }
}