coherent state

Author: Ataxia123

package.json

@@ -42,5 +42,11 @@
     "next": "~14.0.4",
     "vercel": "~32.4.1"
   },
-  "packageManager": "[email protected]"
+  "packageManager": "[email protected]",
+  "dependencies": {
+    "@ethereum-attestation-service/eas-sdk": "^1.5.0",
+    "axios": "^1.6.8",
+    "ethers": "^6.11.1",
+    "moment-timezone": "^0.5.45"
+  }
 }

packages/nextjs/app/api/vote/route.ts

@@ -0,0 +1,38 @@
+; import axios from 'axios';
+import moment from 'moment-timezone';
+
+class CryptoClock {
+    private ethBlockTime: number;
+
+    constructor() {
+        this.ethBlockTime = 13.5; // Average Ethereum block time in seconds
+    }
+
+    async getEthBlockNumber(): Promise<number> {
+        try {
+            const response = await axios.get('https://api.etherscan.io/api?module=proxy&action=eth_blockNumber');
+            return parseInt(response.data.result, 16);
+        } catch (error) {
+            throw new Error('Failed to fetch Ethereum block number');
+        }
+    }
+
+    async convertTimeToEthBlock(time: string, timeZone: string): Promise<number> {
+        const currentTime = moment().tz(timeZone);
+        const targetTime = moment.tz(time, timeZone);
+        const timeDiff = targetTime.diff(currentTime, 'seconds');
+        const blockDiff = Math.floor(timeDiff / this.ethBlockTime);
+        const currentBlock = await this.getEthBlockNumber();
+        const targetBlock = currentBlock + blockDiff;
+        return targetBlock;
+    }
+
+    convertEthBlocksToTime(ethBlocks: number, timeZone: string): string {
+        const ethSeconds = ethBlocks * this.ethBlockTime;
+        const currentTime = moment().tz(timeZone);
+        const targetTime = currentTime.add(ethSeconds, 'seconds');
+        return targetTime.format();
+    }
+}
+
+export default CryptoClock;

packages/nextjs/components/ClockComponent.tsx

@@ -0,0 +1,59 @@
+import React from 'react';
+import { EAS, SchemaEncoder } from "@ethereum-attestation-service/eas-sdk";
+import { useBlockNumber } from "wagmi";
+import { useSigner } from "~~/utils/wagmi-utils"
+import CryptoClock from './ClockComponent';
+
+async function exampleUsage() {
+    const clock = new CryptoClock();
+
+    // Convert time to Ethereum block
+    const time = '2023-03-23 15:30:00';
+    const timeZone = 'America/New_York';
+    const ethBlock = await clock.convertTimeToEthBlock(time, timeZone);
+    console.log(`Time ${time} (${timeZone}) corresponds to Ethereum block ${ethBlock}`);
+
+    // Convert Ethereum blocks to time
+    const ethBlocks = 100;
+    const targetTime = clock.convertEthBlocksToTime(ethBlocks, timeZone);
+    console.log(`${ethBlocks} Ethereum blocks from now is ${targetTime} (${timeZone})`);
+}
+
+exampleUsage();
+
+const CreateSession = () => {
+    const signer = useSigner();
+    const numba = useBlockNumber();
+    const easContractAddress = "0x4200000000000000000000000000000000000021";
+    const eas = new EAS(easContractAddress);
+    const [title, setTitle] = React.useState("");
+    if (!signer) return null;
+    eas.connect(signer);
+    const Attest = async () => {
+        const schemaUID = "0x4e36b4880c16106a434c64c4217d519f98711ec82b44c09b0d3e10971bbb11e8";
+        // Signer must be an ethers-like signer.
+        // Initialize SchemaEncoder with the schema string
+        const schemaEncoder = new SchemaEncoder("string sesionTitle,uint32 startBlock");
+        const encodedData = schemaEncoder.encodeData([
+            { name: "sesionTitle", value: "", type: "string" },
+            { name: "startBlock", value: numba, type: "uint32" }
+        ]);
+        const tx = await eas.attest({
+            schema: schemaUID,
+            data: {
+                recipient: "0x0000000000000000000000000000000000000000",
+                expirationTime: 0n,
+                revocable: true, // Be aware that if your schema is not revocable, this MUST be false
+                data: encodedData,
+            },
+        });
+        const newAttestationUID = await tx.wait();
+        console.log("New attestation UID:", newAttestationUID);
+
+    }
+
+
+    return (<></>);
+}
+
+export default CreateSession;

packages/nextjs/components/CreateSession.tsx

@@ -0,0 +1,70 @@
+import { type PublicClient, type WalletClient } from "@wagmi/core";
+import { type HttpTransport } from "viem";
+import { useEffect, useState } from "react";
+import { usePublicClient, useWalletClient } from "wagmi";
+import { ethers, JsonRpcProvider, JsonRpcSigner } from "ethers";
+
+export function publicClientToProvider(publicClient: PublicClient) {
+    const { chain, transport } = publicClient;
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    if (transport.type === "fallback")
+        return new ethers.FallbackProvider(
+            (transport.transports as ReturnType<HttpTransport>[]).map(
+                ({ value }) => new ethers.JsonRpcProvider(value?.url, network)
+            )
+        );
+    return new ethers.JsonRpcProvider(transport.url, network);
+}
+
+export async function walletClientToSigner(walletClient: WalletClient) {
+    const { account, chain, transport } = walletClient;
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    const provider = new ethers.BrowserProvider(transport, network);
+    return provider.getSigner(account.address);
+}
+
+export function useSigner() {
+    const { data: walletClient } = useWalletClient();
+
+    const [signer, setSigner] = useState<JsonRpcSigner | undefined>(undefined);
+    useEffect(() => {
+        async function getSigner() {
+            if (!walletClient) return;
+
+            const tmpSigner = await walletClientToSigner(walletClient);
+
+            setSigner(tmpSigner);
+        }
+
+        getSigner();
+    }, [walletClient]);
+    return signer;
+}
+
+export function useProvider() {
+    const publicClient = usePublicClient();
+
+    const [provider, setProvider] = useState<JsonRpcProvider | undefined>(
+        undefined
+    );
+    useEffect(() => {
+        async function getSigner() {
+            if (!publicClient) return;
+
+            const tmpProvider = publicClientToProvider(publicClient);
+
+            setProvider(tmpProvider as JsonRpcProvider);
+        }
+
+        getSigner();
+    }, [publicClient]);
+    return provider;
+}