aitbc
816e258d4c
Development Artifact Cleanup: ✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location - dev/test-nodes/brother_node/: Moved from root directory for better organization - Contains development configuration, test logs, and test chain data - No impact on production systems - purely development/testing artifact ✅ DEVELOPMENT ARTIFACTS IDENTIFIED: - Chain ID: aitbc-brother-chain (test/development chain) - Ports: 8010 (P2P) and 8011 (RPC) - different from production - Environment: .env file with test configuration - Logs: rpc.log and node.log from development testing session (March 15, 2026) ✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory - brother_node/ moved to dev/test-nodes/brother_node/ - Root directory now contains only production-ready components - Development artifacts properly organized in dev/ subdirectory DIRECTORY STRUCTURE IMPROVEMENT: 📁 dev/test-nodes/: Development and testing node configurations 🏗️ Root Directory: Clean production structure with only essential components 🧪 Development Isolation: Test environments separated from production BENEFITS: ✅ Clean Production Directory: No development artifacts in root ✅ Better Organization: Development nodes grouped in dev/ subdirectory ✅ Clear Separation: Production vs development environments clearly distinguished ✅ Maintainability: Easier to identify and manage development components RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.
123 lines
5.2 KiB
TypeScript
Executable File
123 lines
5.2 KiB
TypeScript
Executable File
export declare function mod(a: bigint, b: bigint): bigint;
|
|
/**
|
|
* Efficiently raise num to power and do modular division.
|
|
* Unsafe in some contexts: uses ladder, so can expose bigint bits.
|
|
* @example
|
|
* pow(2n, 6n, 11n) // 64n % 11n == 9n
|
|
*/
|
|
export declare function pow(num: bigint, power: bigint, modulo: bigint): bigint;
|
|
export declare function pow2(x: bigint, power: bigint, modulo: bigint): bigint;
|
|
export declare function invert(number: bigint, modulo: bigint): bigint;
|
|
/**
|
|
* Tonelli-Shanks square root search algorithm.
|
|
* 1. https://eprint.iacr.org/2012/685.pdf (page 12)
|
|
* 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
|
|
* Will start an infinite loop if field order P is not prime.
|
|
* @param P field order
|
|
* @returns function that takes field Fp (created from P) and number n
|
|
*/
|
|
export declare function tonelliShanks(P: bigint): <T>(Fp: IField<T>, n: T) => T;
|
|
export declare function FpSqrt(P: bigint): <T>(Fp: IField<T>, n: T) => T;
|
|
export declare const isNegativeLE: (num: bigint, modulo: bigint) => boolean;
|
|
export interface IField<T> {
|
|
ORDER: bigint;
|
|
BYTES: number;
|
|
BITS: number;
|
|
MASK: bigint;
|
|
ZERO: T;
|
|
ONE: T;
|
|
create: (num: T) => T;
|
|
isValid: (num: T) => boolean;
|
|
is0: (num: T) => boolean;
|
|
neg(num: T): T;
|
|
inv(num: T): T;
|
|
sqrt(num: T): T;
|
|
sqr(num: T): T;
|
|
eql(lhs: T, rhs: T): boolean;
|
|
add(lhs: T, rhs: T): T;
|
|
sub(lhs: T, rhs: T): T;
|
|
mul(lhs: T, rhs: T | bigint): T;
|
|
pow(lhs: T, power: bigint): T;
|
|
div(lhs: T, rhs: T | bigint): T;
|
|
addN(lhs: T, rhs: T): T;
|
|
subN(lhs: T, rhs: T): T;
|
|
mulN(lhs: T, rhs: T | bigint): T;
|
|
sqrN(num: T): T;
|
|
isOdd?(num: T): boolean;
|
|
pow(lhs: T, power: bigint): T;
|
|
invertBatch: (lst: T[]) => T[];
|
|
toBytes(num: T): Uint8Array;
|
|
fromBytes(bytes: Uint8Array): T;
|
|
cmov(a: T, b: T, c: boolean): T;
|
|
}
|
|
export declare function validateField<T>(field: IField<T>): IField<T>;
|
|
/**
|
|
* Same as `pow` but for Fp: non-constant-time.
|
|
* Unsafe in some contexts: uses ladder, so can expose bigint bits.
|
|
*/
|
|
export declare function FpPow<T>(f: IField<T>, num: T, power: bigint): T;
|
|
/**
|
|
* Efficiently invert an array of Field elements.
|
|
* `inv(0)` will return `undefined` here: make sure to throw an error.
|
|
*/
|
|
export declare function FpInvertBatch<T>(f: IField<T>, nums: T[]): T[];
|
|
export declare function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T;
|
|
export declare function FpIsSquare<T>(f: IField<T>): (x: T) => boolean;
|
|
export declare function nLength(n: bigint, nBitLength?: number): {
|
|
nBitLength: number;
|
|
nByteLength: number;
|
|
};
|
|
type FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;
|
|
/**
|
|
* Initializes a finite field over prime. **Non-primes are not supported.**
|
|
* Do not init in loop: slow. Very fragile: always run a benchmark on a change.
|
|
* Major performance optimizations:
|
|
* * a) denormalized operations like mulN instead of mul
|
|
* * b) same object shape: never add or remove keys
|
|
* * c) Object.freeze
|
|
* @param ORDER prime positive bigint
|
|
* @param bitLen how many bits the field consumes
|
|
* @param isLE (def: false) if encoding / decoding should be in little-endian
|
|
* @param redef optional faster redefinitions of sqrt and other methods
|
|
*/
|
|
export declare function Field(ORDER: bigint, bitLen?: number, isLE?: boolean, redef?: Partial<IField<bigint>>): Readonly<FpField>;
|
|
export declare function FpSqrtOdd<T>(Fp: IField<T>, elm: T): T;
|
|
export declare function FpSqrtEven<T>(Fp: IField<T>, elm: T): T;
|
|
/**
|
|
* "Constant-time" private key generation utility.
|
|
* Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).
|
|
* Which makes it slightly more biased, less secure.
|
|
* @deprecated use mapKeyToField instead
|
|
*/
|
|
export declare function hashToPrivateScalar(hash: string | Uint8Array, groupOrder: bigint, isLE?: boolean): bigint;
|
|
/**
|
|
* Returns total number of bytes consumed by the field element.
|
|
* For example, 32 bytes for usual 256-bit weierstrass curve.
|
|
* @param fieldOrder number of field elements, usually CURVE.n
|
|
* @returns byte length of field
|
|
*/
|
|
export declare function getFieldBytesLength(fieldOrder: bigint): number;
|
|
/**
|
|
* Returns minimal amount of bytes that can be safely reduced
|
|
* by field order.
|
|
* Should be 2^-128 for 128-bit curve such as P256.
|
|
* @param fieldOrder number of field elements, usually CURVE.n
|
|
* @returns byte length of target hash
|
|
*/
|
|
export declare function getMinHashLength(fieldOrder: bigint): number;
|
|
/**
|
|
* "Constant-time" private key generation utility.
|
|
* Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF
|
|
* and convert them into private scalar, with the modulo bias being negligible.
|
|
* Needs at least 48 bytes of input for 32-byte private key.
|
|
* https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/
|
|
* FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final
|
|
* RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5
|
|
* @param hash hash output from SHA3 or a similar function
|
|
* @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)
|
|
* @param isLE interpret hash bytes as LE num
|
|
* @returns valid private scalar
|
|
*/
|
|
export declare function mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE?: boolean): Uint8Array;
|
|
export {};
|
|
//# sourceMappingURL=modular.d.ts.map
|