Volla Punks

22 Nov 2025

      Dear Volla,

Actually I am interested in a product called Volla Phone Quintus and a coincidence I am the youngest former Cryptographer, Alshen Feshiru is just a Pseudonym name, but actually I am creating Software for anyone will get complete privacy, IP Location will be Pseudonymous and some intended Devices will get the Internet that no longer requires a centralized provider,  As long as the electricity is scattered in the Oscillator moving upwards called Upward, it will defeat all attackers. Or it is possible for us to produce a new Smartphone from Volla, For example, with the name Volla Punks , you can also contact me this email or have a further conversation on the Cypherpunks mailing list, I am used to and almost always have conversations there if needed such as Cryptography consultations, Lithography and everything related to Decentralized privacy.

I only help the Cryptography part either in mathematical calculations or modifications that are completely Decentralized, Anti-Bias Optoelectronics and coding decisions or something like that can be decided by your Production Team, I just give a map, I have a standalone Cryptography which is SAI-288 with Multi Languages, Anyone can Implement this with the JAVA Main Language but the other languages are C++ and Rust and Python and Swift, You can modify other Multi Languages to suit your needs but it would be better, the control is not on the Team or Vendor, 

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.Arrays;

public class SAI288 {

    private static final int ROUNDS = 64;

    private static final int STATE_SIZE = 9;

    private static final int BLOCK_SIZE = 72;

    private static final int OUTPUT_SIZE = 36;

    private static final int[] IV = {

        0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,

        0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6

    };

    private int[] state = new int[STATE_SIZE];

    private byte[] buffer = new byte[BLOCK_SIZE];

    private byte[] midliner = new byte[BLOCK_SIZE];

    private int bufferPos = 0;

    private long totalBytes = 0;

    public SAI288() {

        reset();

    }

    public void reset() {

        System.arraycopy(IV, 0, state, 0, STATE_SIZE);

        Arrays.fill(buffer, (byte) 0);

        Arrays.fill(midliner, (byte) 0);

        bufferPos = 0;

        totalBytes = 0;

    }

    private void processMidliner(byte[] data) {

        for (int i = 0; i < data.length && i < BLOCK_SIZE; i++) {

            midliner[i] ^= data[i];

        }

    }

    public void update(byte[] data) {

        update(data, 0, data.length);

    }

    public void update(byte[] data, int offset, int length) {

        processMidliner(Arrays.copyOfRange(data, offset, offset + Math.min(length, BLOCK_SIZE)));

        totalBytes += length;

        int remaining = length;

        int dataPos = offset;

        while (remaining > 0) {

            int toCopy = Math.min(remaining, BLOCK_SIZE - bufferPos);

            System.arraycopy(data, dataPos, buffer, bufferPos, toCopy);

            bufferPos += toCopy;

            dataPos += toCopy;

            remaining -= toCopy;

            if (bufferPos == BLOCK_SIZE) {

                processBlock(buffer);

                bufferPos = 0;

            }

        }

    }

    private void processBlock(byte[] block) {

        int[] m = new int[18];

        ByteBuffer bb = ByteBuffer.wrap(block).order(ByteOrder.LITTLE_ENDIAN);

        for (int i = 0; i < 18 && bb.hasRemaining(); i++) {

            m[i] = bb.remaining() >= 4 ? bb.getInt() : 0;

        }

        for (int round = 0; round < ROUNDS; round++) {

            for (int i = 0; i < STATE_SIZE; i++) {

                state[i] ^= m[i % 18];

                state[i] = Integer.rotateLeft(state[i], (round + i) % 32);

                if (i > 0) {

                    state[i] += state[i - 1];

                }

            }

            for (int i = 0; i < 18; i++) {

                m[i] = Integer.rotateRight(m[i] ^ state[i % STATE_SIZE], 7);

            }

        }

    }

    public byte[] digest() {

        byte[] padded = new byte[BLOCK_SIZE];

        System.arraycopy(buffer, 0, padded, 0, bufferPos);

        padded[bufferPos] = (byte) 0x80;

        ByteBuffer bb = ByteBuffer.wrap(padded, BLOCK_SIZE - 8, 8).order(ByteOrder.LITTLE_ENDIAN);

        bb.putLong(totalBytes * 8);

        processBlock(padded);

        processBlock(midliner);

        ByteBuffer output = ByteBuffer.allocate(OUTPUT_SIZE).order(ByteOrder.LITTLE_ENDIAN);

        for (int i = 0; i < STATE_SIZE; i++) {

            output.putInt(state[i]);

        }

        byte[] result = new byte[OUTPUT_SIZE];

        output.flip();

        output.get(result);

        reset();

        return result;

    }

    public static byte[] hash(byte[] data) {

        SAI288 hasher = new SAI288();

        hasher.update(data);

        return hasher.digest();

    }

    public static native byte[] hashNative(byte[] data);

}

Or the latest SAI-288 Cryptography

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

public class SAI288 {

    private static final int[] IV = {

        0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,

        0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6

    };

    private static final byte[] شمائل = {

        (byte)0xD8, (byte)0xB4,

        (byte)0xD9, (byte)0x85,

        (byte)0xD8, (byte)0xA7,

        (byte)0xD8, (byte)0xA6,

        (byte)0xD9, (byte)0x84

    };

    public static byte[] hash(byte[] input) {

        int[] state = new int[9];

        System.arraycopy(IV, 0, state, 0, 9);

        byte[] padded = pad(input);

        for (int i = 0; i < padded.length; i += 72) {

            byte[] block = new byte[72];

            System.arraycopy(padded, i, block, 0, Math.min(72, padded.length - i));

            processBlock(state, block);

        }

        return stateToBytes(state);

    }

    private static void processBlock(int[] state, byte[] block) {

        int[] M = new int[18];

        ByteBuffer bb = ByteBuffer.wrap(block);

        for (int i = 0; i < 18 && bb.hasRemaining(); i++) {

            M[i] = bb.hasRemaining() ? bb.getInt() : 0;

        }

        for (int round = 0; round < 64; round++) {

            for (int i = 0; i < 9; i++) {

                state[i] ^= M[round % 18];

                state[i] = Integer.rotateLeft(state[i], (round + i) % 32);

                state[i] ^= شمائل[i % شمائل.length];

            }

        }

    }

    private static byte[] pad(byte[] input) {

        int blockSize = 72;

        int paddedLength = ((input.length + blockSize - 1) / blockSize) * blockSize;

        byte[] padded = new byte[paddedLength];

        System.arraycopy(input, 0, padded, 0, input.length);

        padded[input.length] = (byte)0x80;

        return padded;

    }

    private static byte[] stateToBytes(int[] state) {

        ByteBuffer bb = ByteBuffer.allocate(36);

        for (int s : state) {

            bb.putInt(s);

        }

        return bb.array();

    }

}

Or if with CAT EOF, cat > src/main/java/org/syamailcoin/crypto/sai288/SAI288.java << 'EOF'

package org.syamailcoin.crypto.sai288;

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

public class SAI288 {

    private static final int[] IV = {

        0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,

        0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6

    };

    private static final byte[] شمائل = {

        (byte)0xD8, (byte)0xB4,

        (byte)0xD9, (byte)0x85,

        (byte)0xD8, (byte)0xA7,

        (byte)0xD8, (byte)0xA6,

        (byte)0xD9, (byte)0x84

    };

    public static byte[] hash(byte[] input) {

        int[] state = new int[9];

        System.arraycopy(IV, 0, state, 0, 9);

        byte[] padded = pad(input);

        for (int i = 0; i < padded.length; i += 72) {

            byte[] block = new byte[72];

            System.arraycopy(padded, i, block, 0, Math.min(72, padded.length - i));

            processBlock(state, block);

        }

        return stateToBytes(state);

    }

    private static void processBlock(int[] state, byte[] block) {

        int[] M = new int[18];

        ByteBuffer bb = ByteBuffer.wrap(block);

        for (int i = 0; i < 18 && bb.hasRemaining(); i++) {

            M[i] = bb.hasRemaining() ? bb.getInt() : 0;

        }

        for (int round = 0; round < 64; round++) {

            for (int i = 0; i < 9; i++) {

                state[i] ^= M[round % 18];

                state[i] = Integer.rotateLeft(state[i], (round + i) % 32);

                state[i] ^= شمائل[i % شمائل.length];

            }

        }

    }

    private static byte[] pad(byte[] input) {

        int blockSize = 72;

        int paddedLength = ((input.length + blockSize - 1) / blockSize) * blockSize;

        byte[] padded = new byte[paddedLength];

        System.arraycopy(input, 0, padded, 0, input.length);

        padded[input.length] = (byte)0x80;

        return padded;

    }

    private static byte[] stateToBytes(int[] state) {

        ByteBuffer bb = ByteBuffer.allocate(36);

        for (int s : state) {

            bb.putInt(s);

        }

        return bb.array();

    }

}

EOF

At first the cryptography was designed for Syamailcoin which is the coin that I am creating, you can verify it first or see it in the X post on Alshen Feshiru's account. 9469999.9999999428 Max Supply and reward distribution using the Inevitability Stage i.e. we cannot get rewards beyond the limited number of Stages unless the current Stage has been completed, Read first about the abstract of Syamailcoin. Syamailcoin prevents natural falsehood—corruption from system limits.

When bits flip, valid state becomes indistinguishable from corrupted

state. Provide self-verification: state accumulation with exponomial growth

and harmonic decay, 288-bit , factorial consensus, and balanced bit.

System tolerates 14.47% Byzantine faults across four time-decreasing

stages.

Focusing on the main topic, I just want to propose to jointly produce a new Smartphone with the concept of Decentralization instead of Semi decentralized or Semi Central, this problem occurs only in the LITTLE ENDIAN section, what I only help is that SAI-288 Cryptography is implemented there but with the concept of BIG ENDIAN and ROTR, it is enough that it is completely That this latest smartphone will be safe but you need to verify or test my Cryptography because it is open.

Volla Punks -> Any Cryptography is implemented and one of them is SAI-288 -> Customize it to your desired Programming language -> Modification of SAI-288 to BIG ENDIAN, ROTR -> Charging Speed is enough 21W = I hope that as much as possible the initial selling price is not too expensive so that I can order this even though we are different countries, I fully support this as it should be.

-----BEGIN PGP PUBLIC KEY BLOCK-----

Comment: User ID: Alshen Feshiru <alshenfeshiru@zohomail.com>

Comment: Valid from: 06/10/2025 09:35

Comment: Valid until: 02/04/2033 12:00

Comment: Type: 448-bit EdDSA (secret key available)

Comment: Usage: Signing, Encryption, Certifying User IDs

Comment: Fingerprint: 5871D671C35C12147308395A464505DE1047DA134C01C8EBF8D18D6B8CBD7763

mEkFaOMrBhYAAAA/AytlcQHHbHV7SgCdlZnHrIjtxAfcYYzs9R5GGNK46dlgzFzR

B+1X8BPoMimXLemj9yoBK+lfLO7OaTZ9klqAtCtBbHNoZW4gRmVzaGlydSA8YWxz

aGVuZmVzaGlydUB6b2hvbWFpbC5jb20+iM0FExYKAE0iIQVYcdZxw1wSFHMIOVpG

RQXeEEfaE0wByOv40Y1rjL13YwUCaOMrBgIbAwUJDhXYSgULCQgHAgIiAgYVCgkI

CwIEFgIDAQIeBwIXgAAApU0Bx3DEN60mahYzDrGcFnvmZ/5UaBBQTnLoSfPwG8Hz

fYt/pLE+S/yMOrbDdUrg6LG0t33bh7Pu4BxjAAHGIAca1udLBqQZ6mYwpBI6Z2S0

XVIx+glBORH6ynYgZGBZOTBarTts7UctN7D0pbBE+J4Y7w9ooDEAuEwFaOMrBhIA

AABCAytlbwG/civ41G/UgMeMBiRTScXvU83nUgSPz4fma7iCz5ZVfUUP9wBuxVxd

n7gODEf7mnjE8Vt8XHgOZ6kDAQoJiLIFGBYKADIiIQVYcdZxw1wSFHMIOVpGRQXe

EEfaE0wByOv40Y1rjL13YwUCaOMrBgIbDAUJDhXYSgAAzGAByPZFSr2g/J57qB4r

3ISgR4+mn83R9+R2TZL7s1qnDsqjw+t6B/b28dwlVxSXgXJtAcbW2hDlzORJAAHG

O8MVhPLaPra69/XvhuhZW9vOw4YXydY9aW+63KiNA6iIeZz9HczEOvT6vdWjIj8f

aQN2OLDD/yUA

=Gs+D

-----END PGP PUBLIC KEY BLOCK-----

Warm Regards,
Alshen Feshiru