Get Started on EVM

Overview

Make your NFTs accessible to everyone globally. Ramper NFT Checkout provides a fast NFT checkout solution supporting both crypto & fiat. Ramper handles instant wallet creation, chargebacks, and pays you in your NFT contract's native tokens.

Check out our Live Demo, and try purchasing a (free) Ramper Token!

To get started you'll need your NFT assets (images + metadata) hosted online, for example on AWS S3 or IPFS. For a help generating NFT art, check out this tutorial .

Deploy your Smart Contract

The first step in launching your NFT collection is deploying a smart contract. Ramper supports a couple different ways of achieving this:

• Launch a new collection that uses the Ramper Interface

• Deploy a "bridge" contract that allows Ramper to interact with your pre-existing smart contract

You'll probably want to deploy a contract on a testnet first -- we currently support Ethereum's Goerli network and Polygon's Mumbai network. Deploy contracts to the test network, and make sure to pick the appropriate network in the Developer Dashboard when setting up your collection in the next step (Setting Up Your Collection)

ERC721 vs ERC1155

Ramper currently supports 2 approaches to NFT Contracts: ERC721 and ERC1155. While there are variations of both contracts, we define them as follows:

ERC721 contracts are "gumball-machine" style -- users purchase whatever token is up next for minting (or a random token)

ERC1155 contracts are "vending-machine" style -- your Dapp should always supply the token_id the user is looking to purchase. Please note: for ERC1155 contracts, you'll need to supply `token_id` in each of the functions below!

If you have more specific requirements or questions, please reach out at [e-mail] or message us on Discord.

New Contracts

The simplest way to get started with Ramper NFT Checkout is to launch a brand new contract that supports IRamperInterface721/1155. Here is a basic outline of the interface:

interface IRamperInterface721 {
    /// NOTE: ALL of the below functions must alllow to be called successfully from
    /// addreess 0xA31f61F6957d570fb9BEc9E3879EA6947dFE5688
    
    /// @notice Gets the number of tokens the specified wallet is able to purchase currently.
    function availableTokens(address _userWallet) external view returns (uint256 quantity);


    /// @notice Gets the price of a single NFT in Wei
    function price() external view returns (uint256);


    /// @notice Mint function that mints the NFT
    function mint(address _userWallet, uint256 _quantity) external payable;


    /// @notice Helper Transfer function to allow multiple tokens to be transferred at once
    function safeBulkTransferFrom(address _from, address _to, uint256[] memory _tokenIds) external;
}

You can find the full interface definition in the Ramper Contracts Repo on Github. In short, your contract needs:

• A price function that returns the current price for a token

• A mint function that mints X tokens to a specified address

• An availableTokens function that checks how many tokens a user can buy in their next transaction. You can implement custom logic to restrict per-wallet limits, per-transaction limits, and/or a cap on the total supply.

• (ERC721 only) A safeBulkTransferFrom function that allows Ramper to transfer multiple tokens in one transaction. This greatly reduces gas costs for larger transactions.

You can see full, working example contracts in the Ramper Github repo, for both ERC721 and ERC1155 .

Existing Contracts

If you already have your contract deployed, you can deploy a "bridge" contract that allows Ramper to interact with your custom functions. The interface is the same as above.

The primary difference with Bridge Contracts is that the safeBulkTransferFromMUST check that the sender matches the "_from" address, and Ramper must manually approve the Bridge contract to manage NFT transfers. Please reach out to us for approvals: https://docs.ramper.xyz/#chat-with-us

Here you can find a full, working example of an ERC721 bridge contract

Supported Networks

Currently Ramper supports the following networks (more to come soon):

• Ethereum (+ Goerli test network)

• Polygon (+ Mumbai test network)

Make sure to note down which network you've deployed your contract to, as we'll use it when setting up the collection below.

Verification on Etherscan/Polygonscan

Contracts need to be verified on Etherscan/Polygonscan before they can be used with Ramper NFT Checkout. If you're using hardhat, run the following command:

npx hardhat verify <my_contract_addr> --network <my_network>