import { useAccount, useConnect } from "wagmi";
import { injected } from "wagmi/connectors";

import { CreateProfileForm } from "./CreateProfileForm";

export function OnboardingPage() {
  const { address, isDisconnected, isConnecting } = useAccount();
  const { connect } = useConnect();

  if (isDisconnected && !address) {
    return (
      <button
        disabled={isConnecting}
        onClick={() => connect({ connector: injected() })}
      >
        Connect Wallet
      </button>
    );
  }

  return <CreateProfileForm wallet={address} />;
}

import { useState } from "react";
import { useValidateHandle } from "@lens-protocol/react-web";

type CreateProfileFormProps = {
  wallet: string;
};

export function CreateProfileForm({ wallet }: CreateProfileFormProps) {
  const [localName, setLocalName] = useState("");
  const { execute: validateHandle, loading: verifying } = useValidateHandle();

  const submit = async () => {
    const result = await validateHandle({ localName });

    if (result.isFailure()) {
      console.error();
      return;
    }

    // TODO: mint profile
  };

  return (
    <form onSubmit={submit}>
      <input
        type="text"
        disabled={verifying}
        value={localName}
        onChange={(e) => setLocalName(e.target.value)}
      />

      <button type="submit" disabled={verifying}>
        Create
      </button>
    </form>
  );
}

import { useState } from "react";
import { useCreateProfile, useValidateHandle } from "@lens-protocol/react-web";

type CreateProfileFormProps = {
  wallet: string;
};

export function CreateProfileForm({ wallet }: CreateProfileFormProps) {
  const [localName, setLocalName] = useState("");
  const { execute: validateHandle, loading: verifying } = useValidateHandle();
  const { execute: createProfile, loading: creating } = useCreateProfile();

  const submit = async () => {
    const result = await validateHandle({ localName });

    if (result.isFailure()) {
      window.alert(result.error.message);
      return;
    }

    const result = await execute({ localName, to: address });

    if (result.isFailure()) {
      window.alert(result.error.message);
      return;
    }

    const profile = result.value;
    window.alert(
      `Congratulations! You now own: ${profile.handle?.fullHandle}!`
    );
  };

  return (
    <form onSubmit={submit}>
      <input
        type="text"
        disabled={verifying || creating}
        value={localName}
        onChange={(e) => setLocalName(e.target.value)}
      />

      <button type="submit" disabled={verifying || creating}>
        Create
      </button>
    </form>
  );
}

import { isValidHandle } from "@lens-protocol/client";

const requestedHandle = "wagmi"; // input from the user

if (!isValidHandle(requestedHandle)) {
  console.error(`Invalid handle`);
}

import { LensClient, production } from "@lens-protocol/client";

const client = new LensClient({
  environment: production,
});

const handleOwnerAddress = await client.handle.resolveAddress({
  handle: `lens/${requestedHandle}`,
});

if (handleOwnerAddress) {
  console.error(`The requested handle is not available.`);
}

query {  
  handleToAddress(request: { handle: "lens/wagmi" })  
}

{
  "data": {
    "handleToAddress": null // or owner wallet address
  }
}

[
  {
    "inputs": [],
    "name": "getProfileWithHandleCreationPrice",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "components": [
          {
            "internalType": "address",
            "name": "to",
            "type": "address"
          },
          {
            "internalType": "address",
            "name": "followModule",
            "type": "address"
          },
          {
            "internalType": "bytes",
            "name": "followModuleInitData",
            "type": "bytes"
          }
        ],
        "internalType": "struct Types.CreateProfileParams",
        "name": "createProfileParams",
        "type": "tuple"
      },
      {
        "internalType": "string",
        "name": "handle",
        "type": "string"
      },
      {
        "internalType": "address[]",
        "name": "delegatedExecutors",
        "type": "address[]"
      }
    ],
    "name": "createProfileWithHandle",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "profileId",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "handleId",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable",
    "type": "function"
  }
]

const relayerAddress = await client.transaction.generateLensAPIRelayAddress();

query {
  generateLensAPIRelayAddress
}

import { createPublicClient, createWalletClient, http, custom } from 'viem'
import { mainnet } from 'viem/chains'

import abi from "./permissonless-creator.json" assert { type: "json" };

// setup all what is required to interact with the contract
export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
})
export const walletClient = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum!),
})

// init the contract
const permissonlessCreator = getContract({
  address: CONTRACT_ADDRESS,
  abi,
  client: { public: publicClient, wallet: walletClient }
});

// get the mint price
const price = await permissonlessCreator.read.getProfileWithHandleCreationPrice();

import { ethers } from "ethers";
import abi from "./permissonless-creator.json" assert { type: "json" };

// setup all what is required to interact with the contract
const provider = new ethers.providers.JsonRpcProvider(RPC_PROVIDER_URL);
const wallet = new ethers.Wallet(WALLET_PRIVATE_KEY, provider);

// init the contract
const permissonlessCreator = new ethers.Contract(
  CONTRACT_ADDRESS,
  abi,
  wallet
) as PermissonlessCreator;

// get the mint price
const price = await permissonlessCreator.getProfileWithHandleCreationPrice();

const hash = await permissonlessCreator.write.createProfileWithHandle(
  {
    to: wallet.address,
    followModule: "0x0000000000000000000000000000000000000000",
    followModuleInitData: "0x",
  },
  requestedHandle, // "wagmi"
  [relayerAddress],
  {
    value: price,
  }
);

console.log(
  `Transaction to create a new profile with handle was successfully broadcasted with hash`,
  hash
);

console.log(`Waiting for the transaction to be indexed...`);
const outcome = await client.transaction.waitUntilComplete({
  forTxHash: hash,
});

if (outcome === null) {
  console.error(`The transaction with hash ${hash} was lost.`);
  process.exit(1);
}

console.log("A new profile with handle has been successfully minted.");

const tx = await permissonlessCreator.createProfileWithHandle(
  {
    to: wallet.address,
    followModule: "0x0000000000000000000000000000000000000000",
    followModuleInitData: "0x",
  },
  requestedHandle, // "wagmi"
  [relayerAddress],
  {
    value: price,
  }
);

console.log(
  `Transaction to create a new profile with handle was successfully broadcasted with hash`,
  tx.hash
);

console.log(`Waiting for the transaction to be indexed...`);
const outcome = await client.transaction.waitUntilComplete({
  forTxHash: tx.hash,
});

if (outcome === null) {
  console.error(`The transaction with hash ${tx.hash} was lost.`);
  process.exit(1);
}

console.log("A new profile with handle has been successfully minted.");

function createProfileWithHandleUsingCredits(
  Types.CreateProfileParams calldata createProfileParams,
  string calldata handle,
  address[] calldata delegatedExecutors
) external returns (uint256 profileId, uint256 handleId);

struct CreateProfileParams {
  address to;
  address followModule;
  bytes followModuleInitData;
}

function createProfileUsingCredits(
  Types.CreateProfileParams calldata createProfileParams,
  address[] calldata delegatedExecutors
) external returns (uint256);

struct CreateProfileParams {
  address to;
  address followModule;
  bytes followModuleInitData;
}

function createHandleWithCredits(
  address to,
  string calldata handle
) external returns (uint256);

function transferFromKeepingDelegates(
  address from,
  address to,
  uint256 tokenId
) external;

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';

struct CreateProfileParams {
    address to;
    address followModule;
    bytes followModuleInitData;
}

interface IPermissonlessCreator {
    function createProfileUsingCredits(
        CreateProfileParams calldata createProfileParams,
        address[] calldata delegatedExecutors
    ) external returns (uint256);

    function createProfileWithHandleCredits(
        CreateProfileParams calldata createProfileParams,
        string calldata handle,
        address[] calldata delegatedExecutors
    ) external returns (uint256, uint256);

    function createHandleWithCredits(
        address to,
        string calldata handle
    ) external returns (uint256);
}

contract AppChargeLensOnboarding is Ownable {
    // load the permissonless creator contract
    IPermissonlessCreator public immutable PERMISSONLESS_CREATOR;

    // the cost to buy a profile with handle
    uint256 public profileWithHandleCreationCost = 1 ether;

    error InvalidFunds();

    constructor(address owner, address permissonlessCreator) {
        _transferOwnership(owner);
        PERMISSONLESS_CREATOR = IPermissonlessCreator(permissonlessCreator);
    }

    // charge funds send to your beneficiary and then create profile for the user
    function createProfileWithHandle(
        CreateProfileParams calldata createProfileParams,
        string calldata handle,
        address[] calldata delegatedExecutors
    ) external payable returns (uint256 profileId, uint256 handleId) {
        if (msg.value != profileWithHandleCreationCost) {
            revert InvalidFunds();
        }

        // delegatedExecutors are only allowed if to == msg.sender
        if (delegatedExecutors.length > 0 && createProfileParams.to != msg.sender) {
            revert NotAllowed();
        }

        return PERMISSONLESS_CREATOR.createProfileWithHandleCredits(createProfileParams, handle, delegatedExecutors);
    }

    function withdrawFunds() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';

struct CreateProfileParams {
    address to;
    address followModule;
    bytes followModuleInitData;
}

interface IPermissonlessCreator {
    function createProfileUsingCredits(
        CreateProfileParams calldata createProfileParams,
        address[] calldata delegatedExecutors
    ) external returns (uint256);

    function createProfileWithHandleCredits(
        CreateProfileParams calldata createProfileParams,
        string calldata handle,
        address[] calldata delegatedExecutors
    ) external returns (uint256, uint256);

    function createHandleWithCredits(
        address to,
        string calldata handle
    ) external returns (uint256);
}

// onboard lens users for free
contract AppFreeLensOnboarding is Ownable {
    // load the permissionless creator contract
    IPermissonlessCreator public immutable PERMISSONLESS_CREATOR;

    // your EOAs which can do this transactions can be
    // a list of defender addresses or a list of your own EOAs
    // these will send the transactions
    mapping(address => bool) public allowedAddresses;

    // modifier to only allow your allowed address to do it
    modifier onlyAllowed() {
        require(allowedAddresses[msg.sender], 'AppFreeLensOnboarding: Not allowed');
        _;
    }

    constructor(address owner, address permissonlessCreator) {
        _transferOwnership(owner);
        PERMISSONLESS_CREATOR = IPermissonlessCreator(permissonlessCreator);
    }

    // add to the allowed addresses
    function addAllowedAddresses(address[] calldata newAddresses) external onlyOwner {
        for (uint256 i = 0; i < newAddresses.length; i++) {
            allowedAddresses[newAddresses[i]] = true;
        }
    }

    // remove the allowed addresses
    function removeAllowedAddress(address newAddress) external onlyOwner {
        allowedAddresses[newAddress] = false;
    }

    // check if they are allowed addresses
    function isAllowedAddress(address newAddress) external view returns (bool) {
        return allowedAddresses[newAddress];
    }

    // checks onlyAllowed and then mints it from the credits
    function createProfileWithHandle(
        CreateProfileParams calldata createProfileParams,
        string calldata handle,
        address[] calldata delegatedExecutors
    ) external onlyAllowed returns (uint256 profileId, uint256 handleId) {
        return PERMISSONLESS_CREATOR.createProfileWithHandleCredits(createProfileParams, handle, delegatedExecutors);

}

POST /payments/create
Host: <api-url>
x-shared-secret: <shared-secret>
Accept: application/json
Content-Type: application/json
Content-Length: 103

{
  "address": "0x1234567890abcdef1234567890abcdef12345678",
  "handle": "wagmi",
  "currency": "usd"
}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 137

{
  "id": "pi_1J3xjz2eZvKYlo2C5z3z",
  "for": "0x1234567890abcdef1234567890abcdef12345678",
 "clientSecret": "pi_1J3xjz2eZvKYlo2C5z3z"
}

HTTP/1.1 400 Bad Request
Content-Type: text/plain
Content-Length: 21

HANDLE_ALREADY_EXISTS

GET /payments/<paymentIntentId>/blockchain-tx-info
Host: <api-url>
x-shared-secret: <shared-secret>
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 160

{
  "status": "FULL_SUCCESS",
  "txId": "a8b3a0f9-87d7-42e5-b214-31ea3b76247b",
  "handle": "wagmi",
  "address": "0x1234567890abcdef1234567890abcdef12345678"
}

export const dynamic = "force-dynamic";

export async function POST(request: Request) {
  const response = await fetch(`${process.env.LENS_API}/payments/create`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-shared-secret": process.env.SHARED_SECRET,
    },
    body: await request.text(),
  });

  if (response.ok) {
    const data = await response.json();
    return Response.json({ data, success: true }, { status: 200 });
  }

  const error = await response.text();
  return Response.json(
    { error, success: false },
    { status: response.status }
  );
}

export const dynamic = "force-dynamic";

type Params = { paymentIntentId: string };

export async function GET(request: Request, { params }: { params: Params }) {
  const response = await fetch(
    `${process.env.LENS_API}/payments/${params.paymentIntentId}/blockchain-tx-info`,
    {
      method: "GET",
      headers: {
        "Content-Type": "application/json",
        "x-shared-secret": process.env.SHARED_SECRET,
      },
    }
  );

  if (response.ok) {
    const data = await response.json();
    return Response.json({ data, success: true }, { status: 200 });
  }

  const error = await response.text();
  return Response.json(
    { error, success: false },
    { status: response.status }
  );
}

const express = require("express");
const bodyParser = require("body-parser");

const app = express();

app.use(bodyParser.json());

app.post("/api/payments", async (req, res) => {
  const response = await fetch(`${process.env.LENS_API}/payments/create`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-shared-secret": process.env.SHARED_SECRET,
    },
    body: await request.text(),
  });

  if (response.ok) {
    const data = await response.json();
    return res.json({ data, success: true });
  }

  const error = await response.text();
  return res.json({ error, success: false });
});

app.get("/api/payments/:paymentIntentId", async (req, res) => {
  const response = await fetch(
    `${process.env.LENS_API}/payments/${req.params.paymentIntentId}/blockchain-tx-info`,
    {
      method: "GET",
      headers: {
        "Content-Type": "application/json",
        "x-shared-secret": process.env.SHARED_SECRET,
      },
    }
  );

  if (response.ok) {
    const data = await response.json();
    return res.json({ data, success: true });
  }

  const error = await response.text();
  return res.json({ error, success: false });
});

app.listen(process.env.PORT, function () {
  console.log(`Listening on port: ${process.env.PORT}`);
});

import { LensClient, development, isRelaySuccess } from "@lens-protocol/client";

const client = new LensClient({
  environment: development, // wont't work with `production`
});

const result = await client.wallet.createProfileWithHandle({
  // e.g. 'alice' which will be '@lens/alice' in full-handle notation
  handle: "<local name>",
  to: "<your address>",
});

// handle relay errors
if (!isRelaySuccess(profileCreateResult)) {
  console.error(`Something went wrong`, result);
  process.exit(1);
}

// wait for the transaction to be mined and indexed
const outcome = await client.transaction.waitUntilComplete({
  forTxId: result.txId,
});

// handle transaction not found
if (outcome === null) {
  console.error("The transaction was not found");
  process.exit(1);
}

console.log("Profile created");

mutation {
  createProfileWithHandle(
    request: {
      # e.g. 'alice' which will be '@lens/alice' in full-handle notation
      handle: "<local name>"
      to: "<your address>"
    }
  ) {
    ... on RelaySuccess {
      txHash
      txId
    }

    ... on CreateProfileWithHandleErrorResult {
      reason
    }
  }
}

{
  "data": {
    "actOnOpenAction": {
      "txId": "c30869d4-9a3a-4373-b5dc-811ea393bdf5",
      "txHash": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
    }
  }
}

{
  "data": {
    "actOnOpenAction": {
      "reason": "FAILED" // LensProfileManagerRelayErrorReasonType
    }
  }
}