@dorafactory/maci-sdk 0.1.3-pre.21 → 0.1.3-pre.23

package/src/types/index.ts

@@ -6,18 +6,18 @@ export type * from '../libs/crypto/types';
 
 export enum MaciCircuitType {
   IP1V = '0',
-  QV = '1',
+  QV = '1'
 }
 
 export enum MaciCertSystemType {
   GROTH16 = 'groth16',
-  PLONK = 'plonk',
+  PLONK = 'plonk'
 }
 
 export enum MaciRoundType {
   MACI = '0',
   AMACI = '1',
-  ORACLE_MACI = '2',
+  ORACLE_MACI = '2'
 }
 
 export type CertificateEcosystem = 'cosmoshub' | 'doravota';
@@ -27,7 +27,9 @@ export type ClientParams = {
   network: 'mainnet' | 'testnet';
   rpcEndpoint?: string;
   restEndpoint?: string;
-  apiEndpoint?: string;
+  apiEndpoint?: string; // Indexer GraphQL API endpoint
+  saasApiEndpoint?: string; // MACI SaaS API endpoint
+  saasApiKey?: string; // MACI SaaS API key
   certificateApiEndpoint?: string;
   registryAddress?: string;
   saasAddress?: string;
@@ -474,3 +476,27 @@ export type DeactivateMessage = {
   maciContractAddress: string;
   maciOperator: string;
 };
+
+export type AccountMangerParams = {
+  mnemonic?: string;
+  secretKey?: string | bigint;
+};
+
+export type DerivePathParams = {
+  accountIndex?: number;
+  isExternal?: boolean;
+  addressIndex?: number;
+};
+
+export type VoterClientParams = {
+  network: 'mainnet' | 'testnet';
+  mnemonic?: string;
+  secretKey?: string | bigint;
+  registryAddress?: string;
+  apiEndpoint?: string; // Indexer GraphQL API endpoint
+  restEndpoint?: string; // DoraVota REST API endpoint
+  saasApiEndpoint?: string; // MACI SaaS API endpoint
+  saasApiKey?: string; // MACI SaaS API key
+  customFetch?: typeof fetch;
+  defaultOptions?: FetchOptions;
+};

package/src/types/lib.d.ts

@@ -0,0 +1,7 @@
+declare module 'ffjavascript' {
+	export const utils: any;
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	export const Scalar: any;
+	export const buildBn128: any;
+	export const buildBls12381: any;
+}

package/src/utils/base64.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Dorafactory, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export function fromBase64(base64String: string): Uint8Array {
+	return Uint8Array.from(atob(base64String), char => char.charCodeAt(0));
+}
+
+const CHUNK_SIZE = 8192;
+export function toBase64(bytes: Uint8Array): string {
+	// Special-case the simple case for speed's sake.
+	if (bytes.length < CHUNK_SIZE) {
+		return btoa(String.fromCharCode(...bytes));
+	}
+
+	let output = '';
+	for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+		const chunk = bytes.slice(i, i + CHUNK_SIZE);
+		output += String.fromCharCode(...chunk);
+	}
+
+	return btoa(output);
+}
+
+/** @deprecated use toBase64 instead */
+export const toB64 = toBase64;
+
+/** @deprecated use fromBase64 instead */
+export const fromB64 = fromBase64;

package/src/utils/bech32.ts

@@ -0,0 +1,29 @@
+import { bech32 } from 'bech32';
+
+function verifyIsBech32(address: string): Error | undefined {
+  try {
+    bech32.decode(address);
+  } catch (error) {
+    return error instanceof Error ? error : new Error('Unknown error');
+  }
+
+  return undefined;
+}
+
+export function isValidBech32Address(address: string, prefix: string): boolean {
+  // An address is valid if it starts with `dora` and is Bech32 format.
+  return address.startsWith(prefix) && verifyIsBech32(address) === undefined;
+}
+
+export function convertBech32Prefix(
+  address: string,
+  newPrefix: string
+): string {
+  // Decode the original address
+  const decoded = bech32.decode(address);
+
+  // Encode the address with the new prefix
+  const newAddress = bech32.encode(newPrefix, decoded.words);
+
+  return newAddress;
+}

package/src/utils/decode-address.ts

@@ -0,0 +1,35 @@
+import { sha256 } from '@noble/hashes/sha256';
+
+/**
+ * Convert a contract address to Uint256 format.
+ * This replicates the exact logic from the Rust code:
+ * Use SHA256 hash + reverse bytes order.
+ */
+export function addressToUint256(address: string): bigint {
+	// Convert address string to bytes
+	const addressBytes = new TextEncoder().encode(address);
+
+	// Use SHA256 hash to convert the address to a fixed-length 32-byte format
+	const hashResult = sha256(addressBytes);
+
+	// Convert bytes to Uint256 (big-endian) with reversal like Rust code
+	const uint256Bytes = new Uint8Array(32);
+	for (let i = 0; i < hashResult.length && i < 32; i++) {
+		uint256Bytes[31 - i] = hashResult[i]; // Reverse for little-endian to big-endian conversion
+	}
+
+	// Convert bytes to Uint256 (big-endian)
+	let result = 0n;
+	for (let i = 0; i < uint256Bytes.length; i++) {
+		result = (result << 8n) + BigInt(uint256Bytes[i]);
+	}
+
+	return result;
+}
+
+/**
+ * Convert bigint to hex string.
+ */
+export function bigintToHex(value: bigint): string {
+	return '0x' + value.toString(16).padStart(64, '0');
+}

package/src/utils/fetch.ts

@@ -0,0 +1,28 @@
+export async function fetchApi<T>(url: string, retryCount = 3): Promise<T> {
+	let lastError: Error | null = null;
+	let result: T | null = null;
+
+	for (let attempt = 0; attempt < retryCount; attempt++) {
+		try {
+			const response = await fetch(url);
+			if (!response.ok) {
+				throw new Error(`HTTP error! status: ${response.status}`);
+			}
+
+			result = (await response.json()) as T;
+			break;
+		} catch (error) {
+			lastError = error as Error;
+
+			if (attempt === retryCount - 1) {
+				throw lastError;
+			}
+
+			await new Promise(resolve =>
+				setTimeout(resolve, Math.pow(2, attempt) * 1000)
+			);
+		}
+	}
+
+	return result as T;
+}

package/src/utils/hex.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Dorafactory, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export function fromHex(hexStr: string): Uint8Array {
+	const normalized = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;
+	const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}}`;
+	const intArr = padded.match(/.{2}/g)?.map(byte => parseInt(byte, 16)) ?? [];
+
+	return Uint8Array.from(intArr);
+}
+
+export function toHex(bytes: Uint8Array): string {
+	return bytes.reduce(
+		(str, byte) => str + byte.toString(16).padStart(2, '0'),
+		''
+	);
+}
+
+/** @deprecated use toHex instead */
+export const toHEX = toHex;
+
+/** @deprecated use fromHex instead */
+export const fromHEX = fromHex;

package/src/utils/index.ts

@@ -1,81 +1,17 @@
-import { decode } from 'bech32';
-import { packPubKey, PubKey } from 'src/libs/crypto';
-
-function verifyIsBech32(address: string): Error | undefined {
-  try {
-    decode(address);
-  } catch (error) {
-    return error instanceof Error ? error : new Error('Unknown error');
-  }
-
-  return undefined;
-}
-
-export function isValidAddress(address: string): boolean {
-  // An address is valid if it starts with `dora` and is Bech32 format.
-  return address.startsWith('dora') && verifyIsBech32(address) === undefined;
-}
-
-/**
- * Converts a hexadecimal string to a decimal string.
- * @param hexString - The hexadecimal string to convert.
- * @returns The decimal string representation of the input.
- */
-export function hexToDecimalString(hexString: string) {
-  const decimalString = BigInt('0x' + hexString).toString(10);
-  return decimalString;
-}
-
-/**
- * Converts a hexadecimal string to a BigInt.
- * @param hexString - The hexadecimal string to convert.
- * @returns The BigInt representation of the input.
+// Copyright (c) Dorafactory, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * BCS implementation {@see https://github.com/diem/bcs } for JavaScript.
+ * Intended to be used for Move applications; supports both NodeJS and browser.
+ *
+ * For more details and examples {@see README.md }.
+ *
+ * @module bcs
+ * @property {BcsReader}
  */
-export function hexToBigInt(hexString: string) {
-  return BigInt('0x' + hexString);
-}
-
-function padWithZerosIfNeeded(inputString: string) {
-  if (inputString.length === 64) {
-    return inputString;
-  } else if (inputString.length < 64) {
-    const zerosToAdd = 64 - inputString.length;
-    const zeroPadding = '0'.repeat(zerosToAdd);
-    return zeroPadding + inputString;
-  }
-  throw new Error('Invalid input string length');
-}
-
-/**
- * Parses a public key string into its x and y coordinates.
- * @param publickKey - The public key string to parse (128 characters long).
- * @returns An object containing the x and y coordinates as decimal strings.
- */
-export function decompressPublicKey(compressedPubkey: string) {
-  const x = compressedPubkey.slice(0, 64);
-  const y = compressedPubkey.slice(64);
-
-  return {
-    x: hexToDecimalString(x),
-    y: hexToDecimalString(y),
-  };
-}
-
-export function compressPublicKey(decompressedPubkey: any[]) {
-  const x = decompressedPubkey[0];
-  const y = decompressedPubkey[1];
-  const compressedPubkey =
-    padWithZerosIfNeeded(x.toString(16)) + padWithZerosIfNeeded(y.toString(16));
-  return compressedPubkey;
-}
-
-export function transformPubkey(oldPubkey: string) {
-  const x = oldPubkey.slice(0, 64);
-  const y = oldPubkey.slice(64);
 
-  const pubkey: PubKey = [hexToBigInt(x), hexToBigInt(y)];
-  console.log(pubkey);
-  console.log([hexToDecimalString(x), hexToDecimalString(y)]);
-  const packedPubkey = packPubKey(pubkey);
-  return packedPubkey;
-}
+export { fromB64, fromBase64, toB64, toBase64 } from './base64';
+export { fromHex, fromHEX, toHex, toHEX } from './hex';
+export { addressToUint256, bigintToHex } from './decode-address';
+export * from './validate-address';

package/src/utils/validate-address.ts

@@ -0,0 +1,82 @@
+import { bech32 } from 'bech32';
+import { packPubKey, PubKey } from 'src/libs/crypto';
+
+function verifyIsBech32(address: string): Error | undefined {
+	try {
+		bech32.decode(address);
+	} catch (error) {
+		return error instanceof Error ? error : new Error('Unknown error');
+	}
+
+	return undefined;
+}
+
+export function isValidAddress(address: string): boolean {
+	// An address is valid if it starts with `dora` and is Bech32 format.
+	return address.startsWith('dora') && verifyIsBech32(address) === undefined;
+}
+
+/**
+ * Converts a hexadecimal string to a decimal string.
+ * @param hexString - The hexadecimal string to convert.
+ * @returns The decimal string representation of the input.
+ */
+export function hexToDecimalString(hexString: string) {
+	const decimalString = BigInt('0x' + hexString).toString(10);
+	return decimalString;
+}
+
+/**
+ * Converts a hexadecimal string to a BigInt.
+ * @param hexString - The hexadecimal string to convert.
+ * @returns The BigInt representation of the input.
+ */
+export function hexToBigInt(hexString: string) {
+	return BigInt('0x' + hexString);
+}
+
+function padWithZerosIfNeeded(inputString: string) {
+	if (inputString.length === 64) {
+		return inputString;
+	} else if (inputString.length < 64) {
+		const zerosToAdd = 64 - inputString.length;
+		const zeroPadding = '0'.repeat(zerosToAdd);
+		return zeroPadding + inputString;
+	}
+	throw new Error('Invalid input string length');
+}
+
+/**
+ * Parses a public key string into its x and y coordinates.
+ * @param publickKey - The public key string to parse (128 characters long).
+ * @returns An object containing the x and y coordinates as decimal strings.
+ */
+export function decompressPublicKey(compressedPubkey: string) {
+	const x = compressedPubkey.slice(0, 64);
+	const y = compressedPubkey.slice(64);
+
+	return {
+		x: hexToDecimalString(x),
+		y: hexToDecimalString(y),
+	};
+}
+
+export function compressPublicKey(decompressedPubkey: any[]) {
+	const x = decompressedPubkey[0];
+	const y = decompressedPubkey[1];
+	const compressedPubkey =
+		padWithZerosIfNeeded(x.toString(16)) +
+		padWithZerosIfNeeded(y.toString(16));
+	return compressedPubkey;
+}
+
+export function transformPubkey(oldPubkey: string) {
+	const x = oldPubkey.slice(0, 64);
+	const y = oldPubkey.slice(64);
+
+	const pubkey: PubKey = [hexToBigInt(x), hexToBigInt(y)];
+	console.log(pubkey);
+	console.log([hexToDecimalString(x), hexToDecimalString(y)]);
+	const packedPubkey = packPubKey(pubkey);
+	return packedPubkey;
+}