Mintee coleccionables usando una API de transacciones serverless sin gas

pnpm install wrangler --save-dev

alias wrangler='./node_modules/.bin/wrangler'

wrangler login

wrangler init

import { Session } from "@0xsequence/auth";

import { ethers } from "ethers";



(async () => {

  // Generate a new EOA

  // const wallet = ethers.Wallet.createRandom()

  // const privateKey = wallet.privateKey



  // Or, use an existing EOA private key

  const privateKey = "";



  // Open a Sequence session, this will find or create

  // a Sequence wallet controlled by your server EOA

  const session = await Session.singleSigner({

    signer: privateKey,

    projectAccessKey: "access_key",

  });



  const signer = session.account.getSigner(1);

  console.log(`Your transactions API wallet address: ${signer.account.address}`);

})();

pnpm install 0xsequence @0xsequence/network

import { sequence } from "0xsequence";

import { networks, findSupportedNetwork } from "@0xsequence/network";



export interface Env {

  PKEY: string; // Private key for EOA wallet

  CONTRACT_ADDRESS: string; // Deployed ERC1155 or ERC721 contract address

  PROJECT_ACCESS_KEY: string; // From sequence.build

  CHAIN_HANDLE: string; // Standardized chain name – See https://docs.sequence.xyz/multi-chain-support

}



// use the sequence api to verify proof came from a sequence wallet

const verify = async (

  chainId: string,

  walletAddress: string,

  ethAuthProofString: string

): Promise<Boolean> => {

  const api = new sequence.api.SequenceAPIClient("https://api.sequence.app");

  const { isValid } = await api.isValidETHAuthProof({

    chainId,

    walletAddress,

    ethAuthProofString,

  });

  return isValid;

};



async function handleRequest(

  request: Request,

  env: Env,

  ctx: ExecutionContext

): Promise<Response> {



  if (request.method === "OPTIONS") {

		return new Response(null, {

			headers: {

				// Allow requests from any origin - adjust this as necessary

				"Access-Control-Allow-Origin": "*",

				

				// Allows the headers Content-Type, your-custom-header

				"Access-Control-Allow-Headers": "Content-Type, your-custom-header",

				

				// Allow POST method - add any other methods you need to support

				"Access-Control-Allow-Methods": "POST",

				

				// Optional: allow credentials

				"Access-Control-Allow-Credentials": "true",

				

				// Preflight cache period

				"Access-Control-Max-Age": "86400", // 24 hours

			}

		});

	}



  if (env.PKEY === undefined || env.PKEY === "") {

    return new Response("Make sure PKEY is configured in your environment", {

      status: 400,

    });

  }



  if (env.CONTRACT_ADDRESS === undefined || env.CONTRACT_ADDRESS === "") {

    return new Response(

      "Make sure CONTRACT_ADDRESS is configured in your environment",

      { status: 400 }

    );

  }



  if (env.PROJECT_ACCESS_KEY === undefined || env.PROJECT_ACCESS_KEY === "") {

    return new Response(

      "Make sure PROJECT_ACCESS_KEY is configured in your environment",

      { status: 400 }

    );

  }



  if (env.CHAIN_HANDLE === undefined || env.CHAIN_HANDLE === "") {

    return new Response(

      "Make sure CHAIN_HANDLE is configured in your environment",

      { status: 400 }

    );

  }



  const chainConfig = findSupportedNetwork(env.CHAIN_HANDLE);



  if (chainConfig === undefined) {

    return new Response("Unsupported network or unknown CHAIN_HANDLE", {

      status: 400,

    });

  }



  // POST request

  if (request.method === "POST") {

    // parse the request body as JSON

    const body = await request.json();

    const { proof, address, tokenId }: any = body;

    try {

      // check that the proof is valid

      if (await verify(env.CHAIN_HANDLE, address, proof)) {

        try {

          // mocked call

          const res = await callContract(request, env, address, tokenId);

          return new Response(`${res.hash}`, { status: 200 });

        } catch (err: any) {

          console.log(err);

          return new Response(`Something went wrong: ${JSON.stringify(err)}`, {

            status: 400,

          });

        }

      } else {

        return new Response(`Unauthorized`, { status: 401 });

      }

    } catch (err: any) {

      return new Response(`Unauthorized ${JSON.stringify(err)}`, {

        status: 401,

      });

    }

  }

  // GET request

  else {

    try {

      // mocked call

      const res = await getBlockNumber(env.CHAIN_HANDLE, request);

      return new Response(`Block Number: ${res}`);

    } catch (err: any) {

      return new Response(`Something went wrong: ${JSON.stringify(err)}`, {

        status: 500,

      });

    }

  }

}



const getBlockNumber = async (

  chainId: string,

  request: Request

): Promise<number> => {

  return chainId;

};



const callContract = async (

  request: Request,

  env: Env,

  address: string,

  tokenId: number

): Promise<ethers.providers.TransactionResponse> => {

  return { hash: "0x" } as any;

};



export default {

  async fetch(request: Request, env: Env, ctx: ExecutionContext) {

    // Process the request and create a response

    const response = await handleRequest(request, env, ctx);



    // Set CORS headers

    response.headers.set("Access-Control-Allow-Origin", "*");

    response.headers.set(

      "Access-Control-Allow-Methods",

      "GET, POST, PUT, DELETE, OPTIONS"

    );

    response.headers.set("Access-Control-Allow-Headers", "Content-Type");



    // return response

    return response;

  },

};

[vars]

PKEY = "" # Private key for EOA wallet

CONTRACT_ADDRESS = "" # // Deployed ERC1155 or ERC721 contract address

PROJECT_ACCESS_KEY = "" # From sequence.build

CHAIN_HANDLE = "" # // Standardized chain name – See https://docs.sequence.xyz/multi-chain-support

...

node_compat = true # add this line

...

curl -X POST https://your-worker.your-subdomain.workers.dev \

-H "Content-Type: application/json" \

-d '{"proof": "<some_proof>", "address": "<some_address>", "tokenId": 0 }'



... invalid proof string ...



# and if you replace with actual proof (from a wallet client login) and address on polygon, it should return

success

curl -X POST https://your-worker.your-subdomain.workers.dev \

-H "Content-Type: application/json" \

-d '{"proof": "<some_proof>", "address": "<some_address>", "tokenId": 0 }'

pnpm install @0xsequence/auth ethers

import { ethers } from 'ethers'

import { Session, SessionSettings } from '@0xsequence/auth'



...



const getBlockNumber = async (chainId: string, request: Request): Promise<number> => {

	const nodeUrl = `https://nodes.sequence.app/${chainId}`

	const provider = new ethers.providers.JsonRpcProvider({ url: nodeUrl, skipFetchSetup: true })

	return await provider.getBlockNumber()

}



const callContract = async (request: Request, env: Env, address: string, tokenId: number): Promise<ethers.providers.TransactionResponse> => {



	const nodeUrl = `https://nodes.sequence.app/${env.CHAIN_HANDLE}`

	const relayerUrl = `https://${env.CHAIN_HANDLE}-relayer.sequence.app`

	const contractAddress = env.CONTRACT_ADDRESS





	// instantiate settings

	const settings: Partial<SessionSettings> = {

		networks: [{

			...networks[findSupportedNetwork(env.CHAIN_HANDLE)!.chainId],

			rpcUrl: findSupportedNetwork(env.CHAIN_HANDLE)!.rpcUrl,

			relayer: {

				url: relayerUrl,

				provider: {

					url: findSupportedNetwork(env.CHAIN_HANDLE)!.rpcUrl

				}

			}

		}],

	}



    // create a single signer sequence wallet session

	const session = await Session.singleSigner({

		settings: settings,

		signer: env.PKEY,

		projectAccessKey: env.PROJECT_ACCESS_KEY

	})



	// get signer

	const signer = session.account.getSigner(findSupportedNetwork(env.CHAIN_HANDLE)!.chainId)



	// create interface from partial abi

	const collectibleInterface = new ethers.Interface([

		'function mint(address to, uint256 tokenId, uint256 amount, bytes data)'

	])



	// create calldata

	const data = collectibleInterface.encodeFunctionData(

		'mint', [address, tokenId, 1, "0x00"]

	)



	// create transaction object

	const txn = { to: contractAddress, data }



	try {

		return await signer.sendTransaction(txn)

	} catch (err) {

		throw err

	}

}