Integrator's Guide: Authentication¶

// Assuming you have Parse SDK initialized or using direct REST calls
// Example using Fetch API for direct REST call
const PARSE_SERVER_URL = "YOUR_GEMFORCE_PARSE_SERVER_URL/parse";
const APP_ID = "YOUR_PARSE_APP_ID";
const CLIENT_KEY = "YOUR_PARSE_CLIENT_KEY"; // Or Master Key for backend

// User Sign Up
async function signUp(username, password, email) {
    const response = await fetch(`${PARSE_SERVER_URL}/users`, {
        method: 'POST',
        headers: {
            'X-Parse-Application-Id': APP_ID,
            'X-Parse-REST-API-Key': CLIENT_KEY,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            username: username,
            password: password,
            email: email
        })
    });
    const data = await response.json();
    if (!response.ok) {
        throw new Error(data.error || 'Sign up failed');
    }
    console.log("Sign up successful:", data);
    return data; // Contains sessionToken
}

// User Log In
async function login(username, password) {
    const response = await fetch(`${PARSE_SERVER_URL}/login?username=${username}&password=${password}`, {
        method: 'GET',
        headers: {
            'X-Parse-Application-Id': APP_ID,
            'X-Parse-REST-API-Key': CLIENT_KEY // Use Client Key for client-side API
        }
    });
    const data = await response.json();
    if (!response.ok) {
        throw new Error(data.error || 'Login failed');
    }
    console.log("Login successful, session token:", data.sessionToken);
    return data.sessionToken;
}

// Authenticated Request to a Cloud Function
async function callCloudFunction(functionName, params, sessionToken) {
    const response = await fetch(`${PARSE_SERVER_URL}/functions/${functionName}`, {
        method: 'POST',
        headers: {
            'X-Parse-Application-Id': APP_ID,
            'X-Parse-REST-API-Key': CLIENT_KEY,
            'X-Parse-Session-Token': sessionToken, // Include session token
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(params)
    });
    const data = await response.json();
    if (!response.ok) {
        throw new Error(data.error || `Cloud function ${functionName} failed`);
    }
    console.log(`Cloud function ${functionName} response:`, data.result);
    return data.result;
}

// Example usage:
(async () => {
    try {
        // await signUp("testuser1", "password123", "test1@example.com");
        const token = await login("testuser1", "password123");
        const result = await callCloudFunction("helloWorld", { message: "from integrator" }, token);
    } catch (e) {
        console.error("Authentication error:", e.message);
    }
})();

const express = require('express');
const ParseServer = require('parse-server').ParseServer;
const Parse = require('parse/node'); // Import Parse SDK for Node.js environments

// --- Initialize Parse SDK (usually done globally once) ---
Parse.initialize("YOUR_PARSE_APP_ID", "YOUR_PARSE_JAVASCRIPT_KEY", "YOUR_PARSE_MASTER_KEY");
Parse.serverURL = "YOUR_GEMFORCE_PARSE_SERVER_URL/parse";

async function callCloudFunctionWithMasterKey(functionName, params) {
    try {
        // Use Parse.Cloud.run directly in Node.js, it will use the initialized Master Key
        const result = await Parse.Cloud.run(functionName, params, {
            useMasterKey: true // Use Master Key for this request
        });
        console.log(`Cloud function ${functionName} response:`, result);
        return result;
    } catch (e) {
        console.error(`Cloud function ${functionName} failed:`, e.message);
        throw e;
    }
}

// Example usage:
(async () => {
    try {
        const adminResult = await callCloudFunctionWithMasterKey("processAdminTask", { userId: "someUserId" });
    } catch (e) {
        console.error("Admin task error:", e.message);
    }
})();

import { ethers } from 'ethers';
// Assuming you have the ABI for the smart contract you want to interact with
import MyContractABI from './MyContract.json'; 

const CONTRACT_ADDRESS = "0x..."; // Address of the deployed Gemforce smart contract
const PROVIDER_URL = "https://sepolia.base.org"; // Or use window.ethereum for browser dApps

async function interactWithSmartContract() {
    try {
        // Connect to the user's wallet
        // For browser environments, use window.ethereum
        // const provider = new ethers.providers.Web3Provider(window.ethereum);
        // await provider.send("eth_requestAccounts", []); // Request account access
        // const signer = provider.getSigner();

        // For Node.js/backend automation (using a private key)
        const provider = new ethers.JsonRpcProvider(PROVIDER_URL);
        const privateKey = "YOUR_PRIVATE_KEY"; // Keep this secure! For demo only.
        const signer = new ethers.Wallet(privateKey, provider);

        // Create a contract instance
        const myContract = new ethers.Contract(CONTRACT_ADDRESS, MyContractABI, signer);

        // Example: Call a function that changes state (requires gas)
        const tx = await myContract.someStateChangingFunction("some_parameter", { value: ethers.parseEther("0.1") });
        console.log("Transaction sent:", tx.hash);

        // Wait for the transaction to be mined
        const receipt = await tx.wait();
        console.log("Transaction confirmed in block:", receipt.blockNumber);

        // Example: Call a read-only function (does not require gas, no transaction)
        const result = await myContract.someViewFunction();
        console.log("View function result:", result);

    } catch (error) {
        console.error("Smart contract interaction error:", error);
    }
}

// interactWithSmartContract();

// This is a conceptual example, actual DFNS SDK usage may vary.
import { DfnsApiClient, AsymmetricKeys, SignatureMechanism, SignTransactionRequest } from '@dfns/sdk';

const DFNS_API_URL = "https://api.dfns.io";
const DFNS_APP_ID = "YOUR_DFNS_APP_ID";
const DFNS_AUTH_TOKEN = "YOUR_DFNS_AUTH_TOKEN"; // Generated from a private key & secret

async function signTransactionWithDFNS(walletId: string, chainId: string, transactionPayload: any) {
    try {
        const dfnsClient = new DfnsApiClient({
            baseUrl: DFNS_API_URL,
            appId: DFNS_APP_ID,
            authToken: DFNS_AUTH_TOKEN, // Or use a signing key provider
            authMethod: new AsymmetricKeys({
                 // This would involve loading private keys securely in a real app
                privateKey: "...", 
                signingKeyId: "...",
            })
        });

        const signRequest: SignTransactionRequest = {
            walletId: walletId,
            chainId: chainId,
            payload: JSON.stringify(transactionPayload),
            signatureMechanism: SignatureMechanism.JsonRpc,
            transactionType: "EvmTransaction", // or other types
        };

        const response = await dfnsClient.wallet.signTransaction(signRequest);
        console.log("DFNS Signed Transaction:", response.signedData);
        return response.signedData; // Contains the raw signed transaction to broadcast
    } catch (error) {
        console.error("DFNS signing error:", error);
        throw error;
    }
}

// Example usage:
// const signedTx = await signTransactionWithDFNS(
//     "some-dfns-wallet-uuid",
//     "eip155:11155111", // Sepolia chain ID
//     {
//         to: "0x...",
//         value: "0",
//         gasLimit: "21000",
//         data: "0x..."
//     }
// );
// // Then broadcast signedTx to the blockchain