Poseidon Hashing

// Poseidon: native field arithmetic
component hasher = Poseidon(2);
hasher.inputs[0] <== a;  // Field element
hasher.inputs[1] <== b;  // Field element
signal output <== hasher.out;  // ~250 constraints

// SHA-256: requires bit decomposition + boolean logic
component sha = Sha256(512);
component a2bits = Num2Bits(254);  // ~254 constraints
a2bits.in <== a;
// ... convert to bits, hash, convert back ... (~25K constraints)

        ┌─────────────────┐
Input ──┤ Absorb (XOR)    │
        ├─────────────────┤
        │ Permutation     │  ← Repeated for R rounds
        ├─────────────────┤
Output ←┤ Squeeze         │
        └─────────────────┘

template Poseidon(nInputs) {
    signal input inputs[nInputs];
    signal output out;

    // Implementation uses hardcoded constants and MDS matrices
    // optimized for BN254 field
    
    component mixS[...];  // S-box layers
    component mixM[...];  // MDS mixing layers
    
    // ... circuit logic ...
    
    out <== finalState[0];
}

include "node_modules/circomlib/circuits/poseidon.circom";

component hasher = Poseidon(2);  // 2 inputs
hasher.inputs[0] <== input1;
hasher.inputs[1] <== input2;
signal hash <== hasher.out;

import { poseidon } from 'circomlibjs';

// Hash single value
const hash1 = poseidon([BigInt(12345)]);

// Hash multiple values
const hash2 = poseidon([
  BigInt(value1),
  BigInt(value2),
  BigInt(value3)
]);

// Result is a BigInt (field element)
console.log(hash2.toString());  // "1234567890..."

module sui::poseidon {
    /// Hash a vector of BN254 field elements using Poseidon.
    public fun poseidon_bn254(data: &vector<u256>): u256;
}

import { poseidon as jsHash } from 'circomlibjs';
import { SuiClient } from '@mysten/sui';

// Off-chain (JS)
const inputs = [12345n, 67890n];
const jsResult = jsHash(inputs);

// On-chain (Sui)
const tx = new Transaction();
const result = tx.moveCall({
  target: `${PACKAGE_ID}::test::hash_two`,
  arguments: [
    tx.pure('u256', '12345'),
    tx.pure('u256', '67890')
  ]
});
const suiResult = await client.devInspectTransactionBlock({ ... });

// Should match
assert(jsResult.toString() === suiResult.toString());

// BAD: Ambiguous encoding
const hash1 = poseidon([a, b]);  // 2 inputs
const hash2 = poseidon([c]);     // 1 input

// If a == c and b can be chosen, potential collision risk

// GOOD: Explicit domain separation
const identityCommitment = poseidon([issuer, doc, dob, salt]);  // Always 4
const dobHash = poseidon([year, month, day]);                   // Always 3
const nullifier = poseidon([commitment, key]);                  // Always 2

// Benchmark: Hash 2 field elements
public fun bench_poseidon(): u256 {
    let data = vector[123456789u256, 987654321u256];
    poseidon::poseidon_bn254(&data)  // ~500 gas units
}

import { poseidon } from 'circomlibjs';
import { sha256 } from '@noble/hashes/sha256';
import { performance } from 'perf_hooks';

// Benchmark Poseidon
const start1 = performance.now();
for (let i = 0; i < 10000; i++) {
  poseidon([BigInt(i), BigInt(i + 1)]);
}
const end1 = performance.now();
console.log('Poseidon:', end1 - start1, 'ms');  // ~50ms (0.005ms per hash)

// Benchmark SHA-256
const start2 = performance.now();
for (let i = 0; i < 10000; i++) {
  sha256(new Uint8Array([i, i + 1]));
}
const end2 = performance.now();
console.log('SHA-256:', end2 - start2, 'ms');   // ~100ms (0.01ms per hash)

import { sha256 } from '@noble/hashes/sha256';
import { poseidon } from 'circomlibjs';

// Hash arbitrary bytes with SHA-256
const documentBytes = new TextEncoder().encode(documentNumber);
const sha256Hash = sha256(documentBytes);

// Convert to field element (truncate to 254 bits)
const fieldElement = BigInt('0x' + Buffer.from(sha256Hash).toString('hex')) & ((1n << 254n) - 1n);

// Use in Poseidon circuit
const commitment = poseidon([
  fieldElement,
  otherInputs...
]);

const { expect } = require('chai');
const { wasm: wasm_tester } = require('circom_tester');
const { poseidon } = require('circomlibjs');

describe('Poseidon hash', () => {
  it('should match circomlibjs implementation', async () => {
    const circuit = await wasm_tester(`
      pragma circom 2.1.6;
      include "circomlib/circuits/poseidon.circom";
      
      template Test() {
        signal input in[2];
        signal output out;
        
        component hasher = Poseidon(2);
        hasher.inputs[0] <== in[0];
        hasher.inputs[1] <== in[1];
        out <== hasher.out;
      }
      
      component main = Test();
    `);
    
    const inputs = { in: ['12345', '67890'] };
    const witness = await circuit.calculateWitness(inputs);
    
    const expectedHash = poseidon([12345n, 67890n]);
    expect(witness[1]).to.equal(expectedHash);
  });
});

import { describe, it, expect } from 'vitest';
import { poseidon } from 'circomlibjs';
import { Transaction } from '@mysten/sui';

describe('Poseidon cross-implementation', () => {
  it('should match between JS and Sui', async () => {
    const inputs = [123n, 456n, 789n];
    
    // JS implementation
    const jsHash = poseidon(inputs);
    
    // Sui implementation
    const tx = new Transaction();
    const result = tx.moveCall({
      target: `${PACKAGE_ID}::test::poseidon_3`,
      arguments: [
        tx.pure('u256', '123'),
        tx.pure('u256', '456'),
        tx.pure('u256', '789')
      ]
    });
    
    const { results } = await client.devInspectTransactionBlock({
      transactionBlock: tx,
      sender: '0x0'
    });
    
    const suiHash = parseU256FromResult(results);
    
    expect(jsHash.toString()).toBe(suiHash.toString());
  });
});