@vela-ventures/aosync-sdk-react/dist/walletContext.js

React SDK for Beacon wallet

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
export { useWallet } from "./useWallet";
import React, { useEffect, useRef, useState, createContext, } from "react";
import Arweave from "arweave";
import WalletClient from "@vela-ventures/ao-sync-sdk";
export const AOSyncContext = createContext(undefined);
export function AOSyncProvider({ gatewayConfig = { host: "arweave.net", port: 443, protocol: "https" }, muUrl = "https://mu.ao-testnet.xyz", children, appInfo, }) {
    var _a;
    const walletRef = useRef(new WalletClient());
    const [isConnected, setIsConnected] = useState(!!((_a = walletRef === null || walletRef === void 0 ? void 0 : walletRef.current) === null || _a === void 0 ? void 0 : _a.uid));
    const [isSessionActive, setIsSessionActive] = useState(() => {
        if (typeof window !== "undefined") {
            const sessionValue = sessionStorage.getItem("aosync-session-active");
            return sessionValue ? JSON.parse(sessionValue) : false;
        }
        return false;
    });
    useEffect(() => {
        const wallet = walletRef.current;
        wallet.reconnect();
        const handleDisconnect = () => setIsConnected(false);
        const handleConnect = () => setIsConnected(true);
        wallet.on("disconnected", handleDisconnect);
        wallet.on("connected", handleConnect);
        return () => {
            wallet.off("disconnected", handleDisconnect);
            wallet.off("connected", handleConnect);
        };
    }, []);
    useEffect(() => {
        const handleStorageChange = (event) => {
            if (event.key === "aosync-session-active" && event.storageArea === sessionStorage) {
                const newValue = event.newValue ? JSON.parse(event.newValue) : false;
                setIsSessionActive(newValue);
            }
        };
        window.addEventListener("storage", handleStorageChange);
        return () => {
            window.removeEventListener("storage", handleStorageChange);
        };
    }, []);
    const connect = () => __awaiter(this, void 0, void 0, function* () {
        try {
            yield walletRef.current.connect({
                gateway: gatewayConfig,
                appInfo,
            });
        }
        catch (error) {
            console.error("Error connecting wallet:", error);
            throw error;
        }
    });
    const disconnect = () => __awaiter(this, void 0, void 0, function* () {
        try {
            yield walletRef.current.disconnect();
            setIsConnected(false);
        }
        catch (error) {
            console.error("Error disconnecting wallet:", error);
            throw error;
        }
    });
    const getAddress = () => __awaiter(this, void 0, void 0, function* () {
        try {
            return yield walletRef.current.getActiveAddress();
        }
        catch (error) {
            console.error("Error getting address:", error);
            throw error;
        }
    });
    const getAllAddresses = () => __awaiter(this, void 0, void 0, function* () {
        try {
            return yield walletRef.current.getAllAddresses();
        }
        catch (error) {
            console.error("Error getting address:", error);
            throw error;
        }
    });
    const sendAR = (recipient, quantity) => __awaiter(this, void 0, void 0, function* () {
        try {
            const arweave = Arweave.init(gatewayConfig);
            const tx = yield arweave.createTransaction({
                target: recipient,
                quantity: quantity,
            });
            const signedTx = yield walletRef.current.sign(tx);
            return yield arweave.transactions.post(signedTx);
        }
        catch (error) {
            console.error("Error sending AR:", error);
            throw error;
        }
    });
    const signAOMessage = (dataItem) => __awaiter(this, void 0, void 0, function* () {
        var _a;
        try {
            (_a = dataItem === null || dataItem === void 0 ? void 0 : dataItem.tags) === null || _a === void 0 ? void 0 : _a.push({ name: "SDK", value: "Beacon Wallet" }, { name: "Data-Protocol", value: "ao" }, { name: "Variant", value: "ao.TN.1" }, { name: "Type", value: "Message" });
            const signedDataItem = yield walletRef.current.signDataItem(dataItem);
            const response = yield fetch(muUrl, {
                method: "POST",
                headers: {
                    "Content-Type": "application/octet-stream",
                },
                body: signedDataItem,
            });
            if (!response.ok) {
                throw new Error("Network response was not ok");
            }
            return yield extractAndHashId(signedDataItem);
        }
        catch (error) {
            console.error("Error signing AO message:", error);
            throw error;
        }
    });
    function extractAndHashId(byteArray) {
        return __awaiter(this, void 0, void 0, function* () {
            const idBytes = byteArray.slice(2, 2 + 512);
            const hashBuffer = yield crypto.subtle.digest("SHA-256", idBytes);
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            const hashBase64 = btoa(String.fromCharCode.apply(null, hashArray))
                .replace(/\+/g, "-")
                .replace(/\//g, "_")
                .replace(/=+$/, "");
            return hashBase64;
        });
    }
    const sign = (transaction) => __awaiter(this, void 0, void 0, function* () {
        try {
            return yield walletRef.current.sign(transaction);
        }
        catch (error) {
            console.error("Error signing wallet:", error);
            throw error;
        }
    });
    return (React.createElement(AOSyncContext.Provider, { value: {
            isConnected,
            isSessionActive,
            connect,
            disconnect,
            getAddress,
            getAllAddresses,
            sendAR,
            signAOMessage,
            sign,
        } }, children));
}