STRINGLIB¶

Overview¶

STRINGLIB provides string manipulation utilities including palindrome checking, string reversal, acronym validation, and random acronym generation for the gaming/voting system.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: lib/stringlib.sol

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

What This Means For Players¶

Plain English Summary: STRINGLIB powers the word games - it's used for the acronym guessing game where players submit phrases that match random letter combinations. The system generates random acronyms (like "FBI") and players submit phrases ("Federal Bureau of Investigation") that match.

Real-World Analogy: It's like a game of Scrabble meets word association. The system shows you random letters (an acronym), and you have to come up with a clever phrase where each word starts with those letters in order.

How It Affects Your Gameplay: - Acronym game - Submit phrases that match the generated acronym - Validation - STRINGLIB checks if your phrase actually matches the acronym - Random challenges - Each round generates a new random acronym to guess - Palindrome fun - Can check if strings are palindromes (reads same forwards and backwards)

State Variables¶

Variable	Type	Visibility	Mutability	Initial Value	NatSpec
`Type`	`string`	public	constant	`LibStrings`

Errors¶

Error	Parameters	NatSpec
`MinimumLength3`	(none)

Constructor¶

constructor¶

constructor(address VoidAddress) DYSNOMIA(unicode"DYSNOMIA LibStrings", unicode"LibStrings", address(DYSNOMIA(VoidAddress).Xiao()))

Modifiers: DYSNOMIA(unicode"DYSNOMIA LibStrings", unicode"LibStrings", address(DYSNOMIA(VoidAddress).Xiao()))
Parameters: address VoidAddress

Functions¶

External & Public¶

CheckPalindrome¶

function CheckPalindrome(string memory S) public pure returns (bool)

Visibility: public
State Mutability: pure
Parameters: string memory S
Returns: bool

CheckPalindrome¶

function CheckPalindrome(bytes memory S) public pure returns (bool)

Visibility: public
State Mutability: pure
Parameters: bytes memory S
Returns: bool

Reverse¶

function Reverse(string memory S) public pure returns (string memory Reversed)

Visibility: public
State Mutability: pure
Parameters: string memory S
Returns: string memory Reversed

Reverse¶

function Reverse(bytes memory S) public pure returns (bytes memory Reversed)

Visibility: public
State Mutability: pure
Parameters: bytes memory S
Returns: bytes memory Reversed

RandomAcronym¶

function RandomAcronym(uint8 MaxLength) public returns (bytes memory Acronym)

Visibility: public
Parameters: uint8 MaxLength
Returns: bytes memory Acronym

CaseInsensitiveCompare¶

function CaseInsensitiveCompare(bytes1 A, bytes1 B) public pure returns (bool)

Visibility: public
State Mutability: pure
Parameters: bytes1 A, bytes1 B
Returns: bool

CheckAcronym¶

function CheckAcronym(string memory _A, string memory _B) public pure returns (bool)

Visibility: public
State Mutability: pure
Parameters: string memory _A, string memory _B
Returns: bool

CheckAcronym¶

function CheckAcronym(bytes memory _acronym, string memory _Beta) public pure returns (bool)

Visibility: public
State Mutability: pure
Parameters: bytes memory _acronym, string memory _Beta
Returns: bool

log10¶

function log10(uint256 value) public pure returns (uint256)

Visibility: public
State Mutability: pure
Parameters: uint256 value
Returns: uint256

String¶

function String(uint256 value) public pure returns (string memory buffer)

Visibility: public
State Mutability: pure
Parameters: uint256 value
Returns: string memory buffer

Hex¶

function Hex(address account) public pure returns (string memory)

Visibility: public
State Mutability: pure
Parameters: address account
Returns: string memory

Hex¶

function Hex(uint256 value) public pure returns (string memory)

Visibility: public
State Mutability: pure
Parameters: uint256 value
Returns: string memory

Hex¶

function Hex(bytes32 value) public pure returns (string memory)

Visibility: public
State Mutability: pure
Parameters: bytes32 value
Returns: string memory

Hex¶

function Hex(bytes memory data) public pure returns (string memory)

Visibility: public
State Mutability: pure
Parameters: bytes memory data
Returns: string memory

Inherited Members¶

This contract inherits the members below from its parents. See each parent's dedicated MD for full signatures, NatSpec, and semantics.

From DYSNOMIA¶

External & Public Functions

Function	Signature	State Mutability
`Rename`	`function Rename(string memory newName, string memory newSymbol) public virtual onlyOwners`	nonpayable
`mintToCap`	`function mintToCap() public onlyOwners`	nonpayable
`GetMarketRate`	`function GetMarketRate(address _a) public view returns (uint256)`	view
`Purchase`	`function Purchase(address _t, uint256 _a) public`	nonpayable
`Redeem`	`function Redeem(address _t, uint256 _a) public`	nonpayable
`name`	`function name() public view virtual returns (string memory)`	view
`symbol`	`function symbol() public view virtual returns (string memory)`	view
`decimals`	`function decimals() public view virtual returns (uint8)`	view
`totalSupply`	`function totalSupply() public view virtual returns (uint256)`	view
`balanceOf`	`function balanceOf(address account) public view virtual returns (uint256)`	view
`transfer`	`function transfer(address to, uint256 value) public virtual returns (bool)`	nonpayable
`allowance`	`function allowance(address owner, address spender) public view virtual returns (uint256)`	view
`approve`	`function approve(address spender, uint256 value) public virtual returns (bool)`	nonpayable
`transferFrom`	`function transferFrom(address from, address to, uint256 value) public virtual returns (bool)`	nonpayable

Internal Functions

Function	Signature
`_addLibraryOwner`	`function _addLibraryOwner(VOID Void, string memory what) internal`
`_mintToCap`	`function _mintToCap() internal`
`_addMarketRate`	`function _addMarketRate(address _a, uint256 _r) internal`
`_transfer`	`function _transfer(address from, address to, uint256 value) internal`
`_update`	`function _update(address from, address to, uint256 value) internal virtual`
`_mint`	`function _mint(address account, uint256 value) internal`
`_approve`	`function _approve(address owner, address spender, uint256 value) internal`
`_spendAllowance`	`function _spendAllowance(address owner, address spender, uint256 value) internal virtual`

Events

Event	Parameters
`Transfer`	address indexed from, address indexed to, uint256 value
`Approval`	address indexed owner, address indexed spender, uint256 value

Errors

Error	Parameters
`MarketRateNotFound`	address asset
`DysnomiaInsufficientBalance`	address origin, address sender, address from, address to, address what, uint256 balance, uint256 needed
`DysnomiaInsufficientAllowance`	address origin, address sender, address owner, address spender, address what, uint256 allowance, uint256 needed

State Variables (private parent storage is not reachable and is omitted)

Variable	Type	Visibility	Mutability
`__name`	`string`	internal	mutable
`__symbol`	`string`	internal	mutable
`MotzkinPrime`	`uint64`	public	constant
`Xiao`	`atropaMath`	public	mutable
`maxSupply`	`uint256`	public	mutable

From MultiOwnable¶

External & Public Functions

Function	Signature	State Mutability
`owner`	`function owner() external view virtual returns (address)`	view
`renounceOwnership`	`function renounceOwnership(address toRemove) public virtual onlyOwners`	nonpayable
`addOwner`	`function addOwner(address newOwner) public virtual onlyOwners`	nonpayable

Internal Functions

Function	Signature
`_checkOwner`	`function _checkOwner() internal view virtual`
`_changeOwnership`	`function _changeOwnership(address cOwner, bool cState) internal virtual`

Events

Event	Parameters
`OwnershipUpdate`	address indexed newOwner, bool indexed state

Errors

Error	Parameters
`OwnableUnauthorizedAccount`	address origin, address account, address what
`OwnableInvalidOwner`	address origin, address owner, address what

Modifiers

Modifier	Parameters
`onlyOwners`	(none)

Read Functions (Pure)¶

CheckPalindrome¶

function CheckPalindrome(string memory S) public pure returns (bool)
function CheckPalindrome(bytes memory S) public pure returns (bool)

- Access: public pure - Parameters: - S (string or bytes): Input to check - Returns: - bool: True if input reads the same forwards and backwards - Description: Compares characters from both ends moving inward. - Logic Flow: 1. Create reversed copy of input 2. Compare each position: if any mismatch, return false 3. Return true if all match - In Plain English: Check if a word or phrase is a palindrome (reads the same forwards and backwards, like "racecar" or "kayak").

Reverse¶

function Reverse(string memory S) public pure returns (string memory)
function Reverse(bytes memory S) public pure returns (bytes memory)

- Access: public pure - Parameters: - S (string or bytes): Input to reverse - Returns: - Reversed version of input - Description: Creates a new array and populates it backwards. - Logic Flow: 1. Allocate new bytes array of same length 2. Iterate source backwards (j from length-1 to 0) 3. Assign to output (i from 0 to length-1) - In Plain English: Flip a string backwards. "hello" becomes "olleh".

CaseInsensitiveCompare¶

function CaseInsensitiveCompare(bytes1 A, bytes1 B) public pure returns (bool)

- Access: public pure - Parameters: - A (bytes1): First character - B (bytes1): Second character - Returns: - bool: True if characters match ignoring case - Description: Uses ASCII offset (32) to compare uppercase/lowercase equivalents. - Computation Details: - ASCII uppercase: 65-90, lowercase: 97-122 - Difference between cases: 32 - Checks: A == B or A == B ± 32 - In Plain English: Compare two letters ignoring case. 'A' matches 'a', 'B' matches 'b', etc.

CheckAcronym¶

function CheckAcronym(string memory _A, string memory _B) public pure returns (bool)
function CheckAcronym(bytes memory _acronym, string memory _Beta) public pure returns (bool)

- Access: public pure - Parameters: - _A / _acronym (string or bytes): The acronym to validate (e.g., "FBI") - _B / _Beta (string): The phrase to check against (e.g., "Federal Bureau of Investigation") - Returns: - bool: True if phrase's first letters spell the acronym - Description: Validates that each word's first letter matches the next acronym letter. - Logic Flow: 1. Compare first character of phrase to first acronym letter (case-insensitive) 2. For each space in phrase, next letter must match next acronym letter 3. Return true only if all acronym letters are matched - In Plain English: Check if a phrase matches an acronym. "Federal Bureau of Investigation" matches "FBI" because each word starts with F, B, I in order.

log10¶

function log10(uint256 value) public pure returns (uint256)

- Access: public pure - Parameters: - value (uint256): Number to compute log of - Returns: - uint256: Floor of log base 10 (number of digits minus 1) - Description: Uses iterative halving to compute logarithm efficiently. - Logic Flow: 1. Start with exponent = 64, halve each iteration 2. If value >= 10^exponent, divide value and accumulate exponent 3. Return final accumulated exponent - In Plain English: Count how many digits a number has, minus one. log10(1000) = 3.

String¶

function String(uint256 value) public pure returns (string memory buffer)

- Access: public pure - Parameters: - value (uint256): Number to convert - Returns: - buffer (string): Decimal string representation - Description: Converts integer to string by extracting digits. - Logic Flow: 1. Calculate length via log10 + 1 2. Allocate buffer 3. Use assembly to populate backwards: modulo 10 gives digit, divide by 10 shifts - In Plain English: Convert a number to text. 12345 becomes "12345".

Hex (multiple overloads)¶

function Hex(address account) public pure returns (string memory)
function Hex(uint256 value) public pure returns (string memory)
function Hex(bytes32 value) public pure returns (string memory)
function Hex(bytes memory data) public pure returns (string memory)

- Access: public pure - Returns: - Hexadecimal string with "0x" prefix - Description: Converts various types to hex by mapping each nibble to "0123456789abcdef". - In Plain English: Convert data to hexadecimal format like "0x1a2b3c...".

Contract Interactions¶

Depends On¶

DYSNOMIA V2 - Base functionality
VOID - Library registration
VMREQ - Random number generation

Registered In¶

VOID library registry as "strings"

Special Mechanisms¶

Acronym Validation Algorithm¶

1. Check first letter matches (case-insensitive)
2. For each space in phrase:
   - Next letter after space must match next acronym letter
3. All acronym letters must be matched exactly

Example: - Acronym: "FBI" - Valid: "Federal Bureau of Investigation" ✓ - Invalid: "Fabulous Blue Ice" ✗ (wrong structure)

Case-Insensitive Comparison¶

Uses ASCII math to compare:

if(uint8(B) <= 90)  // B is uppercase
    return(A == B || uint8(A) == (uint8(B) + 32));  // A matches B or lowercase B
else
    return(A == B || (uint8(A) + 32) == uint8(B)); // A matches B or uppercase B

Random Acronym Generation¶

Generate random length (3 to MaxLength)
For each position:
Generate random number 0-25
Map to letter A-Z

Usage Pattern¶

// Check palindrome
bool isPalindrome = stringLib.CheckPalindrome("racecar"); // true

// Validate acronym
bool valid = stringLib.CheckAcronym("LOL", "Laugh Out Loud"); // true

// Generate random acronym
bytes memory acronym = stringLib.RandomAcronym(5); // e.g., "ABXZ"

// Convert to string/hex
string memory numStr = stringLib.String(12345); // "12345"
string memory addrHex = stringLib.Hex(someAddress); // "0x1234..."

Gaming Integration¶

The acronym functions support a game mechanic where: 1. System generates random acronym (e.g., "ABC") 2. Users submit phrases ("A Big Cat") 3. System validates submissions using CheckAcronym 4. Valid submissions can earn rewards

Contract Verification¶

Property	Value
Keccak256 Hash	`0x0e5bf088357a8b8d0cce341a0633531380290525c279d3fcb9fd6b2ed7560c1e`
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/main/solidity/dysnomia/lib/stringlib.sol
Hash Generated	2026-04-17T20:48:17Z