🟣⛵🏴‍☠️

momiji-helpers/package.json

+{
+  "name": "hardhat-project",
+  "type": "module",
+  "devDependencies": {
+    "@aztec/bb.js": "^0.45.1"
+  },
+  "dependencies": {
+    "@chainlink/contracts": "^0.8.0",
+    "@chainsafe/libp2p-gossipsub": "^11.0.0",
+    "@chainsafe/libp2p-noise": "^14.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.1",
+    "@libp2p/bootstrap": "^10.1.0",
+    "@libp2p/circuit-relay-v2": "^1.0.4",
+    "@libp2p/dcutr": "^1.0.3",
+    "@libp2p/identify": "^2.1.2",
+    "@libp2p/mplex": "^10.0.4",
+    "@libp2p/pubsub-peer-discovery": "^10.0.2",
+    "@libp2p/webrtc": "^4.0.5",
+    "@libp2p/websockets": "^8.0.4",
+    "@multiformats/multiaddr": "^12.1.11",
+    "@noir-lang/acvm_js": "^0.29.0",
+    "@noir-lang/backend_barretenberg": "0.28.0",
+    "@noir-lang/noir_codegen": "^0.28.0",
+    "@noir-lang/noir_js": "0.28.0",
+    "@noir-lang/noir_wasm": "0.28.0",
+    "@noir-lang/noirc_abi": "^0.22.0",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@openzeppelin/contracts": "^4.7.1",
+    "@types/node": "^20.14.10",
+    "dexie": "^4.0.8",
+    "ethers": "^6.13.0",
+    "hardhat": "^2.22.6",
+    "indexeddbshim": "^15.0.0",
+    "json2toml": "^6.1.0",
+    "libp2p": "^1.0.8",
+    "nostr-tools": "^2.7.1",
+    "sequelize": "^6.37.3",
+    "ws": "^8.18.0"
+  }
+}

momiji-helpers/tsconfig.json

+{
+  "compilerOptions": {
+    "target": "es2021",
+    "module": "ESNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "bundler"
+  }
+}

momiji-helpers/utils/MerkleTree.ts

+// @ts-ignore
+import { NoirFr, BarretenbergApi, _Barretenberg } from "./types"
+// @ts-ignore -- no types
+
+
+export class MerkleTree  {
+  zeroValue = "0x016a430aa58685aba1311244a973a3bc358859da86784be51094368e8fb6f720"; // sha256("Momiji") % Fr.MODULUS
+  levels: number;
+  defaultLeaves: string[]
+  storage: Map<string, string>;
+  zeros: string[];
+  totalLeaves: number;
+  barretenberg: any;
+
+  constructor(
+    levels: number, 
+    defaultLeaves: string[] = [],   ) {
+    this.levels = levels;
+    this.storage = new Map();
+    this.zeros = [];
+    this.totalLeaves = 0;
+    this.defaultLeaves = defaultLeaves
+  }
+
+  async hashLeftRight(left: string, right: string): Promise<string> {
+    const leftFr = NoirFr.fromString(left);
+    const rightFr = NoirFr.fromString(right);
+    const hash = await this.barretenberg.pedersenHash([leftFr, rightFr], 0)
+    return hash.toString();
+  }
+  async init() {
+    this.barretenberg = await BarretenbergApi.new()
+    let currentZero = this.zeroValue;
+    this.zeros.push(currentZero);
+    for (let i = 0; i < this.levels; i++) {
+      currentZero = await this.hashLeftRight(currentZero, currentZero);
+      this.zeros.push(currentZero);
+    }
+
+    if (this.defaultLeaves.length > 0) {
+      this.totalLeaves = this.defaultLeaves.length;
+
+      let level = 0;
+      this.defaultLeaves.forEach((leaf, index) => {
+        this.storage.set(MerkleTree.indexToKey(level, index), leaf);
+      });
+
+      level++;
+      let numberOfNodesInLevel = Math.ceil(this.totalLeaves / 2);
+      for (level; level <= this.levels; level++) {
+        for (let i = 0; i < numberOfNodesInLevel; i++) {
+          const leftKey = MerkleTree.indexToKey(level - 1, 2 * i);
+          const rightKey = MerkleTree.indexToKey(level - 1, 2 * i + 1);
+
+          const left = this.storage.get(leftKey);
+          const right = this.storage.get(rightKey) || this.zeros[level - 1];
+          if (!left) throw new Error("leftKey not found");
+
+          const node = await this.hashLeftRight(left, right);
+          this.storage.set(MerkleTree.indexToKey(level, i), node);
+        }
+        numberOfNodesInLevel = Math.ceil(numberOfNodesInLevel / 2);
+      }
+    }
+  }
+
+  static indexToKey(level: number, index: number) {
+    return `${level}-${index}`;
+  }
+
+  getIndex(leaf: string) {
+    for (const [key, value] of this.storage) {
+      if (value === leaf) {
+        return Number(key.split("-")[1]);
+      }
+    }
+    return -1;
+  }
+
+  root() {
+    return this.storage.get(MerkleTree.indexToKey(this.levels, 0)) || this.zeros[this.levels];
+  }
+
+  async proof(indexOfLeaf: number) {
+    let pathElements: string[] = [];
+    let pathIndices: number[] = [];
+
+    const leaf = this.storage.get(MerkleTree.indexToKey(0, indexOfLeaf));
+    if (!leaf) throw new Error("leaf not found");
+
+    const handleIndex = (level: number, currentIndex: number, siblingIndex: number) => {
+      const siblingValue = this.storage.get(MerkleTree.indexToKey(level, siblingIndex)) || this.zeros[level];
+      pathElements.push(siblingValue);
+      pathIndices.push(currentIndex % 2);
+    };
+
+    await this.traverse(indexOfLeaf, handleIndex);
+
+    return {
+      root: this.root(),
+      pathElements,
+      pathIndices,
+      leaf: leaf,
+    };
+  }
+
+  async insert(leaf: string) {
+    const index = this.totalLeaves;
+    await this.update(index, leaf, true);
+    this.totalLeaves++;
+  }
+
+  async update(index: number, newLeaf: string, isInsert = false) {
+    if (!isInsert && index >= this.totalLeaves) {
+      throw Error("Use insert method for new elements.");
+    } else if (isInsert && index < this.totalLeaves) {
+      throw Error("Use update method for existing elements.");
+    }
+
+    let keyValueToStore: any[] = [];
+    let currentElement = newLeaf;
+
+    const handleIndex = async (level: number, currentIndex: number, siblingIndex: number) => {
+      const siblingElement = this.storage.get(MerkleTree.indexToKey(level, siblingIndex)) || this.zeros[level];
+  
+      let left;
+      let right;
+      if (currentIndex % 2 === 0) {
+        left = currentElement;
+        right = siblingElement;
+      } else {
+        left = siblingElement;
+        right = currentElement;
+      }
+  
+      keyValueToStore.push({
+        key: MerkleTree.indexToKey(level, currentIndex),
+        value: currentElement,
+      });
+      currentElement = await this.hashLeftRight(left, right);
+    };
+    await this.traverse(index, handleIndex);
+
+    keyValueToStore.push({
+      key: MerkleTree.indexToKey(this.levels, 0),
+      value: currentElement,
+    });
+
+    keyValueToStore.forEach(o => {
+      this.storage.set(o.key, o.value);
+    });
+  }
+
+  async traverse(indexOfLeaf: number, handler: any) {
+    let currentIndex = indexOfLeaf;
+    for (let i = 0; i < this.levels; i++) {
+      let siblingIndex;
+      if (currentIndex % 2 === 0) {
+        siblingIndex = currentIndex + 1;
+      } else {
+        siblingIndex = currentIndex - 1;
+      }
+
+      await handler(i, currentIndex, siblingIndex);
+      currentIndex = Math.floor(currentIndex / 2);
+    }
+  }
+}
\ No newline at end of file

momiji-helpers/utils/batchBuilder.ts

+import { zeroPadValue } from 'ethers';
+import { InputMap } from '@noir-lang/noir_js';
+import fs from "fs"
+import json2toml from "json2toml"
+import { execSync } from 'child_process';
+import { Verifier, rollup_transaction } from '../circuits/helpers/codegen/rollup_transaction';
+import { publish_batch } from '../circuits/helpers/codegen/publish_batch';
+import { tx_as_hash } from '../circuits/helpers/codegen/tx_as_hash';
+import { Peering } from './peering';
+import * as types from './types';
+
+
+export class BatchBuilder extends Peering {
+  owner: types.EthersSigner | undefined;
+  anonRPC: string | undefined;
+
+  constructor(_config: types.GlobalConfig) {
+    if (typeof global !== 'object') throw new Error("BatchBuilder is not available in the browser.");
+    super(_config);
+  }
+
+  async initializeBatchBuilder(callback: Function): Promise<void> {
+    // // Uncomment below to recompile recursion circuit
+    // execSync(`cd ./momiji-helpers/circuits/recursion && nargo compile --only-acir --silence-warnings && ${this.config.nargo} write_vk --silence-warnings && ${this.config.nargo} vk_as_fields --silence-warnings`);
+    await this.initializePeering(callback);
+  }
+
+  async getHistoricPath(root: string): Promise<string[]> {
+    if (root === types.ZERO_VALUE) return types.default_historic_path
+    const path: string[] = await this.contracts.state.queryFilter(
+      this.contracts.state.filters.BatchPublish(undefined, undefined, root, undefined, undefined))
+      .then((event: any) => ((event.length !== 0) ? event[0].args[4] : Promise.reject("No historic path for this root")))
+    return path
+  }
+
+  async wrapTransaction(transaction: types.Transaction, txProofArtifacts: types.ProofArtifacts): Promise<Verifier> {
+    const public_inputs_hash: string = await tx_as_hash(transaction.public_inputs)
+    const wrapperInputs: InputMap = {
+      public_inputs_hash: public_inputs_hash,
+      transaction_verifier: {
+        key_hash: txProofArtifacts.vkHash,
+        verification_key: txProofArtifacts.vkAsFields,
+        proof: txProofArtifacts.proofAsFields,
+      }
+    }
+    let tx_aggregation_object: string[]
+    let wrapperArtifacts: types.ProofArtifacts;
+    let wrapper_proof = await this.noirs.transaction_wrapper.execute(wrapperInputs)
+      .then((wrapper_witness: any) => this.backends.transaction_wrapper.generateProof(wrapper_witness.witness));
+
+    tx_aggregation_object = wrapper_proof.publicInputs.slice(1);
+    let artifacts = await this.backends.transaction_wrapper.generateRecursiveProofArtifacts(wrapper_proof, 17);
+    wrapperArtifacts = {
+      proofData: wrapper_proof,
+      proofAsFields: artifacts.proofAsFields,
+      vkAsFields: artifacts.vkAsFields,
+      vkHash: artifacts.vkHash
+    }
+
+    const txWrapperVerifier: Verifier = {
+      key_hash: wrapperArtifacts.vkHash,
+      proof: wrapperArtifacts.proofAsFields,
+      verification_key: wrapperArtifacts.vkAsFields,
+      aggregation_object: tx_aggregation_object
+    }
+    txWrapperVerifier.proof = tx_aggregation_object.concat(txWrapperVerifier.proof)
+    return txWrapperVerifier
+  }
+
+  async recursiveProof(toml: string, transaction: types.Transaction): Promise<types.RecursionInputs> {
+    fs.writeFileSync('./momiji-helpers/circuits/recursion/Prover.toml', toml)
+    execSync(`cd ./momiji-helpers/circuits/recursion && nargo execute witness --silence-warnings && ${this.config.nargo} prove --silence-warnings && ${this.config.nargo} proof_as_fields --silence-warnings`);
+    const proofAsFields = JSON.parse(fs.readFileSync('./momiji-helpers/circuits/recursion/proofs/proof_fields.json', 'utf8'));
+    const vkAsFields = JSON.parse(fs.readFileSync('./momiji-helpers/circuits/recursion/target/vk_fields.json', 'utf8'));
+    const rollup: types.RecursionInputs = {
+      transaction: transaction,
+      accumulator: proofAsFields[0], 
+      recursion_verifier: {
+        proof: proofAsFields.slice(1),
+        verification_key: vkAsFields.slice(1), 
+        key_hash: vkAsFields[0],
+        aggregation_object: proofAsFields.slice(1, 17)
+      }
+    }
+    return rollup
+  }
+
+  async rollupTransaction(
+    currentRollup: types.RecursionInputs[],
+    transaction: types.Transaction
+  ): Promise<types.RecursionInputs[]> {
+
+    const tx_verifier = {
+      key_hash: transaction.proof_artifacts.vkHash,
+      verification_key: transaction.proof_artifacts.vkAsFields,
+      proof: transaction.proof_artifacts.proofAsFields
+    }
+
+    const idx: number = currentRollup.length > 0 ? currentRollup.length - 1 : 0;
+    const recursion_verifier = (currentRollup.length === 0) ? await this.wrapTransaction(transaction, transaction.proof_artifacts) : currentRollup[idx].recursion_verifier;
+    const previous_accumulator: string = (currentRollup.length === 0) ? types.ZERO_VALUE : currentRollup[idx].accumulator
+    
+    const toml: string = await rollup_transaction(
+      tx_verifier,
+      recursion_verifier!,
+      previous_accumulator,
+      transaction.public_inputs
+    ).then((rollupInputs: any) => json2toml(rollupInputs))
+
+    const newTx = await this.recursiveProof(toml, transaction)
+    currentRollup.push(newTx);
+    return currentRollup
+  }
+
+  async preparePublish(rollup: types.RecursionInputs[]): Promise<types.ContractPublish> {
+    if (rollup.length == 0) return Promise.reject("❌ Empty rollup cannot be published");
+    const finalRollup: types.RecursionInputs = rollup[rollup.length - 1];
+    const validRoots: string[] = await this.contracts.state.getValidRoots()
+    const merkleRoot: string = await this.contracts.state.merkleRoot()
+    const index: number = validRoots.indexOf(merkleRoot)
+    const txVerifier: types.ProofArtifacts = finalRollup.transaction!.proof_artifacts;
+    const publisherHelperInputs: types.PublishInputs = {
+      accumulator: finalRollup.accumulator,
+      hist_tree_input: {
+        root: await this.contracts.state.histRoot(),
+        leaf: merkleRoot,
+        index: types.toFixedHex(index, true),
+        path: await this.getHistoricPath(merkleRoot),
+        utxo_roots: new Array(16).fill("0x").map((_, i, __) => {
+          if (rollup[i] !== undefined && rollup[i].transaction !== undefined) return rollup[i]!.transaction!.public_inputs.utxo_root;
+          else return types.ZERO_VALUE;
+        })
+      },
+      tx_verifier: {
+        proof: txVerifier.proofAsFields,
+        verification_key: txVerifier.vkAsFields,
+        key_hash: txVerifier.vkHash
+      },
+      recursion_verifier: finalRollup.recursion_verifier!
+    }
+
+    if (this.verbose) fs.writeFileSync("./test_files/publisherHelperInputs.json", JSON.stringify(publisherHelperInputs))
+
+    const formattedPublishInputs = await publish_batch(
+      publisherHelperInputs.accumulator,
+      publisherHelperInputs.hist_tree_input,
+      publisherHelperInputs.tx_verifier,
+      publisherHelperInputs.recursion_verifier
+    )
+    if (this.verbose) fs.writeFileSync("./test_files/formattedPublishInputs.json", JSON.stringify(formattedPublishInputs))
+    const toml = json2toml(formattedPublishInputs as InputMap)
+    fs.writeFileSync('./momiji-helpers/circuits/publish/Prover.toml', toml)
+    execSync(`cd ./momiji-helpers/circuits/publish && nargo prove --silence-warnings && nargo verify --silence-warnings`);
+    const verifierInputs = {
+      proof: fs.readFileSync('./momiji-helpers/circuits/publish/proofs/publish.proof', 'utf-8'),
+      pi: formattedPublishInputs.pi_contract_hash
+    }
+
+    const batch_publish: types.ContractBatch = {
+      tx_key_hash: zeroPadValue(formattedPublishInputs.tx_verifier.key_hash, 32),
+      recursive_key_hash: zeroPadValue(formattedPublishInputs.recursion_verifier.key_hash, 32),
+      new_root: zeroPadValue(formattedPublishInputs.batch.new_state_root, 32),
+      old_hist_root: zeroPadValue(formattedPublishInputs.batch.hist_tree.root, 32),
+      new_hist_root: zeroPadValue(formattedPublishInputs.batch.hist_tree.new_root, 32),
+      oracle: zeroPadValue(formattedPublishInputs.batch.batch_oracle, 32),
+      historic_path: formattedPublishInputs.batch.hist_tree.new_path.map((p: any) => zeroPadValue(p, 32)),
+      aggregation_object: new Array(16).fill("0x")
+        .map((_, i, __) => "0x" + verifierInputs.proof.slice(i * 64, (i + 1) * 64)),
+      transactions: rollup.map(r => r.transaction).map(tx => tx!.contract_inputs)
+    }
+    if (this.verbose) fs.writeFileSync("./test_files/batch_publish_deposit.json", JSON.stringify(batch_publish))
+    return {
+      proof: "0x" + verifierInputs.proof.slice(1024),
+      batch: batch_publish
+    } as types.ContractPublish
+  }
+
+}
\ No newline at end of file

momiji-helpers/utils/database.ts

+import setGlobalVars from 'indexeddbshim';
+if (typeof global === 'object') setGlobalVars();
+import Dexie, { Table } from 'dexie';
+
+export interface UTXO_DB {
+    id?: number;
+    commitment: string;
+    secret: string;
+    amount: bigint;
+    assetType: string;
+    siblings?: string[];
+    timestamp: number;
+    status: string;
+    txHash?: string;
+    chainStatus: string;
+}
+
+export interface Hash {
+    id?: number;
+    hash: string;
+}
+
+export class UTXOStorage extends Dexie {
+
+    utxo!: Table<UTXO_DB>;
+
+    constructor() {
+        super('UTXOStorage');
+        this.version(1).stores({
+            utxo: '++commitment, secret, amount, assetType, siblings, timestamp, status, chainStatus'
+        });
+        this.utxo = this.table('utxo');
+    }
+}
+
+export class HashDB extends Dexie {
+
+    hash!: Table<Hash>;
+
+    constructor() {
+        super('HashDB');
+        this.version(1).stores({
+            hash: '++id, hash'
+        })
+        this.hash = this.table('hash');
+    }
+}
+
+export const db = new UTXOStorage();
+
+export const hashDB = new HashDB();

momiji-helpers/utils/peering.ts

+// @ts-ignore
+import * as types from './types';
+import { TransactionBuilder } from "./transactionBuilder";
+import { createLibp2p } from 'libp2p'
+import { webSockets } from '@libp2p/websockets'
+import * as filters from '@libp2p/websockets/filters'
+import { finalizeEvent, verifyEvent, setNostrWasm, VerifiedEvent, Event } from 'nostr-tools/wasm'
+import { SimplePool } from 'nostr-tools/pool'
+import { gossipsub } from '@chainsafe/libp2p-gossipsub'
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { mplex } from '@libp2p/mplex'
+import { identify } from "@libp2p/identify"
+import { dcutr } from "@libp2p/dcutr"
+import { getPublicKey } from 'nostr-tools/pure';
+import { initNostrWasm } from 'nostr-wasm'
+import { multiaddr } from '@multiformats/multiaddr'
+import { useWebSocketImplementation } from 'nostr-tools/pool'
+import { pubsubPeerDiscovery } from '@libp2p/pubsub-peer-discovery'
+import WebSocket from 'ws'
+
+if (typeof global === "object") useWebSocketImplementation(WebSocket);
+
+
+export class Peering extends TransactionBuilder {
+
+    p2p: any | undefined; 
+    pool: SimplePool = new SimplePool(); 
+    relays: string[];
+    seeds: string[];
+    rebroadcast: any | undefined;
+    callback: Function;
+
+    constructor(_config: types.GlobalConfig) {
+        super(_config);
+        if (!this.config.gossip) throw new Error("Gossip config not found");
+        this.pool = new SimplePool();
+        this.relays = this.config.gossip!.relays;
+        this.seeds = this.config.gossip!.seeds;
+        this.callback = () => true;
+    }
+
+    postEvent = async (_sk: Uint8Array, _timestamp: number) => Promise.any(this.pool.publish(this.relays, finalizeEvent({
+        kind: 1,
+        created_at: _timestamp,
+        tags: [],
+        content: this.p2p.getMultiaddrs().map((addr: any) => multiaddr(addr).toString()).join(',')
+    }, _sk)))
+    postTransaction = async (_tx: types.Transaction) => {
+        const hexString = (await this.contracts.state.getAddress()).slice(2).padStart(64, '0');
+        const matches = hexString.match(/.{1,2}/g);
+        const skUint8Array = matches ? new Uint8Array(matches.map(byte => parseInt(byte, 16))) : new Uint8Array();
+        const _pk: string = getPublicKey(skUint8Array);
+
+        if (this.p2p.services.pubsub.getSubscribers(_pk).length > 0) {
+            await this.p2p.services.pubsub.publish(_pk, new TextEncoder().encode(JSON.stringify(_tx)))
+        } else {
+            setTimeout(async () => await this.postTransaction(_tx), 10_000);
+        }
+    };
+    initializePeering = async (callback?: Function): Promise<void> => {
+        await this.initializeTransactionBuilder();
+        const hexString = (await this.contracts.state.getAddress()).slice(2).padStart(64, '0');
+        const matches = hexString.match(/.{1,2}/g);
+        const skUint8Array = matches ? new Uint8Array(matches.map(byte => parseInt(byte, 16))) : new Uint8Array();
+        let _pk = getPublicKey(skUint8Array);
+
+        await this.fetchRelays();
+        await initNostrWasm().then(setNostrWasm);
+
+        const latestBlock = await this.config.provider.getBlock("latest");
+
+        let multiAddrs: string[] = [];
+
+        this.p2p = await createLibp2p({
+            addresses: {
+                listen: (typeof global === "object") ? ['/ip4/0.0.0.0/tcp/5150/ws'] : []
+            },
+            transports: [webSockets({
+                filter: filters.all
+            })],
+            connectionEncryption: [noise()],
+            streamMuxers: [yamux(), mplex()],
+            services: {
+                pubsub: gossipsub(),
+                identify: identify(),
+                dcutr: dcutr()
+            },
+            connectionGater: {
+                denyDialMultiaddr: () => {
+                    return false
+                }
+            },
+            peerDiscovery: [
+                pubsubPeerDiscovery({
+                    interval: 10_000 
+                })
+            ]
+        });
+
+        await this.p2p.start()
+        this.p2p.services.pubsub.subscribe(_pk)
+        await this.p2p.services.pubsub.start()
+
+        this.p2p.addEventListener('connection:open', async (event: CustomEvent) => {
+            console.log("peering.ts - connection open", event.detail.id.toString())
+        })
+        this.p2p.addEventListener('connection:close', () => {
+            console.log("peering.ts - connection closed")
+        })
+        this.p2p.addEventListener("peer:connect", async (event: CustomEvent) => {
+            console.log("peering.ts - peer connect")
+        })
+        this.p2p.addEventListener("peer:discovery", (event: CustomEvent) => {
+            console.log("peering.ts - peer discovered:", event.detail.id.toString())
+        })
+
+        if (typeof global === "object") {
+            try {
+                this.pool.subscribeMany(
+                    this.relays.slice(0, this.config.gossip!.maxRelays),
+                    [
+                        {
+                            kinds: [1],
+                            authors: [_pk],
+                            since: latestBlock!.timestamp
+                        },
+                    ],
+                    {
+                        onevent: async (event) => event.content.split(',')
+                            .filter(addr => {
+                                try {
+                                    multiaddr(addr);
+                                    return true;
+                                } catch (error) {
+                                    return false;
+                                }
+                            })
+                            .forEach(async (addr) => this.addPeer(addr)),
+                        oneose: async () => true,
+                        onclose: async () => true,
+                    }
+                )
+            } catch (error) {
+            }
+        } else {
+            try {
+                const events: Event[] = await this.pool.querySync(this.relays.slice(0, this.config.gossip!.maxRelays),
+                    {
+                        kinds: [1],
+                        authors: [_pk],
+                        since: latestBlock!.timestamp - (typeof global === 'object' ? 0 : 86400)
+                    }
+                )
+                console.log("peering.ts - nostr events", events)
+                multiAddrs = events.map(event => event.content.split(","))
+                    .flat(1)
+                    .filter(addr => {
+                        try {
+                            multiaddr(addr);
+                            return true;
+                        } catch (error) {
+                            return false;
+                        }
+                    })
+
+                for (let addr in multiAddrs) await this.addPeer(multiAddrs[addr]);
+
+            } catch (error) {
+                console.log("error, peering.ts - initializePeering(), pool.querySync()", error)
+            }
+        }
+
+        if (typeof global === 'object') {
+            this.rebroadcast = setInterval(async () => await this.postEvent(skUint8Array, latestBlock!.timestamp), 60 * 60 * 1000);
+            await this.postEvent(skUint8Array, latestBlock!.timestamp);
+            this.p2p.services.pubsub.addEventListener('message', (message: CustomEvent) => {
+                if (!(message.detail.topic == _pk) || !callback) return;
+                callback(JSON.parse(new TextDecoder().decode(message.detail.data)));
+            })
+
+        }
+
+    }
+
+    addPeer = async (peerMultiaddr: string): Promise<void> => {
+        if (!this.p2p) {
+            throw new Error('P2P is not initialized');
+        }
+        try {
+            await this.p2p.dial(multiaddr(peerMultiaddr));
+            console.log(`Successfully connected to peer: ${peerMultiaddr}`);
+        } catch (error) {
+        }
+    };
+
+    fetchRelays = async (refresh: boolean = false): Promise<string[]> => {
+        if (this.seeds.length == 0 || refresh) return this.relays;
+        for (const seed of this.seeds) {
+            const relaysFromSeed: string[] = (await (await fetch(seed)).json()) as string[];
+            this.relays = this.relays.concat(relaysFromSeed);
+        }
+        return this.relays;
+    }
+}
+
+/* eslint-disable no-console */
+

momiji-helpers/utils/transactionBuilder.ts

+import "crypto"
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { Noir, InputMap } from '@noir-lang/noir_js';
+import { zeroPadValue, TypedDataEncoder } from 'ethers';
+import json2toml from "json2toml"
+import * as types from './types.js';
+import { TransactionInputs, create_transaction } from '../circuits/helpers/codegen/create_transaction';
+import { UTXO_New } from '../circuits/helpers/codegen/utxo_to_commitment';
+import { MerkleTree } from './MerkleTree';
+import { keccak_tx_no_deposit } from '../circuits/helpers/codegen/keccak_tx_no_deposit';
+import { tx_as_hash } from '../circuits/helpers/codegen/tx_as_hash';
+import { Momiji__factory, XFTMock__factory, UltraVerifier__factory, IUniswapV3Pool__factory } from './typechain-types';
+import { transaction, transaction_wrapper } from './transaction_circuits';
+import { Fr, Barretenberg } from "@aztec/bb.js"
+import { Buffer } from "buffer"
+import { rollup_transaction, RecursionInputs, Verifier } from "../circuits/helpers/codegen/rollup_transaction";
+import './database';
+
+const MAX_FIELD_VALUE: string = (new types.NoirFr(types.NoirFr.MAX_VALUE)).toString();
+
+export class TransactionBuilder {
+  initialized: boolean = false;
+  circuits: types.Circuits;
+  backends: types.Backends;
+  noirs: types.Noirs;
+  contracts!: types.Contracts;
+  sendRpc: string | undefined;
+  verbose: boolean = false;
+  config: types.GlobalConfig;
+
+  constructor(config: types.GlobalConfig) {
+    this.config = config;
+    this.verbose = (config.verbose) ? config.verbose : false;
+    const circuits: types.Circuits = {
+      transaction: transaction,
+      transaction_wrapper: transaction_wrapper,
+    };
+    let backendOptions: types.NoirBackendOptions | undefined = (this.config.threads) ? { threads: this.config.threads } : undefined;
+    const backends: types.Backends = {
+      transaction: new BarretenbergBackend(circuits.transaction, backendOptions),
+      transaction_wrapper: new BarretenbergBackend(circuits.transaction_wrapper, backendOptions),
+    };
+    const noirs: types.Noirs = {
+      transaction: new Noir(circuits.transaction, backends.transaction),
+      transaction_wrapper: new Noir(circuits.transaction_wrapper, backends.transaction_wrapper),
+    };
+    this.circuits = circuits;
+    this.backends = backends;
+    this.noirs = noirs;
+  }
+
+  async initializeTransactionBuilder(): Promise<void> {
+    let _runner = this.config.signer ? this.config.signer : this.config.provider
+    let _state = Momiji__factory.connect("0xd66E7B1B008a560ad8be69494ce101DE188FbCd3", _runner) 
+    this.contracts = {
+      state: _state,
+      verifier: UltraVerifier__factory.connect(await _state.verifier(), _runner),
+      token: XFTMock__factory.connect(await _state.xft(), _runner),
+      pool: IUniswapV3Pool__factory.connect(await _state.xftPool(), _runner)
+    }
+    this.initialized = true;
+  }
+
+  emptyTransaction = async (): Promise<types.Transaction> => {
+    return { 
+      proof_artifacts: {
+        proofData: {
+          proof: Uint8Array.from(new Array(2144).fill(255)),
+          publicInputs: [MAX_FIELD_VALUE]
+        },
+        proofAsFields: new Array(93).fill(MAX_FIELD_VALUE),
+        vkAsFields: new Array(114).fill(MAX_FIELD_VALUE),
+        vkHash: await this.contracts.state.txKeyHash()
+      },
+      contract_inputs: {
+        current_root: await this.contracts.state.merkleRoot(),
+        utxo_root: MAX_FIELD_VALUE,
+        price_limit: MAX_FIELD_VALUE,
+        timestamp: await this.config.provider.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60), true)),
+        deadline: await this.config.provider!.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60) + (60 * 60 * 24 * 7), true)),
+        amount: MAX_FIELD_VALUE,
+        encrypted_utxo: new Array(16).fill({
+          secret: MAX_FIELD_VALUE,
+          amount: MAX_FIELD_VALUE,
+          data: MAX_FIELD_VALUE
+        }),
+        withdrawals: new Array(16).fill(types.ZERO_HEX),
+        commitments_in: new Array(16).fill(types.ZERO_VALUE),
+        commitments: new Array(16).fill(types.NoirFr.random().toString()),
+        recipients: new Array(16).fill(types.ZERO_HEX),
+        nullifier_hashes: new Array(16).fill(types.ZERO_VALUE),
+        uids: new Array(16).fill(types.ZERO_HEX),
+        swap_amounts: new Array(16).fill(types.ZERO_HEX),
+        deposit: {
+          signature: "0x00",
+          pi_hash: MAX_FIELD_VALUE
+        }
+      },
+      public_inputs: {
+        current_root: await this.contracts.state.merkleRoot(),
+        utxo_root: MAX_FIELD_VALUE,
+        deposit_amount: types.ZERO_HEX,
+        withdrawals: types.ZERO_HEX,
+        commitment_in: new Array(16).fill(types.ZERO_VALUE),
+        commitment_out: new Array(16).fill(types.ZERO_VALUE),
+        nullifier_hashes: new Array(16).fill(types.ZERO_VALUE),
+        contract_only_inputs: MAX_FIELD_VALUE
+      }
+  }
+  };
+
+  async _padBatch(tx: types.Transaction[]): Promise<types.Batch> {
+    const txContractInputs = tx.map(_tx => _tx.contract_inputs)
+    const _fill = new Array(16 - tx.length).fill((await this.emptyTransaction()).contract_inputs)
+    const txFill = txContractInputs.concat(_fill)
+    let _batch: types.Batch = {
+      tx_key_hash: await this.contracts.state.txKeyHash(),
+      recursive_key_hash: await this.contracts.state.recursiveKeyHash(),
+      new_root: MAX_FIELD_VALUE,
+      old_hist_root: await this.contracts.state.histRoot(),
+      new_hist_root: MAX_FIELD_VALUE,
+      oracle: MAX_FIELD_VALUE,
+      historic_path: new Array(20).fill(MAX_FIELD_VALUE),
+      aggregation_object: new Array(16).fill(MAX_FIELD_VALUE),
+      transactions: txFill
+    }
+    console.log(_batch.transactions)
+    return _batch
+  }
+
+  async getTransactionsGas(tx: types.Transaction[] | types.Transaction): Promise<bigint> {
+    const SUBSIDY_FACTOR = 16n 
+    const _verifyCost = 430_000n; 
+    if (!Array.isArray(tx)) tx = [tx]
+    console.log("pad now")
+    const _batch = await this._padBatch(tx)
+    console.log(_batch)
+    let _batchSim = _batch;
+    let _emptySim = _batch;
+    try {
+      _batchSim.transactions = _batch.transactions.slice(tx.length);
+      _emptySim.transactions = _batch.transactions = [];
+      let _fullGas = (await this.contracts.state.simulatePublish.estimateGas(_batch));
+      let _stubGas = (await this.contracts.state.simulatePublish.estimateGas(_batchSim));
+      let _emptyGas = (await this.contracts.state.simulatePublish.estimateGas(_emptySim));
+      console.log(_fullGas, _stubGas, _emptyGas);
+      return (_fullGas - _stubGas) + ((_verifyCost + _emptyGas) / SUBSIDY_FACTOR);
+    } catch (e) {
+      console.log(e);
+      return 0n;
+    }
+  }
+
+  async _generateUTXOEncrypted(utxo_input: types.UTXO_Input[]): Promise<types.UTXO_Encrypted[]> {
+    const utxos: types.UTXO_Encrypted[] = utxo_input.map((utxo) => {
+      return {
+        secret: utxo.secret ? utxo.secret : Fr.random().toString(),
+        amount: utxo.amount,
+        asset_type: utxo.asset_type ? utxo.asset_type : types.ZERO_VALUE,
+        secret_encrypted: types.ZERO_VALUE,
+        amount_encrypted: types.ZERO_VALUE,
+        asset_type_encrypted: types.ZERO_VALUE,
+        uid: types.ZERO_VALUE
+      }
+    })
+    return utxos
+  }
+
+  async utxo_to_commitment(utxo: UTXO_New): Promise<string> {
+    const barretenberg: types._Barretenberg = await Barretenberg.new()
+    const hash: string = await barretenberg.pedersenHash([Fr.fromString(utxo.secret)], 0)
+      .then((owner: types._NoirFr) => barretenberg.pedersenHash([owner, Fr.fromString(utxo.amount), Fr.fromString(utxo.asset_type)], 0))
+      .then((hashFr: types._NoirFr) => hashFr.toString())
+    await barretenberg.destroy()
+    return hash
+  }
+
+  async pedersen_left_right(left: string, right: string): Promise<string> {
+    const barretenberg: types._Barretenberg = await Barretenberg.new()
+    const hash: string = await barretenberg.pedersenHash([Fr.fromString(left), Fr.fromString(right)], 0)
+      .then(hashFr => hashFr.toString())
+    await barretenberg.destroy()
+    return hash
+  }
+
+  _calculateDepositAmount(utxo_commitments?: types.UTXO_Commitment[], utxo_new?: types.UTXO_Encrypted[], withdrawals?: types.WithdrawalSwap[]): string {
+    const utxo_in_total: bigint = utxo_commitments ? utxo_commitments.map(utxo => (utxo.amount === types.ZERO_VALUE ? BigInt(0) : BigInt(utxo.amount))).reduce((prev, curr) => BigInt(prev) + BigInt(curr)) : BigInt(0)
+    const utxo_out_total: bigint = utxo_new ? utxo_new.map(utxo => (utxo.amount === types.ZERO_VALUE ? BigInt(0) : BigInt(utxo.amount))).reduce((prev, curr) => BigInt(prev) + BigInt(curr)) : BigInt(0)
+    const withdrawal_total: bigint = withdrawals ? withdrawals.map(w => BigInt(w.amount)).reduce((prev, curr) => BigInt(prev) + BigInt(curr)) : BigInt(0)
+    let total: string = ((utxo_out_total + withdrawal_total) > utxo_in_total)
+      ? (new Fr(utxo_out_total + withdrawal_total - utxo_in_total)).toString()
+      : (new Fr(BigInt(0))).toString();
+    return total
+  }
+
+  async _getPriceLimitX96(slippage_percentage: number): Promise<string> {
+    if (slippage_percentage > 24) return Promise.reject("Slippage too high");
+    if (slippage_percentage < 0) return Promise.reject("Slippage cannot be less than zero")
+    const _sqrtPriceX96: bigint = await this.contracts.pool.slot0().then(slot0 => slot0.sqrtPriceX96)
+    const _sqrtPriceLimitX96: bigint = _sqrtPriceX96 * BigInt(100_000 - Math.floor(slippage_percentage * 1_000)) / BigInt(100_000)
+    return (new Fr(_sqrtPriceLimitX96)).toString()
+  }
+
+  async _getTransactionFeeInXFT(gasUsed: bigint): Promise<bigint> {
+    const _sqrtPriceX96: bigint = await this.contracts.pool.slot0().then(slot0 => slot0.sqrtPriceX96)
+    const _xftPerEth: bigint = BigInt(2**192 * 1e18) / (_sqrtPriceX96 * _sqrtPriceX96)
+    const _feeData = await this.config.provider.getFeeData()
+    if (!_feeData.maxFeePerGas || !_feeData.maxPriorityFeePerGas) return Promise.reject("Fee data cannot be fetched")
+    const _transactionFeeInXft: bigint = BigInt(gasUsed) * (_feeData.maxFeePerGas! + _feeData.maxPriorityFeePerGas!) * _xftPerEth / BigInt(1e18)
+    return _transactionFeeInXft
+  }
+
+  async _getEtherFromXFT(xft: bigint): Promise<bigint> {
+    const sqrtPriceX96: bigint = await this.contracts.pool.slot0().then(slot0 => slot0.sqrtPriceX96)
+    const xftToEther: bigint = xft * sqrtPriceX96 * sqrtPriceX96 / BigInt(2**192)
+    return xftToEther
+  }
+
+  async _generateWithdrawals(_withdrawals: types.Withdrawal[], slippage_percentage: number): Promise<types.WithdrawalSwap[]> {
+    const priceLimitX96: string = await this._getPriceLimitX96(slippage_percentage)
+    const withdrawals: types.WithdrawalSwap[] = _withdrawals.map(
+      (withdrawal) => {
+        const _amount: string = (withdrawal.amount === types.ZERO_VALUE) ? types.ZERO_HEX : withdrawal.amount;
+        return {
+          amount: _amount,
+          recipient: zeroPadValue(withdrawal.recipient, 32),
+          swap_amount: (new Fr(BigInt(_amount) * BigInt(Math.floor(withdrawal.swap_percentage * 1_000)) / BigInt(100_000))).toString(),
+          price_limit: priceLimitX96
+        } as types.WithdrawalSwap
+      }
+    )
+    return withdrawals
+  }
+
+  async _generateRawTransactionInputs(utxo_commitments?: types.UTXO_Commitment[], utxo_encrypted?: types.UTXO_Encrypted[], withdrawals?: types.WithdrawalSwap[]): Promise<types.TransactionInputsRaw> {
+    const inputs: types.TransactionInputsRaw = {
+      current_root: await this.contracts.state.histRoot(),
+      deposit_amount: this._calculateDepositAmount(utxo_commitments, utxo_encrypted, withdrawals),
+      withdrawals: (withdrawals)
+        ? new Array(16).fill("0x").map((_, i, __) => (withdrawals[i]) ? withdrawals[i].amount : types.ZERO_HEX)
+        : new Array(16).fill(types.ZERO_HEX),
+      utxo_spendable: await this._generateUTXOSpendable(utxo_commitments),
+      utxo_new: (utxo_encrypted)
+        ? new Array(16).fill({
+          secret: types.ZERO_VALUE,
+          amount: types.ZERO_VALUE,
+          asset_type: types.ZERO_VALUE
+        })
+          .map((_, i, __) => {
+            if (utxo_encrypted[i]) {
+              return {
+                secret: utxo_encrypted[i].secret,
+                amount: utxo_encrypted[i].amount,
+                asset_type: utxo_encrypted[i].asset_type
+              }
+            } else {
+              return {
+                secret: types.ZERO_HEX,
+                amount: types.ZERO_VALUE,
+                asset_type: types.ZERO_VALUE
+              }
+            }
+          })
+        : new Array(16).fill({
+          secret: types.ZERO_VALUE,
+          amount: types.ZERO_VALUE,
+          asset_type: types.ZERO_VALUE
+        }),
+      contract_only_inputs: {
+        timestamp: await this.config.provider.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60), true)),
+        deadline: await this.config.provider!.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60) + (60 * 60 * 24 * 7), true)), 
+        signature_hash: types.ZERO_HEX,
+        price_limit: (withdrawals)
+          ? withdrawals.reduce((prev, curr) => ((BigInt(curr.price_limit) > BigInt(prev.price_limit)) ? curr : prev)).price_limit
+          : types.ZERO_HEX,
+        recipients: (withdrawals)
+          ? new Array(16).fill("0x").map((_, i, __) => ((withdrawals[i]) ? withdrawals[i].recipient : types.ZERO_HEX))
+          : new Array(16).fill(types.ZERO_HEX),
+        swap_amounts: (withdrawals)
+          ? new Array(16).fill("0x").map((_, i, __) => ((withdrawals[i]) ? withdrawals[i].swap_amount : types.ZERO_HEX))
+          : new Array(16).fill(types.ZERO_HEX),
+        uids: (utxo_encrypted)
+          ? new Array(16).fill("0x").map((_, i, __) => ((utxo_encrypted[i]) ? utxo_encrypted[i].uid : types.ZERO_VALUE))
+          : new Array(16).fill(types.ZERO_VALUE),
+        encrypted_utxo: (utxo_encrypted)
+          ? new Array(16).fill("0x")
+            .map((_, i, __) => {
+              if (utxo_encrypted[i]) {
+                return {
+                  secret: utxo_encrypted[i].secret_encrypted,
+                  amount: utxo_encrypted[i].amount_encrypted,
+                  data: utxo_encrypted[i].asset_type_encrypted
+                }
+              } else {
+                return {
+                  secret: types.ZERO_VALUE,
+                  amount: types.ZERO_VALUE,
+                  data: types.ZERO_VALUE
+                }
+              }
+            })
+          : new Array(16).fill({
+            secret: types.ZERO_VALUE,
+            amount: types.ZERO_VALUE,
+            data: types.ZERO_VALUE
+          })
+      }
+    }
+    const _domain: types.TypedDataDomain = {
+      name: "Momiji",
+      version: "1",
+      chainId: BigInt(1),
+      verifyingContract: await this.contracts.state.getAddress()
+    }
+    const _types: types.TypedDataTypes = {
+      DepositHash: [
+        { name: "pi_hash", type: "bytes32" }
+      ]
+    }
+    const _values: types.TypedDataValues = {
+      pi_hash: types.ZERO_HEX
+    }
+    inputs.contract_only_inputs.signature_hash = await keccak_tx_no_deposit(
+      inputs.current_root,
+      inputs.deposit_amount,
+      inputs.withdrawals,
+      inputs.utxo_spendable,
+      inputs.utxo_new,
+      inputs.contract_only_inputs
+    ).then(hash => {
+      _values.pi_hash = zeroPadValue(hash, 32)
+      if (inputs.deposit_amount === types.toFixedHex(0, true)) return types.toFixedHex(0, true);
+      else return zeroPadValue(
+        Fr.fromBufferReduce(
+          Buffer.from(
+            TypedDataEncoder.hash(_domain, _types, _values).slice(2),
+            "hex"
+          )
+        ).toString(),
+        32
+      );
+    })
+    return inputs
+  }
+
+  async _generateRawTransactionInputsExpert(deposit?: bigint, utxo_commitments?: types.UTXO_Commitment[], utxo_encrypted?: types.UTXO_Encrypted[], withdrawals?: types.WithdrawalSwap[]): Promise<types.TransactionInputsRaw> {
+    const inputs: types.TransactionInputsRaw = {
+      current_root: await this.contracts.state.histRoot(),
+      deposit_amount: (deposit) 
+      ? (new types.NoirFr(deposit)).toString()
+      : types.toFixedHex(0, true),
+      withdrawals: (withdrawals)
+        ? new Array(16).fill("0x").map((_, i, __) => (withdrawals[i]) ? withdrawals[i].amount : types.ZERO_HEX)
+        : new Array(16).fill(types.ZERO_HEX),
+      utxo_spendable: await this._generateUTXOSpendable(utxo_commitments),
+      utxo_new: (utxo_encrypted)
+        ? new Array(16).fill({
+          secret: types.ZERO_VALUE,
+          amount: types.ZERO_VALUE,
+          asset_type: types.ZERO_VALUE
+        })
+          .map((_, i, __) => {
+            if (utxo_encrypted[i]) {
+              return {
+                secret: utxo_encrypted[i].secret,
+                amount: utxo_encrypted[i].amount,
+                asset_type: utxo_encrypted[i].asset_type
+              }
+            } else {
+              return {
+                secret: types.ZERO_HEX,
+                amount: types.ZERO_VALUE,
+                asset_type: types.ZERO_VALUE
+              }
+            }
+          })
+        : new Array(16).fill({
+          secret: types.ZERO_VALUE,
+          amount: types.ZERO_VALUE,
+          asset_type: types.ZERO_VALUE
+        }),
+      contract_only_inputs: {
+        timestamp: await this.config.provider.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60), true)),
+        deadline: await this.config.provider!.getBlock("latest")
+          .then(res => types.toFixedHex(res!.timestamp - (res!.timestamp % 60) + (60 * 60 * 24 * 7), true)), 
+        signature_hash: types.ZERO_HEX,
+        price_limit: (withdrawals)
+          ? withdrawals.reduce((prev, curr) => ((BigInt(curr.price_limit) > BigInt(prev.price_limit)) ? curr : prev)).price_limit
+          : types.ZERO_HEX,
+        recipients: (withdrawals)
+          ? new Array(16).fill("0x").map((_, i, __) => ((withdrawals[i]) ? withdrawals[i].recipient : types.ZERO_HEX))
+          : new Array(16).fill(types.ZERO_HEX),
+        swap_amounts: (withdrawals)
+          ? new Array(16).fill("0x").map((_, i, __) => ((withdrawals[i]) ? withdrawals[i].swap_amount : types.ZERO_HEX))
+          : new Array(16).fill(types.ZERO_HEX),
+        uids: (utxo_encrypted)
+          ? new Array(16).fill("0x").map((_, i, __) => ((utxo_encrypted[i]) ? utxo_encrypted[i].uid : types.ZERO_VALUE))
+          : new Array(16).fill(types.ZERO_VALUE),
+        encrypted_utxo: (utxo_encrypted)
+          ? new Array(16).fill("0x")
+            .map((_, i, __) => {
+              if (utxo_encrypted[i]) {
+                return {
+                  secret: utxo_encrypted[i].secret_encrypted,
+                  amount: utxo_encrypted[i].amount_encrypted,
+                  data: utxo_encrypted[i].asset_type_encrypted
+                }
+              } else {
+                return {
+                  secret: types.ZERO_VALUE,
+                  amount: types.ZERO_VALUE,
+                  data: types.ZERO_VALUE
+                }
+              }
+            })
+          : new Array(16).fill({
+            secret: types.ZERO_VALUE,
+            amount: types.ZERO_VALUE,
+            data: types.ZERO_VALUE
+          })
+      }
+    }
+    const _domain: types.TypedDataDomain = {
+      name: "Momiji",
+      version: "1",
+      chainId: BigInt(1),
+      verifyingContract: await this.contracts.state.getAddress()
+    }
+    const _types: types.TypedDataTypes = {
+      DepositHash: [
+        { name: "pi_hash", type: "bytes32" }
+      ]
+    }
+    const _values: types.TypedDataValues = {
+      pi_hash: types.ZERO_HEX
+    }
+    console.log(inputs)
+    inputs.contract_only_inputs.signature_hash = await keccak_tx_no_deposit(
+      inputs.current_root,
+      inputs.deposit_amount,
+      inputs.withdrawals,
+      inputs.utxo_spendable,
+      inputs.utxo_new,
+      inputs.contract_only_inputs
+    ).then(hash => {
+      _values.pi_hash = zeroPadValue(hash, 32)
+      if (inputs.deposit_amount === types.toFixedHex(0, true)) return types.toFixedHex(0, true);
+      else return zeroPadValue(
+        Fr.fromBufferReduce(
+          Buffer.from(
+            TypedDataEncoder.hash(_domain, _types, _values).slice(2),
+            "hex"
+          )
+        ).toString(),
+        32
+      );
+    })
+    return inputs
+  }
+
+  async getSiblingsFromChain(utxo: UTXO_New): Promise<string[]> {
+    const commitment: string = await this.utxo_to_commitment(utxo).then(c => zeroPadValue(c, 32))
+    const old_root: string = await this.contracts.state.utxoPrevRoots(commitment)
+    const siblings: string[] = await this.contracts.state.queryFilter(
+      this.contracts.state.filters.TransactionPublish(undefined, old_root, undefined)
+    )
+      .then((events: any) => events.map((event: any) => event.args[0].commitments))
+      .then((commitments: any) => commitments.find((c: any) => c.includes(commitment)))
+    if (!siblings) return Promise.reject("Siblings not found.")
+    return siblings
+  }
+
+  async getUtxoCommitment(utxo: UTXO_New): Promise<string> {
+    const commitment: string = await this.utxo_to_commitment(utxo)
+    return commitment
+  }
+
+  async getTxHashFromUtxo(utxo: UTXO_New): Promise<string> {
+    const commitment: string = await this.getUtxoCommitment(utxo)
+    const oldRoot: string = await this.contracts.state.utxoPrevRoots(commitment)
+    const txHash: string = await this.contracts.state.queryFilter(
+      this.contracts.state.filters.TransactionPublish(undefined, oldRoot, undefined)
+    )
+      .then(events => events.find(event => event.args[0].commitments.includes(commitment)))
+      .then(event => (event ? event.transactionHash : types.toFixedHex(0, true)))
+    return txHash
+  }
+
+  async _generateUTXOCommitments(inputs: types.TransactionInputsRaw, spend_in_same_batch: boolean[]): Promise<types.UTXO_Commitment[]> {
+    const formattedInputs: TransactionInputs = await create_transaction(
+      inputs.current_root,
+      inputs.deposit_amount,
+      inputs.withdrawals,
+      inputs.utxo_spendable,
+      inputs.utxo_new,
+      inputs.contract_only_inputs
+    )
+    const utxo_commitments: types.UTXO_Commitment[] = inputs.utxo_new.map((utxo, i, _) => {
+      return {
+        commitment: formattedInputs.public_inputs.commitment_out[i],
+        secret: utxo.secret,
+        amount: utxo.amount,
+        asset_type: utxo.asset_type,
+        siblings: formattedInputs.public_inputs.commitment_out,
+        spend_in_same_batch: spend_in_same_batch[i] ? true : false
+      } as types.UTXO_Commitment
+    })
+    return utxo_commitments
+  }
+
+  async _generateFormattedTransactionInputs(inputs: types.TransactionInputsRaw): Promise<TransactionInputs> {
+    const formattedInputs: TransactionInputs = await create_transaction(
+      inputs.current_root,
+      inputs.deposit_amount,
+      inputs.withdrawals,
+      inputs.utxo_spendable,
+      inputs.utxo_new,
+      inputs.contract_only_inputs
+    )
+    return formattedInputs
+  }
+
+  async _generateMerkleProof(
+    utxo_input: types.MerkleProofInput,
+    tx_input: types.MerkleProofInput,
+    state_input: types.MerkleProofInput
+  ): Promise<types.Merkle_Proof_Struct> {
+    const merkleProof: types.Merkle_Proof_Struct = {
+      path_utxo: await utxo_input.tree.proof(utxo_input.tree.getIndex(utxo_input.leaf))
+        .then(proof => proof.pathElements),
+      path_tx: await tx_input.tree.proof(tx_input.tree.getIndex(tx_input.leaf))
+        .then(proof => proof.pathElements),
+      path_historic: await state_input.tree.proof(state_input.tree.getIndex(state_input.leaf))
+        .then(proof => proof.pathElements),
+      index_utxo: types.toFixedHex(utxo_input.tree.getIndex(utxo_input.leaf), true),
+      index_tx: types.toFixedHex(tx_input.tree.getIndex(tx_input.leaf), true),
+      index_historic: types.toFixedHex(state_input.tree.getIndex(state_input.leaf), true)
+    }
+    return merkleProof
+  }
+
+  async getNewStateRoot(old_state_root: string): Promise<string> {
+    const validRoots: string[] = await this.contracts.state.getValidRoots()
+    const oldRootIndex: number = validRoots.indexOf(old_state_root)
+    if (oldRootIndex === undefined) return Promise.reject("Root not found")
+    const newStateRoot: string = validRoots[oldRootIndex + 1]
+    return newStateRoot
+  }
+
+  async _generateUTXOSpendableSingle(utxo: types.UTXO_Commitment, hist_tree: MerkleTree): Promise<types.UTXO_Spendable_Struct> {
+    const empty_utxo_spendable: types.UTXO_Spendable_Struct = {
+      secret: types.ZERO_HEX,
+      amount: types.ZERO_VALUE,
+      asset_type: types.ZERO_VALUE,
+      oracle: types.ZERO_VALUE,
+      old_root_proof: types.ZERO_VALUE,
+      merkle_proof: {
+        path_utxo: new Array(types.treeConfig.utxoDepth).fill(types.ZERO_HEX),
+        path_tx: new Array(types.treeConfig.txDepth).fill(types.ZERO_HEX),
+        path_historic: new Array(types.treeConfig.stateDepth).fill(types.ZERO_HEX),
+        index_utxo: types.ZERO_HEX,
+        index_tx: types.ZERO_HEX,
+        index_historic: types.ZERO_HEX
+      },
+      spend_in_same_batch: false
+    }
+
+    if (!utxo.spend_in_same_batch) utxo.spend_in_same_batch = false;
+    if (!utxo.commitment) utxo.commitment = await this.utxo_to_commitment(utxo);
+    if (!utxo.siblings && !utxo.spend_in_same_batch) utxo.siblings = await this.getSiblingsFromChain(utxo);
+
+    if (utxo.commitment === types.ZERO_VALUE) return empty_utxo_spendable
+    if (utxo.spend_in_same_batch) return {
+      secret: utxo.secret,
+      amount: utxo.amount,
+      asset_type: utxo.asset_type,
+      oracle: types.ZERO_VALUE,
+      old_root_proof: types.ZERO_HEX,
+      merkle_proof: {
+        path_utxo: new Array(types.treeConfig.utxoDepth).fill(types.ZERO_HEX),
+        path_tx: new Array(types.treeConfig.txDepth).fill(types.ZERO_HEX),
+        path_historic: new Array(types.treeConfig.stateDepth).fill(types.ZERO_HEX),
+        index_utxo: types.ZERO_HEX,
+        index_tx: types.ZERO_HEX,
+        index_historic: types.ZERO_HEX
+      },
+      spend_in_same_batch: true
+    }
+    const utxo_tree: MerkleTree = new MerkleTree(
+      types.treeConfig.utxoDepth,
+      utxo.siblings
+    )
+    await utxo_tree.init()
+
+    const old_root: string = (utxo.commitment !== types.ZERO_VALUE && utxo.spend_in_same_batch === false)
+      ? await this.contracts.state.utxoPrevRoots(zeroPadValue(utxo.commitment, 32))
+      : types.ZERO_HEX
+
+    const new_root: string = (old_root === types.ZERO_HEX) ? types.ZERO_HEX : await this.getNewStateRoot(old_root)
+
+    const tx_tree: MerkleTree = await this.getBatchTransactions(old_root)
+      .then(transactions => new MerkleTree(types.treeConfig.txDepth, transactions))
+    await tx_tree.init()
+
+    const utxo_input: types.MerkleProofInput = {
+      leaf: utxo.commitment,
+      tree: utxo_tree
+    }
+    const tx_input: types.MerkleProofInput = {
+      leaf: utxo_tree.root(),
+      tree: tx_tree
+    }
+    const state_input: types.MerkleProofInput = {
+      leaf: new_root,
+      tree: hist_tree
+    }
+
+    const utxo_spendable: types.UTXO_Spendable_Struct = {
+      secret: utxo.secret,
+      amount: utxo.amount,
+      asset_type: utxo.asset_type,
+      oracle: await this.getBatchOracle(old_root),
+      old_root_proof: old_root,
+      merkle_proof: await this._generateMerkleProof(utxo_input, tx_input, state_input),
+      spend_in_same_batch: utxo.spend_in_same_batch
+    }
+
+    return utxo_spendable
+  }
+
+  async _generateUTXOSpendable(utxos?: types.UTXO_Commitment[]): Promise<types.UTXO_Spendable_Struct[]> {
+    const empty_utxo_spendable: types.UTXO_Spendable_Struct = {
+      secret: types.ZERO_HEX,
+      amount: types.ZERO_VALUE,
+      asset_type: types.ZERO_VALUE,
+      oracle: types.ZERO_VALUE,
+      old_root_proof: types.ZERO_VALUE,
+      merkle_proof: {
+        path_utxo: new Array(types.treeConfig.utxoDepth).fill(types.ZERO_HEX),
+        path_tx: new Array(types.treeConfig.txDepth).fill(types.ZERO_HEX),
+        path_historic: new Array(types.treeConfig.stateDepth).fill(types.ZERO_HEX),
+        index_utxo: types.ZERO_HEX,
+        index_tx: types.ZERO_HEX,
+        index_historic: types.ZERO_HEX
+      },
+      spend_in_same_batch: false
+    }
+    const utxo_spendable_empty_array: types.UTXO_Spendable_Struct[] = new Array(16).fill(empty_utxo_spendable)
+    if (!utxos) return utxo_spendable_empty_array;
+
+    const hist_tree: MerkleTree = await this.contracts.state.getValidRoots()
+      .then((roots: any) => new MerkleTree(types.treeConfig.stateDepth, roots))
+    await hist_tree.init()
+
+    let utxo_spendable_array: types.UTXO_Spendable_Struct[] = await Promise.all(
+      utxos.map(utxo => this._generateUTXOSpendableSingle(utxo, hist_tree))
+    )
+
+    utxo_spendable_array = utxo_spendable_array.concat(new Array(16 - utxos.length).fill(empty_utxo_spendable))
+
+    return utxo_spendable_array
+  }
+
+  async getBatchTransactions(old_root: string): Promise<string[]> {
+    const transactions: string[] = await this.contracts.state.queryFilter(
+      this.contracts.state.filters.TransactionPublish(undefined, old_root, undefined)
+    )
+      .then((events: any) => events.map((event: any) => event.args[0].utxo_root))
+    return transactions
+  }
+
+  async getBatchOracle(root: string): Promise<string> {
+    const index = await this.contracts.state.getValidRoots()
+      .then((roots: any) => roots.indexOf(root))
+    const oracle: string = await this.contracts.state.queryFilter(
+      this.contracts.state.filters.BatchPublish(index, undefined, undefined, undefined, undefined)
+    )
+      .then((events: any) => {
+        if (events.length === 0) return Promise.reject("No batch for this root");
+        else return events[0].args[3];
+      })
+    return oracle
+  }
+
+  async _generateTransactionDepositSignature(inputs: types.TransactionInputsRaw): Promise<types.Deposit> {
+    if (!this.config.signer) throw new Error("Signer not initialized");
+    const _domain: types.TypedDataDomain = {
+      name: "Momiji",
+      version: "1",
+      chainId: BigInt(1),
+      verifyingContract: await this.contracts.state.getAddress()
+    }
+    const _types: types.TypedDataTypes = {
+      DepositHash: [
+        { name: "pi_hash", type: "bytes32" }
+      ]
+    }
+    const _values: types.TypedDataValues = {
+      pi_hash: await keccak_tx_no_deposit(
+        inputs.current_root,
+        inputs.deposit_amount,
+        inputs.withdrawals,
+        inputs.utxo_spendable,
+        inputs.utxo_new,
+        inputs.contract_only_inputs
+      ).then(hash => zeroPadValue(hash, 32))
+    }
+    const deposit: types.Deposit = {
+      signature: (BigInt(inputs.deposit_amount) === BigInt(types.ZERO_HEX)) ? "0x00" : await this.config.signer.signTypedData(_domain, _types, _values),
+      pi_hash: inputs.contract_only_inputs.signature_hash
+    }
+    return deposit
+
+  }
+
+  async _generateTransactionContractInputs(inputs: types.TransactionInputsRaw): Promise<types.ContractTransaction> {
+    const formattedInputs = await this._generateFormattedTransactionInputs(inputs)
+    const deposit = await this._generateTransactionDepositSignature(inputs)
+    const contract_inputs: types.ContractTransaction = {
+      current_root: await this.contracts.state.histRoot(),
+      utxo_root: zeroPadValue(formattedInputs.public_inputs.utxo_root, 32),
+      price_limit: zeroPadValue(inputs.contract_only_inputs.price_limit, 32),
+      timestamp: zeroPadValue(inputs.contract_only_inputs.timestamp, 32),
+      deadline: zeroPadValue(inputs.contract_only_inputs.deadline, 32),
+      amount: zeroPadValue(formattedInputs.public_inputs.deposit_amount, 32),
+      encrypted_utxo: inputs.contract_only_inputs.encrypted_utxo
+        .map(utxo => {
+          return {
+            secret: zeroPadValue(utxo.secret, 32),
+            amount: zeroPadValue(utxo.amount, 32),
+            data: zeroPadValue(utxo.data, 32)
+          } as types.EncryptedUTXO
+        }),
+      withdrawals: inputs.withdrawals,
+      commitments_in: formattedInputs.public_inputs.commitment_in.map(c => zeroPadValue(c, 32)),
+      commitments: formattedInputs.public_inputs.commitment_out.map(c => zeroPadValue(c, 32)),
+      recipients: inputs.contract_only_inputs.recipients.map(r => zeroPadValue(r, 32)),
+      nullifier_hashes: formattedInputs.public_inputs.nullifier_hashes.map(hash => zeroPadValue(hash, 32)),
+      uids: inputs.contract_only_inputs.uids.map(uid => zeroPadValue(uid, 32)),
+      swap_amounts: inputs.contract_only_inputs.swap_amounts.map(swap => zeroPadValue(swap, 32)),
+      deposit: deposit
+    }
+    return contract_inputs
+  }
+
+  async _generateTransactionProofArtifacts(inputs: types.TransactionInputsRaw): Promise<types.ProofArtifacts> {
+    const formattedInputs: TransactionInputs = await create_transaction(
+      inputs.current_root,
+      inputs.deposit_amount,
+      inputs.withdrawals,
+      inputs.utxo_spendable,
+      inputs.utxo_new,
+      inputs.contract_only_inputs
+    )
+    const toml = json2toml(formattedInputs)
+    let proof_artifacts: types.ProofArtifacts;
+    let tx_proof = await this.noirs.transaction.execute(formattedInputs)
+      .then(w => this.backends.transaction.generateProof(w.witness)) 
+
+    let artifacts = await this.backends.transaction.generateRecursiveProofArtifacts(tx_proof, 1)
+
+    proof_artifacts = {
+      proofData: tx_proof,
+      proofAsFields: artifacts.proofAsFields,
+      vkAsFields: artifacts.vkAsFields,
+      vkHash: artifacts.vkHash
+    }
+    return proof_artifacts
+  }
+
+  async _generateTransactionProof(
+    utxo_commitments?: types.UTXO_Commitment[],
+    utxo_encrypted?: types.UTXO_Encrypted[],
+    withdrawals?: types.WithdrawalSwap[]
+  ): Promise<types.Transaction> {
+    const inputs: types.TransactionInputsRaw = await this._generateRawTransactionInputs(
+      utxo_commitments,
+      utxo_encrypted,
+      withdrawals
+    )
+    return {
+      public_inputs: await this._generateFormattedTransactionInputs(inputs).then(formatted => formatted.public_inputs),
+      contract_inputs: await this._generateTransactionContractInputs(inputs),
+      proof_artifacts: await this._generateTransactionProofArtifacts(inputs)
+    }
+  }
+
+  async _generateTransactionProofExpert(
+    deposit?: bigint,
+    utxo_commitments?: types.UTXO_Commitment[],
+    utxo_encrypted?: types.UTXO_Encrypted[],
+    withdrawals?: types.WithdrawalSwap[]
+  ): Promise<types.Transaction> {
+    const inputs: types.TransactionInputsRaw = await this._generateRawTransactionInputsExpert(
+      deposit,
+      utxo_commitments,
+      utxo_encrypted,
+      withdrawals
+    )
+    return {
+      public_inputs: await this._generateFormattedTransactionInputs(inputs).then(formatted => formatted.public_inputs),
+      contract_inputs: await this._generateTransactionContractInputs(inputs),
+      proof_artifacts: await this._generateTransactionProofArtifacts(inputs)
+    }
+  }
+
+  async generateTransactions(inputs: types.TransactionIO[]): Promise<types.Transaction[]> {
+    const transactions: types.Transaction[] = new Array(inputs.length)
+    for (let i = 0; i < inputs.length; i++) {
+      console.log(`Transaction proof ${i}`)
+      transactions[i] = await this._generateTransactionProof(
+        inputs[i].utxo_commitment,
+        inputs[i].utxo_encrypted,
+        inputs[i].withdrawal
+      )
+    }
+    return transactions
+  }
+
+  async wrapTransaction(transaction: types.Transaction, txProofArtifacts: types.ProofArtifacts): Promise<Verifier> {
+    const public_inputs_hash: string = await tx_as_hash(transaction.public_inputs)
+    const wrapperInputs: InputMap = {
+      public_inputs_hash: public_inputs_hash,
+      transaction_verifier: {
+        key_hash: txProofArtifacts.vkHash,
+        verification_key: txProofArtifacts.vkAsFields,
+        proof: txProofArtifacts.proofAsFields,
+      }
+    }
+    let tx_aggregation_object: string[]
+    let wrapperArtifacts: types.ProofArtifacts;
+    let wrapper_proof = await this.noirs.transaction_wrapper.execute(wrapperInputs)
+      .then((wrapper_witness: any) => this.backends.transaction_wrapper.generateProof(wrapper_witness.witness));
+
+    tx_aggregation_object = wrapper_proof.publicInputs.slice(1);
+    let artifacts = await this.backends.transaction_wrapper.generateRecursiveProofArtifacts(wrapper_proof, 17);
+    wrapperArtifacts = {
+      proofData: wrapper_proof,
+      proofAsFields: artifacts.proofAsFields,
+      vkAsFields: artifacts.vkAsFields,
+      vkHash: artifacts.vkHash
+    }
+
+    const txWrapperVerifier: Verifier = {
+      key_hash: wrapperArtifacts.vkHash,
+      proof: wrapperArtifacts.proofAsFields,
+      verification_key: wrapperArtifacts.vkAsFields,
+      aggregation_object: tx_aggregation_object
+    }
+    txWrapperVerifier.proof = tx_aggregation_object.concat(txWrapperVerifier.proof)
+    return txWrapperVerifier
+  }
+
+}
\ No newline at end of file

momiji-helpers/utils/transaction_circuits.ts

+import { CompiledCircuit } from "@noir-lang/noir_js";
+export const transaction: CompiledCircuit = {
+    "abi": {
+        "parameters": [
+            {
+                "name": "public_inputs_hash",
+                "type": {
+                    "kind": "field"
+                },
+                "visibility": "public"
+            },
+            {
+                "name": "public_inputs",
+                "type": {
+                    "kind": "struct",
+                    "path": "helpers::structs::PublicInputs",
+                    "fields": [
+                        {
+                            "name": "current_root",
+                            "type": {
+                                "kind": "field"
+                            }
+                        },
+                        {
+                            "name": "utxo_root",
+                            "type": {
+                                "kind": "field"
+                            }
+                        },
+                        {
+                            "name": "deposit_amount",
+                            "type": {
+                                "kind": "field"
+                            }
+                        },
+                        {
+                            "name": "withdrawals",
+                            "type": {
+                                "kind": "field"
+                            }
+                        },
+                        {
+                            "name": "commitment_in",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "commitment_out",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "nullifier_hashes",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "contract_only_inputs",
+                            "type": {
+                                "kind": "field"
+                            }
+                        }
+                    ]
+                },
+                "visibility": "private"
+            },
+            {
+                "name": "private_inputs",
+                "type": {
+                    "kind": "struct",
+                    "path": "helpers::structs::PrivateInputs",
+                    "fields": [
+                        {
+                            "name": "oracle",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "old_root_proof",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "secrets",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "utxo_in",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "struct",
+                                    "path": "helpers::structs::UTXO",
+                                    "fields": [
+                                        {
+                                            "name": "owner",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "amount",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "asset_type",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "name": "merkle_proofs",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "struct",
+                                    "path": "helpers::structs::MerkleProof",
+                                    "fields": [
+                                        {
+                                            "name": "path_utxo",
+                                            "type": {
+                                                "kind": "array",
+                                                "length": 4,
+                                                "type": {
+                                                    "kind": "field"
+                                                }
+                                            }
+                                        },
+                                        {
+                                            "name": "path_tx",
+                                            "type": {
+                                                "kind": "array",
+                                                "length": 4,
+                                                "type": {
+                                                    "kind": "field"
+                                                }
+                                            }
+                                        },
+                                        {
+                                            "name": "path_historic",
+                                            "type": {
+                                                "kind": "array",
+                                                "length": 20,
+                                                "type": {
+                                                    "kind": "field"
+                                                }
+                                            }
+                                        },
+                                        {
+                                            "name": "index_utxo",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "index_tx",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "index_historic",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "name": "utxo_out",
+                            "type": {
+                                "kind": "array",
+                                "length": 16,
+                                "type": {
+                                    "kind": "struct",
+                                    "path": "helpers::structs::UTXO",
+                                    "fields": [
+                                        {
+                                            "name": "owner",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "amount",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        },
+                                        {
+                                            "name": "asset_type",
+                                            "type": {
+                                                "kind": "field"
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    ]
+                },
+                "visibility": "private"
+            }
+        ],
+        "param_witnesses": {
+            "private_inputs": [
+                {
+                    "start": 54,
+                    "end": 694
+                }
+            ],
+            "public_inputs": [
+                {
+                    "start": 1,
+                    "end": 54
+                }
+            ],
+            "public_inputs_hash": [
+                {
+                    "start": 0,
+                    "end": 1
+                }
+            ]
+        },
+        "return_type": null,
+        "return_witnesses": []
+    },
+    "bytecode": "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"
+};
+
+export const transaction_wrapper: CompiledCircuit = {
+    "abi": {
+        "parameters": [
+            {
+                "name": "public_inputs_hash",
+                "type": {
+                    "kind": "field"
+                },
+                "visibility": "public"
+            },
+            {
+                "name": "transaction_verifier",
+                "type": {
+                    "kind": "struct",
+                    "path": "helpers::structs::VerifierTx",
+                    "fields": [
+                        {
+                            "name": "key_hash",
+                            "type": {
+                                "kind": "field"
+                            }
+                        },
+                        {
+                            "name": "verification_key",
+                            "type": {
+                                "kind": "array",
+                                "length": 114,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        },
+                        {
+                            "name": "proof",
+                            "type": {
+                                "kind": "array",
+                                "length": 93,
+                                "type": {
+                                    "kind": "field"
+                                }
+                            }
+                        }
+                    ]
+                },
+                "visibility": "private"
+            }
+        ],
+        "param_witnesses": {
+            "public_inputs_hash": [
+                {
+                    "start": 0,
+                    "end": 1
+                }
+            ],
+            "transaction_verifier": [
+                {
+                    "start": 1,
+                    "end": 209
+                }
+            ]
+        },
+        "return_type": null,
+        "return_witnesses": []
+    },
+    "bytecode": "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"
+};
+
+export const txVk: string[] = ["0x2e592c2ade5527a4aaa1a68b75bdff97876a8bc89c8d41a704f1e2b23a82b698", "0x19ddbcaf3a8d46c15c0176fbb5b95e4dc57088ff13f4d1bd84c6bfa57dcdc0e0", "0x0000000000000000000000000000000000000000000000000000000000040000", "0x0000000000000000000000000000000000000000000000000000000000000005", "0x0000000000000000000000000000000000000000000000000000000000040000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000002a8e4638fe890cb43aca194c43c794c145", "0x00000000000000000000000000000000000fc379c77a020ebe6facbad763de76", "0x000000000000000000000000000000eeb6057fa6ac1da4b77880242c8c3b05c9", "0x0000000000000000000000000000000000297cfb0a0650b7ed60ddb1c63a15e6", "0x000000000000000000000000000000ce88227a4bf7754b638b9237a9bc5fe3da", "0x0000000000000000000000000000000000236dceba50da931a369c4be1401026", "0x000000000000000000000000000000728c97969f92c442167450b9ef6ac18d9c", "0x0000000000000000000000000000000000264b94274f11d130fcdb1ddf507f33", "0x0000000000000000000000000000004301542287a1e249b63089dcfa48498644", "0x0000000000000000000000000000000000227ddd84179aac0294c9163b990cb7", "0x000000000000000000000000000000a2a4d84c82bf735b5c1b3858023151ef2a", "0x00000000000000000000000000000000000e7057cad36abe675d10c487eecb24", "0x0000000000000000000000000000004976a738a8f7b23aab0cf7f6f911c2b4d6", "0x0000000000000000000000000000000000056a2544ff213cdf11f5eb671c62ca", "0x000000000000000000000000000000e67ff9fbedee8d0a7f9f690b214ca64484", "0x0000000000000000000000000000000000215d4a78379930402b628e6856fcdf", "0x0000000000000000000000000000002fec1fa4dd765e6a0aacc5a9b921d4bc9a", "0x0000000000000000000000000000000000227a63de3b66cdce0e299d8ef18908", "0x00000000000000000000000000000019097eb1909f84949efa64912166db0f9e", "0x00000000000000000000000000000000002aa055b0785af28e6a415c5aa30b59", "0x0000000000000000000000000000008dfcaf909c6e19977027cac02866068624", "0x000000000000000000000000000000000010299e08de0cbd3b5073c4f9ed0a03", "0x000000000000000000000000000000b92e0032b2f62145978a0523936f4b17b4", "0x00000000000000000000000000000000000282e1565f5f1b49267d76f5e8d061", "0x0000000000000000000000000000008972e372748f5b508cb8f5bb3ef8e50280", "0x000000000000000000000000000000000018c81e10aaa2c8645e5fa5de02ce4f", "0x0000000000000000000000000000009f58065ce4bfacc7ebc9a3efcaf7e2df8a", "0x00000000000000000000000000000000000f032bf323ffa61eb61f2c0e2d0e64", "0x000000000000000000000000000000b1958c9a035ec70f483be5d660ff5bbfc7", "0x00000000000000000000000000000000000aa01c4d94918f12fdb472e0a48c6a", "0x000000000000000000000000000000dbca85061f0cbc80faec1d4172c4950eae", "0x0000000000000000000000000000000000016cca75f7649a48d54f13201425ab", "0x000000000000000000000000000000cb98ffdd6c305efe2b96de6052bb928cb9", "0x000000000000000000000000000000000006698cb6b134db7043bb0a19772df1", "0x00000000000000000000000000000065df11b87c6a8edbbf1a3e2d307870e124", "0x00000000000000000000000000000000002f9e8b045390ff035dd03626890011", "0x000000000000000000000000000000ee587a3108b7b7f3bca8aad8a29233ad1c", "0x00000000000000000000000000000000001bed1483f3b48d1edfd50fe8107d8d", "0x000000000000000000000000000000b1c8e58aa7f9bcfa6130fd93ba7aab9362", "0x000000000000000000000000000000000028d9eb2b3b0a612043278aaa2a2c44", "0x0000000000000000000000000000002c2d9a3de66255084a4bb7730f65ef8c1a", "0x0000000000000000000000000000000000044564fba61d2ea7c2f453b84cb185", "0x00000000000000000000000000000099d2fbb99c623d9123be965199f8cb5d3b", "0x000000000000000000000000000000000015f52ff3f4ce480955c71fb245313e", "0x00000000000000000000000000000011ea2fc35f4045603afc750534c08dd373", "0x00000000000000000000000000000000001cfb8d903a6634fa0e6a242e51a831", "0x000000000000000000000000000000e79549b3f91a371da96d0e8da4b358fa4d", "0x00000000000000000000000000000000001cdfaca9f18fcd5d01020f2e670724", "0x000000000000000000000000000000e4bfc9c2c620a1838eed970f550198579d", "0x00000000000000000000000000000000001ba0949ff199218bc6807cbf372621", "0x00000000000000000000000000000002ab1af04948521d990480572148201ad7", "0x000000000000000000000000000000000024c4985645b110cc8ff358e8fbd533", "0x0000000000000000000000000000006c591a583a07e9d00466445ccaf56eef4b", "0x0000000000000000000000000000000000287dab85bc4dbc397de6ce17a70c2c", "0x000000000000000000000000000000fdfac2966f06782c46e83e62a0ed3f9f36", "0x0000000000000000000000000000000000056a4a40511eba9e7733d56791970a", "0x000000000000000000000000000000da65d2bda0fbe3f3fba50e51e64b8834b0", "0x00000000000000000000000000000000001e4d70a799e115231b6bade5b5c0a1", "0x000000000000000000000000000000dbd23932a54bed3f89432635503222faa9", "0x00000000000000000000000000000000002fe8339867a24a287e0ac43003856e", "0x000000000000000000000000000000bdec694d9ed21e653c9e407cb9819a65d6", "0x0000000000000000000000000000000000055ed855db256e5b4f8a06c1efb875", "0x00000000000000000000000000000003f1f66e07d1ffb03288efecacf884cb55", "0x00000000000000000000000000000000001ee61fb43eecca1e6de550ef663662", "0x0000000000000000000000000000006a91cb9b127b4df21a841b3d522e20cbb3", "0x000000000000000000000000000000000014b7078c4edeb2d7bfa70fe8f45387", "0x0000000000000000000000000000004bdc4a150e56380a29758003563dcb8abb", "0x0000000000000000000000000000000000215cbdfcaac938aca1d60562f8ee94", "0x0000000000000000000000000000009d1efca3006a8f2f62e82269704a080668", "0x0000000000000000000000000000000000217044aeae4265324cae6b6497135d", "0x000000000000000000000000000000648414f086df6a6d51c5fcc682e1d236fd", "0x000000000000000000000000000000000019b82be10a8ce8bc808b3f4a68eb62", "0x000000000000000000000000000000a9ab3db5fc581680802619b5ef2bcc0dd8", "0x0000000000000000000000000000000000192d388bd495bed2e5e9ba5cf2e162", "0x0000000000000000000000000000000d841571d0d8f6c515d6a89878008e0e71", "0x0000000000000000000000000000000000137c5ef4cd039774daf5897a894ca0", "0x000000000000000000000000000000f491336163c054d1fda0e7d6d205ac3d51", "0x00000000000000000000000000000000002a3d9e1d726f057480b18c3e768b7d", "0x000000000000000000000000000000abaf8de11e9c38874587792459a10ac601", "0x00000000000000000000000000000000000d0c9f725f52c7de5af92d699a4679", "0x0000000000000000000000000000009ad52f5fd10d116b84c23afad5654a4634", "0x000000000000000000000000000000000011366ef4cc5ca4043f9ebecd45938c", "0x0000000000000000000000000000005b0e3524d14b0499abb7019191c6c2d968", "0x00000000000000000000000000000000002000ff961349d9c559fd25e1b68156", "0x000000000000000000000000000000ac2b6e35506e7b4ab39165c78a9e22f959", "0x000000000000000000000000000000000015544496733c4c498deeb2093f7e63", "0x000000000000000000000000000000be09ebbd30043936e78435dd3f50cc6ac3", "0x000000000000000000000000000000000002d26517af1fdf0b77a5c31840d282", "0x0000000000000000000000000000007ff81caf53b14e78d558f322f923ec3967", "0x00000000000000000000000000000000002b3912052d2f780d0e1eae7ee01bdb", "0x0000000000000000000000000000001bda48577269dfcf7b4a75228d8e7c6325", "0x000000000000000000000000000000000002c116ba8b423ace60212194aefe73"]
\ No newline at end of file

momiji-helpers/utils/typechain-types/@chainlink/contracts/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as src from "./src";
+export type { src };

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as v08 from "./v0.8";
+export type { v08 };

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/v0.8/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as interfaces from "./interfaces";
+export type { interfaces };

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../../../common";
+
+export interface AggregatorInterfaceInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "getAnswer"
+      | "getTimestamp"
+      | "latestAnswer"
+      | "latestRound"
+      | "latestTimestamp"
+  ): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "AnswerUpdated" | "NewRound"): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getAnswer",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTimestamp",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestAnswer",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRound",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestTimestamp",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "getAnswer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getTimestamp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestAnswer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRound",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestTimestamp",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace AnswerUpdatedEvent {
+  export type InputTuple = [
+    current: BigNumberish,
+    roundId: BigNumberish,
+    updatedAt: BigNumberish
+  ];
+  export type OutputTuple = [
+    current: bigint,
+    roundId: bigint,
+    updatedAt: bigint
+  ];
+  export interface OutputObject {
+    current: bigint;
+    roundId: bigint;
+    updatedAt: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace NewRoundEvent {
+  export type InputTuple = [
+    roundId: BigNumberish,
+    startedBy: AddressLike,
+    startedAt: BigNumberish
+  ];
+  export type OutputTuple = [
+    roundId: bigint,
+    startedBy: string,
+    startedAt: bigint
+  ];
+  export interface OutputObject {
+    roundId: bigint;
+    startedBy: string;
+    startedAt: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface AggregatorInterface extends BaseContract {
+  connect(runner?: ContractRunner | null): AggregatorInterface;
+  waitForDeployment(): Promise<this>;
+
+  interface: AggregatorInterfaceInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getAnswer: TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+
+  getTimestamp: TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+
+  latestAnswer: TypedContractMethod<[], [bigint], "view">;
+
+  latestRound: TypedContractMethod<[], [bigint], "view">;
+
+  latestTimestamp: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getAnswer"
+  ): TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getTimestamp"
+  ): TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestAnswer"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestRound"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestTimestamp"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "AnswerUpdated"
+  ): TypedContractEvent<
+    AnswerUpdatedEvent.InputTuple,
+    AnswerUpdatedEvent.OutputTuple,
+    AnswerUpdatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "NewRound"
+  ): TypedContractEvent<
+    NewRoundEvent.InputTuple,
+    NewRoundEvent.OutputTuple,
+    NewRoundEvent.OutputObject
+  >;
+
+  filters: {
+    "AnswerUpdated(int256,uint256,uint256)": TypedContractEvent<
+      AnswerUpdatedEvent.InputTuple,
+      AnswerUpdatedEvent.OutputTuple,
+      AnswerUpdatedEvent.OutputObject
+    >;
+    AnswerUpdated: TypedContractEvent<
+      AnswerUpdatedEvent.InputTuple,
+      AnswerUpdatedEvent.OutputTuple,
+      AnswerUpdatedEvent.OutputObject
+    >;
+
+    "NewRound(uint256,address,uint256)": TypedContractEvent<
+      NewRoundEvent.InputTuple,
+      NewRoundEvent.OutputTuple,
+      NewRoundEvent.OutputObject
+    >;
+    NewRound: TypedContractEvent<
+      NewRoundEvent.InputTuple,
+      NewRoundEvent.OutputTuple,
+      NewRoundEvent.OutputObject
+    >;
+  };
+}

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../../../common";
+
+export interface AggregatorV2V3InterfaceInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "decimals"
+      | "description"
+      | "getAnswer"
+      | "getRoundData"
+      | "getTimestamp"
+      | "latestAnswer"
+      | "latestRound"
+      | "latestRoundData"
+      | "latestTimestamp"
+      | "version"
+  ): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "AnswerUpdated" | "NewRound"): EventFragment;
+
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "description",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAnswer",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoundData",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTimestamp",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestAnswer",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRound",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRoundData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestTimestamp",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "version", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "description",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getAnswer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getTimestamp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestAnswer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRound",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestTimestamp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+
+export namespace AnswerUpdatedEvent {
+  export type InputTuple = [
+    current: BigNumberish,
+    roundId: BigNumberish,
+    updatedAt: BigNumberish
+  ];
+  export type OutputTuple = [
+    current: bigint,
+    roundId: bigint,
+    updatedAt: bigint
+  ];
+  export interface OutputObject {
+    current: bigint;
+    roundId: bigint;
+    updatedAt: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace NewRoundEvent {
+  export type InputTuple = [
+    roundId: BigNumberish,
+    startedBy: AddressLike,
+    startedAt: BigNumberish
+  ];
+  export type OutputTuple = [
+    roundId: bigint,
+    startedBy: string,
+    startedAt: bigint
+  ];
+  export interface OutputObject {
+    roundId: bigint;
+    startedBy: string;
+    startedAt: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface AggregatorV2V3Interface extends BaseContract {
+  connect(runner?: ContractRunner | null): AggregatorV2V3Interface;
+  waitForDeployment(): Promise<this>;
+
+  interface: AggregatorV2V3InterfaceInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  decimals: TypedContractMethod<[], [bigint], "view">;
+
+  description: TypedContractMethod<[], [string], "view">;
+
+  getAnswer: TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+
+  getRoundData: TypedContractMethod<
+    [_roundId: BigNumberish],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+
+  getTimestamp: TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+
+  latestAnswer: TypedContractMethod<[], [bigint], "view">;
+
+  latestRound: TypedContractMethod<[], [bigint], "view">;
+
+  latestRoundData: TypedContractMethod<
+    [],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+
+  latestTimestamp: TypedContractMethod<[], [bigint], "view">;
+
+  version: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "decimals"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "description"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getAnswer"
+  ): TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getRoundData"
+  ): TypedContractMethod<
+    [_roundId: BigNumberish],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getTimestamp"
+  ): TypedContractMethod<[roundId: BigNumberish], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestAnswer"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestRound"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "latestRoundData"
+  ): TypedContractMethod<
+    [],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "latestTimestamp"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "version"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "AnswerUpdated"
+  ): TypedContractEvent<
+    AnswerUpdatedEvent.InputTuple,
+    AnswerUpdatedEvent.OutputTuple,
+    AnswerUpdatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "NewRound"
+  ): TypedContractEvent<
+    NewRoundEvent.InputTuple,
+    NewRoundEvent.OutputTuple,
+    NewRoundEvent.OutputObject
+  >;
+
+  filters: {
+    "AnswerUpdated(int256,uint256,uint256)": TypedContractEvent<
+      AnswerUpdatedEvent.InputTuple,
+      AnswerUpdatedEvent.OutputTuple,
+      AnswerUpdatedEvent.OutputObject
+    >;
+    AnswerUpdated: TypedContractEvent<
+      AnswerUpdatedEvent.InputTuple,
+      AnswerUpdatedEvent.OutputTuple,
+      AnswerUpdatedEvent.OutputObject
+    >;
+
+    "NewRound(uint256,address,uint256)": TypedContractEvent<
+      NewRoundEvent.InputTuple,
+      NewRoundEvent.OutputTuple,
+      NewRoundEvent.OutputObject
+    >;
+    NewRound: TypedContractEvent<
+      NewRoundEvent.InputTuple,
+      NewRoundEvent.OutputTuple,
+      NewRoundEvent.OutputObject
+    >;
+  };
+}

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../../../common";
+
+export interface AggregatorV3InterfaceInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "decimals"
+      | "description"
+      | "getRoundData"
+      | "latestRoundData"
+      | "version"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "description",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoundData",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "latestRoundData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "version", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "description",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "latestRoundData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+
+export interface AggregatorV3Interface extends BaseContract {
+  connect(runner?: ContractRunner | null): AggregatorV3Interface;
+  waitForDeployment(): Promise<this>;
+
+  interface: AggregatorV3InterfaceInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  decimals: TypedContractMethod<[], [bigint], "view">;
+
+  description: TypedContractMethod<[], [string], "view">;
+
+  getRoundData: TypedContractMethod<
+    [_roundId: BigNumberish],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+
+  latestRoundData: TypedContractMethod<
+    [],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+
+  version: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "decimals"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "description"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoundData"
+  ): TypedContractMethod<
+    [_roundId: BigNumberish],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "latestRoundData"
+  ): TypedContractMethod<
+    [],
+    [
+      [bigint, bigint, bigint, bigint, bigint] & {
+        roundId: bigint;
+        answer: bigint;
+        startedAt: bigint;
+        updatedAt: bigint;
+        answeredInRound: bigint;
+      }
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "version"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  filters: {};
+}

momiji-helpers/utils/typechain-types/@chainlink/contracts/src/v0.8/interfaces/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { AggregatorInterface } from "./AggregatorInterface";
+export type { AggregatorV2V3Interface } from "./AggregatorV2V3Interface";
+export type { AggregatorV3Interface } from "./AggregatorV3Interface";

momiji-helpers/utils/typechain-types/@chainlink/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as contracts from "./contracts";
+export type { contracts };

momiji-helpers/utils/typechain-types/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../common";
+
+export interface OwnableUpgradeableInterface extends Interface {
+  getFunction(
+    nameOrSignature: "owner" | "renounceOwnership" | "transferOwnership"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "OwnershipTransferred"
+  ): EventFragment;
+
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "renounceOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "renounceOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace OwnershipTransferredEvent {
+  export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+  export type OutputTuple = [previousOwner: string, newOwner: string];
+  export interface OutputObject {
+    previousOwner: string;
+    newOwner: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface OwnableUpgradeable extends BaseContract {
+  connect(runner?: ContractRunner | null): OwnableUpgradeable;
+  waitForDeployment(): Promise<this>;
+
+  interface: OwnableUpgradeableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  owner: TypedContractMethod<[], [string], "view">;
+
+  renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+
+  transferOwnership: TypedContractMethod<
+    [newOwner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "owner"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "renounceOwnership"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "transferOwnership"
+  ): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "OwnershipTransferred"
+  ): TypedContractEvent<
+    OwnershipTransferredEvent.InputTuple,
+    OwnershipTransferredEvent.OutputTuple,
+    OwnershipTransferredEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "OwnershipTransferred(address,address)": TypedContractEvent<
+      OwnershipTransferredEvent.InputTuple,
+      OwnershipTransferredEvent.OutputTuple,
+      OwnershipTransferredEvent.OutputObject
+    >;
+    OwnershipTransferred: TypedContractEvent<
+      OwnershipTransferredEvent.InputTuple,
+      OwnershipTransferredEvent.OutputTuple,
+      OwnershipTransferredEvent.OutputObject
+    >;
+  };
+}

momiji-helpers/utils/typechain-types/@openzeppelin/contracts-upgradeable/access/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { OwnableUpgradeable } from "./OwnableUpgradeable";

momiji-helpers/utils/typechain-types/@openzeppelin/contracts-upgradeable/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as access from "./access";
+export type { access };
+import type * as proxy from "./proxy";
+export type { proxy };
+import type * as utils from "./utils";
+export type { utils };

momiji-helpers/utils/typechain-types/@openzeppelin/contracts-upgradeable/proxy/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as utils from "./utils";
+export type { utils };