NodeJS

import { Omnid } from "@omnid/sdk";
let omnid = new Omnid();

let relayResponse = await omnid.auth.relayLoginProof(
  [
    proof.a[0],
    proof.a[1],
    proof.b[0][1],
    proof.b[0][0],
    proof.b[1][1],
    proof.b[1][0],
    proof.c[0],
    proof.c[1],
  ],
  publicSignals
);

relayLoginProof = async (
  proof: Array<string>,
  publicSignals: Array<string>,
  relayEndpoint: string = "https://alchemy.omnid.io/relay/login",
): Promise<RelayResponse>

let body = await req.json() as Omit<TokenExchangeRequest, 'appSecretKey'>;
let omnid = new Omnid();
 
const respData = await omnid.auth.exchangeForJwt({
    ...body,
    appSecretKey: process.env['OMNID_SIGNIN_SECRET_KEY'] as string
});

exchangeForJwt = async (
  details: TokenExchangeRequest,
  vaultEndpoint: string = "https://vault.omnid.io",
): Promise<TokenExchangeResponse>

const sig = omnid.fc.getCircuitFiles('VerifySignature10');
const { downloaded, downloadProgress, makeProof } = useProof(sig);

getCircuitFiles = (
  proofId: supportedProofIds,
  cdn = ''
): circuitFileDetails

const { proof, publicSignals } = await makeProof('rsa', []);

makeProof = async (
  proofId: supportedProofIds,
  inputs: CircuitSignals,
  node: string = `https://fc.omnid.io`
): Promise<FunctionCloudProofResponse>

const res = await relayProof('11', []);

relayProof = async (
  groupId: number,
  proofData: ProofData,
  relayEndpoint: string = "https://alchemy.omnid.io/relay/login",
): Promise<RelayResponse>

let data = await fromToken('0x00', 'eth', 'APIKEY');

fromToken = async (
  token: string,
  chainName: string,
  COVALENT_APIKEY: string
): Promise<Array<TokenHolder>>

let data = await fromSnapshot(
  'aave.eth',
  '0xe03ecf69d92f04d39d1385ccc87d8782347471a7305897e85b3d5d04f26a522d',
);

fromSnapshot = async (
  space: string,
  proposal: string | null = null,
  first: number = 1000,
  skip: number = 0
): Promise<SnapshotVote[]>

let data = await fromEas(
  '0xe03ecf69d92f04d39d1385ccc87d8782347471a7305897e85b3d5d04f26a522d',
  '0x385ccc87d8782347471a7305897e85b3d5d04f26a522'
  1
);

fromEas = async (
  schemaId: string,
  attestor: string,
  chainId: 1 | 10 | 8453 | 42161 | 59144 | 11155111 | 11155420 | 534351
): Promise<EasAttestation[]>

let ids = await getGroupIds();

async getGroupIds(): Promise<string[]>

let groups = await getGroups();

async getGroups(options: {
  members?: boolean;
  validatedProofs?: boolean;
  filters?: {
    admin?: string;
    identityCommitment?: string;
    timestamp?: Date;
    timestampGte?: Date;
    timestampLte?: Date;
  };
}): Promise<{
  id: string;
  merkleTree: {
    root: string;
    depth: number;
    size: number;
  };
  admin?: string;
  members?: Array<{
    id: number;
    timestamp: number;
    identityCommitment: number;
    index: number;
  }>;
  validatedProofs?: {
    message: string;
    merkleTreeRoot: string;
    merkleTreeDepth: number;
    scope: string;
    nullifier: string;
    points: string[];
    timestamp?: string;
  }[];
}[]>

let group = await getGroup(1);

async getGroup(groupId: string, options: Omit<GroupOptions, "filters"> = {}): Promise<GroupResponse>

let res = await isGroupMember(1, 'commitment');

async isGroupMember(groupId: string, member: string): Promise<boolean>

makeTree(hashedValues: Array<bigint>) {}

getProof(leafHash: bigint): {
    found: boolean;
    path: bigint[];
    pathInd: number[];
}: { found: true, path, pathInd }

getCalldata(proof: {
    path: bigint[];
    pathInd: number[];
}, leafHash: bigint) {
    return JSON.stringify({
        leaf: this.bigint2hex(leafHash),
        path_elements: proof.path.map(this.bigint2hex),
        path_indices: proof.pathInd
    })
}

let root = getRootHash()