diff --git a/.env b/.env index 92cfff0..0cf49ba 100644 --- a/.env +++ b/.env @@ -1,2 +1,2 @@ # The version of the Inco Lightning test docker images to use -DOCKER_IMAGE_TAG=v3-33-gc708d2f +DOCKER_IMAGE_TAG=v0.6.9 \ No newline at end of file diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 7418456..fc42c7f 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -23,4 +23,4 @@ jobs: uses: foundry-rs/foundry-toolchain@v1 - run: bun install - - run: bun run test + - run: bun run test \ No newline at end of file diff --git a/backend/src/generated/abis.ts b/backend/src/generated/abis.ts index c2a72f5..319dfd2 100644 --- a/backend/src/generated/abis.ts +++ b/backend/src/generated/abis.ts @@ -14,11 +14,8 @@ export const addTwoAbi = [ type: 'function', inputs: [{ name: 'uint256EInput', internalType: 'bytes', type: 'bytes' }], name: 'addTwoEOA', - outputs: [ - { name: '', internalType: 'uint256', type: 'uint256' }, - { name: '', internalType: 'euint256', type: 'bytes32' }, - ], - stateMutability: 'nonpayable', + outputs: [{ name: 'result', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'payable', }, { type: 'function', @@ -27,23 +24,599 @@ export const addTwoAbi = [ outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], stateMutability: 'nonpayable', }, + { + type: 'function', + inputs: [], + name: 'getFee', + outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }], + stateMutability: 'pure', + }, + { type: 'error', inputs: [], name: 'FeeNotPaid' }, +] as const + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// LibTest +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +export const libTestAbi = [ { type: 'function', inputs: [ - { name: '', internalType: 'uint256', type: 'uint256' }, - { name: 'result', internalType: 'uint256', type: 'uint256' }, - { name: '', internalType: 'bytes', type: 'bytes' }, + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, ], - name: 'callback', - outputs: [], + name: 'testAdd', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testAddScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testAnd', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'ebool', type: 'bytes32' }, + ], + name: 'testAndBool', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'bool', type: 'bool' }, + ], + name: 'testAndBoolScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testAndScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testDiv', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testDivScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testEq', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'eaddress', type: 'bytes32' }, + { name: 'b', internalType: 'eaddress', type: 'bytes32' }, + ], + name: 'testEqAddress', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'eaddress', type: 'bytes32' }, + { name: 'b', internalType: 'address', type: 'address' }, + ], + name: 'testEqAddressScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testEqScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testGe', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testGeScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testGt', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testGtScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testLe', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testLeScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testLt', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testLtScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testMax', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testMaxScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testMin', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testMinScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testMul', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testMulScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testNe', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'eaddress', type: 'bytes32' }, + { name: 'b', internalType: 'eaddress', type: 'bytes32' }, + ], + name: 'testNeAddress', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'eaddress', type: 'bytes32' }, + { name: 'b', internalType: 'address', type: 'address' }, + ], + name: 'testNeAddressScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testNeScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'ciphertext', internalType: 'bytes', type: 'bytes' }, + { name: 'user', internalType: 'address', type: 'address' }, + ], + name: 'testNewEaddress', + outputs: [{ name: '', internalType: 'eaddress', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [ + { name: 'ciphertext', internalType: 'bytes', type: 'bytes' }, + { name: 'user', internalType: 'address', type: 'address' }, + ], + name: 'testNewEbool', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [ + { name: 'ciphertext', internalType: 'bytes', type: 'bytes' }, + { name: 'user', internalType: 'address', type: 'address' }, + ], + name: 'testNewEuint256', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [{ name: 'a', internalType: 'ebool', type: 'bytes32' }], + name: 'testNot', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testOr', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'ebool', type: 'bytes32' }, + ], + name: 'testOrBool', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'bool', type: 'bool' }, + ], + name: 'testOrBoolScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testOrScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], stateMutability: 'nonpayable', }, { type: 'function', inputs: [], - name: 'lastResult', - outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }], - stateMutability: 'view', + name: 'testRand', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [{ name: 'upperBound', internalType: 'uint256', type: 'uint256' }], + name: 'testRandBounded', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [{ name: 'upperBound', internalType: 'euint256', type: 'bytes32' }], + name: 'testRandBoundedEncrypted', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'payable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testRem', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testRemScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [{ name: 'a', internalType: 'eaddress', type: 'bytes32' }], + name: 'testRevealEAddress', + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [{ name: 'a', internalType: 'ebool', type: 'bytes32' }], + name: 'testRevealEBool', + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [{ name: 'a', internalType: 'euint256', type: 'bytes32' }], + name: 'testRevealEUint', + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testRotl', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testRotlScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testRotr', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testRotrScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testShl', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testShlScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testShr', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testShrScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testSub', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testSubScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'euint256', type: 'bytes32' }, + ], + name: 'testXor', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'ebool', type: 'bytes32' }, + ], + name: 'testXorBool', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'ebool', type: 'bytes32' }, + { name: 'b', internalType: 'bool', type: 'bool' }, + ], + name: 'testXorBoolScalar', + outputs: [{ name: '', internalType: 'ebool', type: 'bytes32' }], + stateMutability: 'nonpayable', + }, + { + type: 'function', + inputs: [ + { name: 'a', internalType: 'euint256', type: 'bytes32' }, + { name: 'b', internalType: 'uint256', type: 'uint256' }, + ], + name: 'testXorScalar', + outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }], + stateMutability: 'nonpayable', }, ] as const diff --git a/backend/src/test/lightning-addtwo.ts b/backend/src/test/lightning-addtwo.ts new file mode 100644 index 0000000..9ed92dd --- /dev/null +++ b/backend/src/test/lightning-addtwo.ts @@ -0,0 +1,176 @@ +import { HexString, parseAddress } from '@inco/js'; +import { incoVerifierAbi } from '@inco/js/abis/verifier'; +import { Lightning } from '@inco/js/lite'; +import { + type Account, + type Address, + type Chain, + createPublicClient, + createWalletClient, + getContract, + type Hex, + http, + parseEther, + type PublicClient, + type Transport, + type WalletClient, +} from 'viem'; +import { privateKeyToAccount } from 'viem/accounts'; +import { beforeAll, describe, expect, it } from 'vitest'; +import addTwoBuild from '../../../contracts/out/AddTwo.sol/AddTwo.json'; +import { addTwoAbi } from '../generated/abis.js'; +import { type E2EConfig, type E2EParams } from './lightning-test.js'; + +export function runAddTwoE2ETest(zap: Lightning, cfg: E2EConfig,params: E2EParams) { + const { walletClient, publicClient, incoLite } = params; + const valueToAdd = Math.floor(Math.random() * 100); + + describe('Lightning AddTwo E2E', () => { + let dappAddress: Address; + + beforeAll(async () => { + console.warn('###############################################'); + console.warn(`# Step 0. Deploy the AddTwo contract`); + console.warn('###############################################'); + dappAddress = await deployAddTwo(cfg); + console.warn(`AddTwo contract deployed at ${dappAddress}`); + console.warn('Running this test has some prerequisites:'); + console.warn(`- The IncoLite contract ${zap.executorAddress} must be deployed on ${cfg.chain.name}`); + console.warn(`- The dapp contract ${dappAddress} must be deployed on ${cfg.chain.name}`); + console.warn( + `- The sender ${privateKeyToAccount(cfg.senderPrivKey).address} must have some ${cfg.chain.name} tokens`, + ); + }, 100_000); + + it('should read from the decrypted message', async () => { + const incoVerifierAddress = await incoLite.read.incoVerifier(); + const incoVerifier = getContract({ + abi: incoVerifierAbi, + address: incoVerifierAddress, + client: publicClient, + }); + const eciesKey = await incoVerifier.read.eciesPubkey(); + const encryptor = zap.getEncryptor(eciesKey); + + const inputCt = await zap.encrypt( + valueToAdd, + { + accountAddress: walletClient.account.address, + dappAddress, + }, + encryptor, + ); + const { resultHandle } = await addTwo(dappAddress, inputCt, walletClient, publicClient, cfg); + console.log(`Result handle: ${resultHandle}`); + const decrypted = await zap.attestedDecrypt(walletClient as any, [resultHandle]); + const result = decrypted[0]?.plaintext?.value; + console.log(`Result:`, result); + expect(result).toBe(BigInt(valueToAdd + 2)); + }, 20_000); + + it('should reencrypt a message', async () => { + // Step 3. + console.warn('###############################################'); + console.warn(`# Step 3. Reencrypt the result handle`); + console.warn('###############################################'); + console.warn(`# Using covalidator ${zap.covalidatorUrl}`); + // const reencryptor = await zap.getReencryptor(walletClient); + // const decrypted = await reencryptor({ handle: resultHandle }); + // expect(decrypted.value).toBe(BigInt(valueToAdd + 2)); + }, 10_000); + }); +} + +// Sends a tx on the host chain to call `addTwo`. +async function addTwo( + dappAddress: Address, + inputCt: HexString, + walletClient: WalletClient, + publicClient: PublicClient, + cfg: E2EConfig, +): Promise<{ resultHandle: HexString }> { + const chain = cfg.chain; + console.log(); + console.log('###############################################'); + console.log(`# Step 2. Send a tx to ${chain.name}`); + console.log('###############################################'); + + const dapp = getContract({ + abi: addTwoAbi, + address: dappAddress, + client: walletClient, + }); + + console.log(`Simulating the call to add 2 to ${prettifyInputCt(inputCt)}`); + const { result: resultHandle } = await dapp.simulate.addTwoEOA([inputCt], { value: parseEther('0.001') }); + + if (!resultHandle) { + throw new Error('Failed to get resultHandle from simulation'); + } + console.log(`Result handle: ${resultHandle}`); + + console.log(); + console.log(`Calling the dapp contract to add 2 to ${prettifyInputCt(inputCt)}`); + // With some testing, we found that 300000 gas is enough for this tx. + // ref: https://testnet.monadexplorer.com/tx/0x562e301221c942c50c758076d67bef85c41cd51def9d8f4ad2d514aa8ab5f74d + // ref: https://sepolia.basescan.org/tx/0x9141788e279a80571b0b5fcf203a7dc6599b6a3ad14fd3353e51089dc3c870a6 + const txHash = await dapp.write.addTwoEOA([inputCt], { gas: BigInt(300000), value: parseEther('0.001') }); + console.log(`Tx submitted: ${chain.blockExplorers?.default.url ?? 'no-explorer'}/tx/${txHash}`); + + console.log(); + console.log('Waiting for tx to be included in a block...'); + const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash }); + console.log(`Transaction included in block ${receipt.blockNumber}`); + + return { resultHandle: resultHandle as HexString }; +} + +// Deploys the AddTwo.sol contract on the host chain. +async function deployAddTwo(cfg: E2EConfig): Promise
{ + console.log(); + console.log(`Deploying AddTwo.sol contract ...`); + await fundAccount(cfg.senderPrivKey, cfg.chain, cfg.hostChainRpcUrl); + const account = privateKeyToAccount(cfg.senderPrivKey); + const walletClient = createWalletClient({ + chain: cfg.chain, + transport: http(cfg.hostChainRpcUrl), + }); + + const byteCode = addTwoBuild.bytecode.object as Hex; + const txHash = await walletClient.deployContract({ + account, + abi: addTwoAbi, + bytecode: byteCode, + }); + + const publicClient = createPublicClient({ + chain: cfg.chain, + transport: http(cfg.hostChainRpcUrl), + }); + const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash }); + + const contractAddress = receipt.contractAddress; + if (!contractAddress) { + throw new Error('Contract address not found in the transaction receipt'); + } + console.log(`Deployed AddTwo.sol contract at ${contractAddress}`); + return parseAddress(contractAddress); +} + +function prettifyInputCt(hex: HexString): string { + return `${hex.slice(0, 8)}...${hex.slice(-6)}`; +} + +async function fundAccount(senderPrivKey: Hex, chain: Chain, hostChainRpcUrl: string) { + const richAccount = privateKeyToAccount('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'); + const account = privateKeyToAccount(senderPrivKey); + const richWalletClient = createWalletClient({ + chain, + transport: http(hostChainRpcUrl), + }); + await richWalletClient.sendTransaction({ + account: richAccount, + to: account.address, + value: parseEther('1'), + }); +} diff --git a/backend/src/test/lightning-libtest.ts b/backend/src/test/lightning-libtest.ts new file mode 100644 index 0000000..b6d63cb --- /dev/null +++ b/backend/src/test/lightning-libtest.ts @@ -0,0 +1,505 @@ +import { handleTypes, HexString, parseAddress } from '@inco/js'; +import { incoVerifierAbi } from '@inco/js/abis/verifier'; +import { encryptionSchemes } from '@inco/js/encryption'; +import { Lightning } from '@inco/js/lite'; +import { + type Address, + type Chain, + createPublicClient, + createWalletClient, + getContract, + type Hex, + http, + parseEther, +} from 'viem'; +import { privateKeyToAccount } from 'viem/accounts'; +import { beforeAll, describe, expect, it } from 'vitest'; +import libTestBuild from '../../../contracts/out/LibTest.sol/LibTest.json'; +import { libTestAbi } from '../generated/abis.js'; +import { type E2EConfig } from './lightning-test.js'; + +import type { E2EParams } from './lightning-test.js'; + +// Deploys the LibTest.sol contract on the host chain. +async function deployLibTest(cfg: E2EConfig): Promise
{ + console.log(); + console.log(`Deploying LibTest.sol contract ...`); + await fundAccount(cfg.senderPrivKey, cfg.chain, cfg.hostChainRpcUrl); + const account = privateKeyToAccount(cfg.senderPrivKey); + const walletClient = createWalletClient({ + chain: cfg.chain, + transport: http(cfg.hostChainRpcUrl), + }); + + const byteCode = libTestBuild.bytecode.object as Hex; + const txHash = await walletClient.deployContract({ + account, + abi: libTestAbi, + bytecode: byteCode, + }); + + const publicClient = createPublicClient({ + chain: cfg.chain, + transport: http(cfg.hostChainRpcUrl), + }); + const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash }); + + const contractAddress = receipt.contractAddress; + if (!contractAddress) { + throw new Error('Contract address not found in the transaction receipt'); + } + console.log(`Deployed LibTest.sol contract at ${contractAddress}`); + return parseAddress(contractAddress); +} + +async function fundAccount(senderPrivKey: Hex, chain: Chain, hostChainRpcUrl: string) { + const richAccount = privateKeyToAccount('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'); + const account = privateKeyToAccount(senderPrivKey); + const richWalletClient = createWalletClient({ + chain, + transport: http(hostChainRpcUrl), + }); + await richWalletClient.sendTransaction({ + account: richAccount, + to: account.address, + value: parseEther('1'), + }); +} + +export function runLibTestE2ETest(zap: Lightning, cfg: E2EConfig,params: E2EParams) { + const { walletClient, publicClient, incoLite } = params; + + describe('Lightning LibTest E2E', () => { + let libTestAddress: Address; + let encryptor: ReturnType; + let libTest: any; + let handleA: HexString; + let handleB: HexString; + let handleC: HexString; + let handleTrue: HexString; + let handleFalse: HexString; + let handleAddress: HexString; + + beforeAll(async () => { + console.warn('###############################################'); + console.warn(`# Step 0. Deploy the LibTest contract`); + console.warn('###############################################'); + libTestAddress = await deployLibTest(cfg); + console.warn(`LibTest contract deployed at ${libTestAddress}`); + console.warn('Running this test has some prerequisites:'); + console.warn(`- The IncoLite contract ${zap.executorAddress} must be deployed on ${cfg.chain.name}`); + console.warn(`- The dapp contract ${libTestAddress} must be deployed on ${cfg.chain.name}`); + console.warn( + `- The sender ${privateKeyToAccount(cfg.senderPrivKey).address} must have some ${cfg.chain.name} tokens`, + ); + + const incoVerifierAddress = await incoLite.read.incoVerifier(); + const incoVerifier = getContract({ + abi: incoVerifierAbi, + address: incoVerifierAddress, + client: publicClient, + }); + const eciesKey = await incoVerifier.read.eciesPubkey(); + encryptor = zap.getEncryptor(eciesKey); + + libTest = getContract({ + abi: libTestAbi, + address: libTestAddress, + client: walletClient, + }); + + // Helper function to create euint256 handle + async function createEuint256Handle(value: number): Promise { + const inputCt = await zap.encrypt( + value, + { + accountAddress: walletClient.account.address, + dappAddress: libTestAddress, + }, + encryptor, + ); + const handleSim = await libTest.simulate.testNewEuint256([inputCt, walletClient.account.address], { + value: parseEther('0.0001'), + }); + await libTest.write.testNewEuint256([inputCt, walletClient.account.address], { + value: parseEther('0.0001'), + }); + return handleSim.result as HexString; + } + + // Helper function to create ebool handle + async function createEboolHandle(value: boolean): Promise { + const inputCt = await zap.encrypt( + value, + { + accountAddress: walletClient.account.address, + dappAddress: libTestAddress, + }, + encryptor, + ); + const handleSim = await libTest.simulate.testNewEbool([inputCt, walletClient.account.address], { + value: parseEther('0.0001'), + }); + await libTest.write.testNewEbool([inputCt, walletClient.account.address], { + value: parseEther('0.0001'), + }); + return handleSim.result as HexString; + } + + // Helper function to create eaddress handle + async function createEaddressHandle(address: Address): Promise { + const plaintext = { + scheme: encryptionSchemes.ecies, + type: handleTypes.euint160, + value: BigInt(address), // BigInt can parse hex strings directly, preserving precision + } as any; + const ct = await encryptor({ + plaintext: plaintext, + context: { + hostChainId: BigInt(cfg.chain.id), + aclAddress: zap.executorAddress, + userAddress: walletClient.account.address, + contractAddress: libTestAddress, + }, + }); + const handleSim = await libTest.simulate.testNewEaddress([ct.ciphertext.value, walletClient.account.address], { + value: parseEther('0.0001'), + }); + await libTest.write.testNewEaddress([ct.ciphertext.value, walletClient.account.address], { + value: parseEther('0.0001'), + }); + return handleSim.result as HexString; + } + + // Create 3 numeric handles and 2 boolean handles + console.warn('Creating handles in beforeAll...'); + handleA = await createEuint256Handle(10); + handleB = await createEuint256Handle(5); + handleC = await createEuint256Handle(15); + handleTrue = await createEboolHandle(true); + handleFalse = await createEboolHandle(false); + handleAddress = await createEaddressHandle(walletClient.account.address); + console.warn('All handles created successfully'); + }, 100_000); + + // Arithmetic Operations Tests + describe('Arithmetic Operations', () => { + it('should test addition with stored handles', async () => { + const sim = await libTest.simulate.testAdd([handleA, handleB]); + const txHash = await libTest.write.testAdd([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(15)); + }, 20_000); + + it('should test addition with scalar value using stored A', async () => { + const b = 3; + const sim = await libTest.simulate.testAddScalar([handleA, BigInt(b)]); + const txHash = await libTest.write.testAddScalar([handleA, BigInt(b)]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(13)); + }, 20_000); + + it('should test subtraction with stored handles', async () => { + const sim = await libTest.simulate.testSub([handleA, handleB]); + const txHash = await libTest.write.testSub([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(5)); + }, 20_000); + + it('should test multiplication with stored handles', async () => { + const sim = await libTest.simulate.testMul([handleA, handleB]); + const txHash = await libTest.write.testMul([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(50)); + }, 20_000); + + it('should test division with stored handles', async () => { + const sim = await libTest.simulate.testDiv([handleA, handleB]); + const txHash = await libTest.write.testDiv([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await (zap as any).attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(2)); + }, 20_000); + + it('should test remainder with stored handles', async () => { + const sim = await libTest.simulate.testRem([handleA, handleB]); + const txHash = await libTest.write.testRem([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await (zap as any).attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr?.[0]?.plaintext?.value ?? decryptedArr?.[0]?.value; + expect(value).toBeDefined(); + }, 20_000); + }); + + // Bitwise Operations Tests + describe('Bitwise Operations', () => { + it('should test AND operation with stored handles', async () => { + const sim = await libTest.simulate.testAnd([handleA, handleB]); + const txHash = await libTest.write.testAnd([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(0)); + }, 20_000); + + it('should test OR operation with stored handles', async () => { + const sim = await libTest.simulate.testOr([handleA, handleB]); + const txHash = await libTest.write.testOr([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(15)); + }, 20_000); + + it('should test XOR operation with stored handles', async () => { + const sim = await libTest.simulate.testXor([handleA, handleB]); + const txHash = await libTest.write.testXor([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(15)); + }, 20_000); + + it('should test left shift with stored handles', async () => { + const sim = await libTest.simulate.testShl([handleA, handleB]); + const txHash = await libTest.write.testShl([handleA, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(320)); + }, 20_000); + + it('should test right shift with stored handles', async () => { + const sim = await libTest.simulate.testShr([handleC, handleB]); + const txHash = await libTest.write.testShr([handleC, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(0)); + }, 20_000); + }); + + // Comparison Operations Tests + describe('Comparison Operations', () => { + it('should test equality with stored handles', async () => { + const sim = await libTest.simulate.testEq([handleC, handleC]); + const txHash = await libTest.write.testEq([handleC, handleC]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(true); + }, 20_000); + + it('should test inequality with stored handles', async () => { + const sim = await libTest.simulate.testNe([handleC, handleA]); + const txHash = await libTest.write.testNe([handleC, handleA]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await (zap as any).attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr?.[0]?.plaintext?.value ?? decryptedArr?.[0]?.value; + expect(value).toBe(true); + }, 20_000); + + it('should test greater than with stored handles', async () => { + const sim = await libTest.simulate.testGt([handleC, handleB]); + const txHash = await libTest.write.testGt([handleC, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(true); + }, 20_000); + + it('should test less than with stored handles', async () => { + const sim = await libTest.simulate.testLt([handleA, handleC]); + const txHash = await libTest.write.testLt([handleA, handleC]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(true); + }, 20_000); + + it('should test min with stored handles', async () => { + const sim = await libTest.simulate.testMin([handleC, handleA]); + const txHash = await libTest.write.testMin([handleC, handleA]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(10)); + }, 20_000); + + it('should test max with stored handles', async () => { + const sim = await libTest.simulate.testMax([handleC, handleA]); + const txHash = await libTest.write.testMax([handleC, handleA]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(15)); + }, 20_000); + }); + + // Logical Operations Tests + describe('Logical Operations', () => { + it('should test NOT operation with stored boolean handle', async () => { + const sim = await libTest.simulate.testNot([handleTrue]); + const txHash = await libTest.write.testNot([handleTrue]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(false); // false (NOT true) + }, 20_000); + }); + + // Random Number Generation Tests + describe('Random Number Generation', () => { + it('should test random number generation', async () => { + const sim = await libTest.simulate.testRand({ value: parseEther('0.0001') }); + const txHash = await libTest.write.testRand({ value: parseEther('0.0001') }); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + // Random number should be a valid uint256 (0 to 2^256-1) + expect(value).toBeGreaterThanOrEqual(BigInt(0)); + expect(value).toBeLessThan(BigInt(2) ** BigInt(256)); + }, 20_000); + + it('should test bounded random number generation', async () => { + const upperBound = 100; + const sim = await libTest.simulate.testRandBounded([BigInt(upperBound)], { value: parseEther('0.0001') }); + const txHash = await libTest.write.testRandBounded([BigInt(upperBound)], { value: parseEther('0.0001') }); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + // Random number should be within bounds + expect(value).toBeGreaterThanOrEqual(BigInt(0)); + expect(value).toBeLessThan(BigInt(upperBound)); + }, 20_000); + }); + + // Additional Bitwise Operations Tests + describe('Additional Bitwise Operations', () => { + it.skip('should test rotation left with stored handles', async () => { + const sim = await libTest.simulate.testRotl([handleB, handleB]); + const txHash = await libTest.write.testRotl([handleB, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(160)); + }, 20_000); + + it.skip('should test rotation right with stored handles', async () => { + const sim = await libTest.simulate.testRotr([handleB, handleB]); + const txHash = await libTest.write.testRotr([handleB, handleB]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(18092513943330655534932966407607485602073435104006338131165247501236426506240n); + }, 20_000); + + it('should test AND operation with stored boolean handles', async () => { + const sim = await libTest.simulate.testAndBool([handleTrue, handleFalse]); + const txHash = await libTest.write.testAndBool([handleTrue, handleFalse]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(false); // false (true AND false) + }, 20_000); + + it('should test OR operation with stored boolean handles', async () => { + const sim = await libTest.simulate.testOrBool([handleTrue, handleFalse]); + const txHash = await libTest.write.testOrBool([handleTrue, handleFalse]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(true); // true (true OR false) + }, 20_000); + + it('should test XOR operation with stored boolean handles', async () => { + const sim = await libTest.simulate.testXorBool([handleTrue, handleTrue]); + const txHash = await libTest.write.testXorBool([handleTrue, handleTrue]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(false); // false (true XOR true) + }, 20_000); + }); + + // Additional Comparison Operations Tests + describe('Additional Comparison Operations', () => { + it('should test greater than or equal with stored handles', async () => { + const sim = await libTest.simulate.testGe([handleC, handleC]); + const txHash = await libTest.write.testGe([handleC, handleC]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBeDefined(); + }, 20_000); + + it('should test less than or equal with stored handles', async () => { + const sim = await libTest.simulate.testLe([handleC, handleA]); + const txHash = await libTest.write.testLe([handleC, handleA]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBeDefined(); + }, 20_000); + + it('should test equality with scalar value', async () => { + const sim = await libTest.simulate.testEqScalar([handleC, BigInt(15)]); + const txHash = await libTest.write.testEqScalar([handleC, BigInt(15)]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBeDefined(); + }, 20_000); + + it('should test inequality with scalar value', async () => { + const sim = await libTest.simulate.testNeScalar([handleC, BigInt(20)]); + const txHash = await libTest.write.testNeScalar([handleC, BigInt(20)]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [sim.result]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBeDefined(); + }, 20_000); + }); + describe('Reveal Operations', () => { + it('should test reveal uint256', async () => { + const sim = await libTest.simulate.testRevealEUint([handleA]); + const txHash = await libTest.write.testRevealEUint([handleA]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [handleA]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(BigInt(10)); + }, 20_000); + it('should test reveal bool', async () => { + const sim = await libTest.simulate.testRevealEBool([handleTrue]); + const txHash = await libTest.write.testRevealEBool([handleTrue]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [handleTrue]); + const value = decryptedArr[0]?.plaintext.value; + expect(value).toBe(true); + }, 20_000); + it('should test reveal address', async () => { + // Note: sim.result is undefined because testRevealEAddress returns void (no outputs) + // The reveal function just reveals the value on-chain but doesn't return a handle + const sim = await libTest.simulate.testRevealEAddress([handleAddress]); + const txHash = await libTest.write.testRevealEAddress([handleAddress]); + await publicClient.waitForTransactionReceipt({ hash: txHash }); + // After revealing, we decrypt the original handle to verify the value + const decryptedArr = await zap.attestedDecrypt(walletClient as any, [handleAddress]); + const value = decryptedArr[0]?.plaintext.value; + // Convert address to BigInt - use the same conversion as in createEaddressHandle + const expectedAddressValue = BigInt(walletClient.account.address); + expect(value).toBe(expectedAddressValue); + }, 20_000); + }); + }); +} + diff --git a/backend/src/test/lightning-test.ts b/backend/src/test/lightning-test.ts index 9a831cd..6651d44 100644 --- a/backend/src/test/lightning-test.ts +++ b/backend/src/test/lightning-test.ts @@ -1,23 +1,9 @@ -import { HexString, parseAddress } from '@inco/js'; -import { incoLightningAbi } from '@inco/js/abis'; +import { incoLightningAbi } from '@inco/js/abis/lightning'; +import { Transport, PublicClient, Address, type Chain, type Hex, Account, WalletClient, GetContractReturnType, getContract, http, parseGwei, createWalletClient, createPublicClient, defineChain } from 'viem'; +import { runAddTwoE2ETest } from './lightning-addtwo.js'; +import { runLibTestE2ETest } from './lightning-libtest.js'; import { Lightning } from '@inco/js/lite'; -import { - type Account, - type Address, - type Chain, - createPublicClient, - createWalletClient, - getContract, - type Hex, - http, - type PublicClient, - type Transport, - type WalletClient, -} from 'viem'; import { privateKeyToAccount } from 'viem/accounts'; -import { beforeAll, describe, expect, it } from 'vitest'; -import addTwoBuild from '../../../contracts/out/AddTwo.sol/AddTwo.json'; -import { addTwoAbi } from '../generated/abis'; // E2EConfig contains all configuration needed to run a test against // a specific deployment. @@ -31,12 +17,32 @@ export interface E2EConfig { // Address of the confidential token contract. // dappAddress: Address; } - -export function runE2ETest(valueToAdd: number, zap: Lightning, cfg: E2EConfig) { +export interface E2EParams { + walletClient: WalletClient; + publicClient: PublicClient; + incoLite: GetContractReturnType< + typeof incoLightningAbi, + PublicClient, + Address + >; +} + +export const backoffConfig = { + errHandler: (error: Error, attempt: number) => { + console.log(`Backoff: Attempt ${attempt} failed: ${error.message}`); + return 'continue'; + }, + maxRetries: 10, + baseDelayInMs: 1000, + backoffFactor: 1.5, +}; + +export function runE2ETest(zap: Lightning, cfg: E2EConfig,) { const account = privateKeyToAccount(cfg.senderPrivKey); - const viemChain = cfg.chain; - // TODO: my attempt to override gas fees to work around insufficient balance error without success: - // const viemChain = defineChain({ ...getViemChain(cfg.chain), fees: { maxPriorityFeePerGas: parseGwei('10') } }); + const viemChain = defineChain({ + ...cfg.chain, + fees: { maxPriorityFeePerGas: parseGwei('10') }, + }); const walletClient = createWalletClient({ chain: viemChain, transport: http(cfg.hostChainRpcUrl), @@ -47,156 +53,13 @@ export function runE2ETest(valueToAdd: number, zap: Lightning, cfg: E2EConfig) { transport: http(cfg.hostChainRpcUrl), }) as PublicClient; - describe('Lightning AddTwo E2E', () => { - // Will hold the handle of the result of the `addTwoEOA` call. - let resultHandle: HexString; - let requestId: bigint; - let callbackFulfillPromise: Promise; - let dappAddress: Address; - - beforeAll(async () => { - console.warn('###############################################'); - console.warn(`# Step 0. Deploy the AddTwo contract`); - console.warn('###############################################'); - dappAddress = await deployAddTwo(cfg); - console.warn(`AddTwo contract deployed at ${dappAddress}`); - console.warn('Running this test has some prerequisites:'); - console.warn(`- The IncoLite contract ${zap.executorAddress} must be deployed on ${cfg.chain.name}`); - console.warn(`- The dapp contract ${dappAddress} must be deployed on ${cfg.chain.name}`); - console.warn( - `- The sender ${privateKeyToAccount(cfg.senderPrivKey).address} must have some ${cfg.chain.name} tokens`, - ); - - // Step 1. - const inputCt = await zap.encrypt(valueToAdd, { - accountAddress: walletClient.account.address, - dappAddress, - }); - - // Already start watching for the fullfilled event. This is because on - // Monad, stuff is happening so fast that it's better to start watching - // for events as soon as possible. - const incoLite = getContract({ - abi: incoLightningAbi, - address: zap.executorAddress, - client: publicClient, - }); - if (!incoLite) { - throw new Error(`IncoLite contract not found at address ${zap.executorAddress}`); - } - callbackFulfillPromise = new Promise((resolve) => { - incoLite.watchEvent.RequestFulfilled({ requestId }, { onLogs: () => resolve() }); - }); - - // Step 2. - const res = await addTwo(dappAddress, inputCt, walletClient, publicClient, cfg); - resultHandle = res.resultHandle; - requestId = res.requestId; - },100_000);//Include 100s timeout for sepolia backend testing - - it('should read from the decrypted message', async () => { - console.log(); - console.log(`Waiting for RequestFulfilled event with requestId ${requestId}...`); - await callbackFulfillPromise; - console.log('RequestFulfilled event received'); - - const dapp = getContract({ - abi: addTwoAbi, - address: dappAddress, - client: publicClient, - }); - - const lastResult = await dapp.read.lastResult(); - expect(lastResult).toBe(BigInt(valueToAdd + 2)); - }, 20_000); - - it('should reencrypt a message', async () => { - // Step 3. - console.warn('###############################################'); - console.warn(`# Step 3. Reencrypt the result handle`); - console.warn('###############################################'); - console.warn(`# Using covalidator ${zap.covalidatorUrl}`); - const reencryptor = await zap.getReencryptor(walletClient); - const decrypted = await reencryptor({ handle: resultHandle }); - expect(decrypted.value).toBe(BigInt(valueToAdd + 2)); - }, 10_000); - }); -} - -// Sends a tx on the host chain to call `addTwo`. -async function addTwo( - dappAddress: Address, - inputCt: HexString, - walletClient: WalletClient, - publicClient: PublicClient, - cfg: E2EConfig, -): Promise<{ requestId: bigint; resultHandle: HexString }> { - const chain = cfg.chain; - console.log(); - console.log('###############################################'); - console.log(`# Step 2. Send a tx to ${chain.name}`); - console.log('###############################################'); - - const dapp = getContract({ - abi: addTwoAbi, - address: dappAddress, - client: walletClient, + const incoLite = getContract({ + abi: incoLightningAbi, + address: zap.executorAddress, + client: publicClient, }); - console.log(); - console.log(`Simulating the call to add 2 to ${prettifyInputCt(inputCt)}`); - const { - result: [requestId, resultHandle], - } = await dapp.simulate.addTwoEOA([inputCt]); - console.log(`Result handle: ${resultHandle}`); - - console.log(); - console.log(`Calling the dapp contract to add 2 to ${prettifyInputCt(inputCt)}`); - // With some testing, we found that 300000 gas is enough for this tx. - // ref: https://testnet.monadexplorer.com/tx/0x562e301221c942c50c758076d67bef85c41cd51def9d8f4ad2d514aa8ab5f74d - // ref: https://sepolia.basescan.org/tx/0x9141788e279a80571b0b5fcf203a7dc6599b6a3ad14fd3353e51089dc3c870a6 - const txHash = await dapp.write.addTwoEOA([inputCt], { gas: BigInt(300000) }); - console.log(`Tx submitted: ${chain.blockExplorers?.default.url ?? 'no-explorer'}/tx/${txHash}`); - - console.log(); - console.log('Waiting for tx to be included in a block...'); - const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash }); - console.log(`Transaction included in block ${receipt.blockNumber}`); - - return { requestId, resultHandle }; -} - -// Deploys the AddTwo.sol contract on the host chain. -async function deployAddTwo(cfg: E2EConfig): Promise
{ - console.log(); - console.log(`Deploying AddTwo.sol contract ...`); - const account = privateKeyToAccount(cfg.senderPrivKey); - const walletClient = createWalletClient({ - chain: cfg.chain, - transport: http(cfg.hostChainRpcUrl), - }); - - const byteCode = addTwoBuild.bytecode.object as Hex; - const txHash = await walletClient.deployContract({ - account, - abi: addTwoAbi, - bytecode: byteCode, - }); - - const publicClient = createPublicClient({ - chain: cfg.chain, - transport: http(cfg.hostChainRpcUrl), - }); - const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash }); - - const contractAddress = receipt.contractAddress; - if (!contractAddress) { - throw new Error('Contract address not found in the transaction receipt'); - } - console.log(`Deployed AddTwo.sol contract at ${contractAddress}`); - return parseAddress(contractAddress); -} - -function prettifyInputCt(hex: HexString): string { - return `${hex.slice(0, 8)}...${hex.slice(-6)}`; + const params: E2EParams = { walletClient, publicClient, incoLite }; + runAddTwoE2ETest(zap, cfg, params); + runLibTestE2ETest(zap, cfg, params); } diff --git a/backend/src/test/lightning.base-sepolia.e2e.test.ts b/backend/src/test/lightning.base-sepolia.e2e.test.ts index b66f089..3c79bcb 100644 --- a/backend/src/test/lightning.base-sepolia.e2e.test.ts +++ b/backend/src/test/lightning.base-sepolia.e2e.test.ts @@ -2,8 +2,8 @@ import { HexString, parse } from '@inco/js'; import { Lightning } from '@inco/js/lite'; import { baseSepolia } from 'viem/chains'; import { describe } from 'vitest'; -import { runE2ETest } from './lightning-test.ts'; import { loadDotEnv } from '../repo.ts'; +import { runE2ETest } from './lightning-test.ts'; describe(`Lightning Base Sepolia E2E`, { timeout: 50_000 }, async () => { loadDotEnv(); @@ -11,8 +11,8 @@ describe(`Lightning Base Sepolia E2E`, { timeout: 50_000 }, async () => { const senderPrivKey = parse(HexString, getEnv('SENDER_PRIVATE_KEY')); const hostChainRpcUrl = getEnv('BASE_SEPOLIA_RPC_URL'); const chain = baseSepolia; - const zap = Lightning.latest('testnet', chain.id); - runE2ETest(Math.floor(Math.random() * 100), zap, { + const zap = await Lightning.latest('testnet', chain.id); + runE2ETest(zap, { chain, senderPrivKey, hostChainRpcUrl, diff --git a/backend/src/test/lightning.local.e2e.test.ts b/backend/src/test/lightning.local.e2e.test.ts index e3feba3..f86f38d 100644 --- a/backend/src/test/lightning.local.e2e.test.ts +++ b/backend/src/test/lightning.local.e2e.test.ts @@ -1,13 +1,14 @@ import { Lightning } from '@inco/js/lite'; +import { Hex } from 'viem'; import { anvil } from 'viem/chains'; import { describe } from 'vitest'; -import { runE2ETest } from './lightning-test.ts'; +import { runE2ETest } from './lightning-test'; describe(`Lightning Local Node E2E`, { timeout: 50_000 }, async () => { - const zap = Lightning.localNode(); - runE2ETest(Math.floor(Math.random() * 100), zap, { + const zap = await Lightning.localNode('alphanet'); + runE2ETest(zap, { chain: anvil, - senderPrivKey: zap.deployment.senderPrivateKey, - hostChainRpcUrl: 'http://127.0.0.1:8545', + senderPrivKey: zap.deployment.senderPrivateKey as Hex, + hostChainRpcUrl: 'http://127.0.0.1:8545', }); }); diff --git a/backend/wagmi.config.mts b/backend/wagmi.config.mts index ccc6433..ce5cbfb 100644 --- a/backend/wagmi.config.mts +++ b/backend/wagmi.config.mts @@ -1,14 +1,13 @@ import { defineConfig } from "@wagmi/cli"; import { foundry } from "@wagmi/cli/plugins"; - export default defineConfig([ { out: "src/generated/abis.ts", plugins: [ foundry({ project: "../contracts/", - include: ["AddTwo.sol/**", "SimpleConfidentialToken.sol/**"], + include: ["AddTwo.sol/**", "SimpleConfidentialToken.sol/**", "LibTest.sol/**"], }), ], }, diff --git a/bun.lock b/bun.lock index 36fef65..3540cc0 100644 --- a/bun.lock +++ b/bun.lock @@ -2,7 +2,7 @@ "lockfileVersion": 1, "workspaces": { "": { - "name": "lightning-rod", + "name": "@inco/lightning-rod", "devDependencies": { "@inco/lightning": "workspace:*", "@types/bun": "latest", @@ -27,8 +27,7 @@ "contracts": { "name": "lightning-rod-contracts", "dependencies": { - "@inco/lightning": "^0.1.21", - "@inco/shared": "^0.1.0", + "@inco/lightning": "0.6.8", "@openzeppelin/contracts": "^5.3.0", "ds-test": "https://github.com/dapphub/ds-test", "forge-std": "https://github.com/foundry-rs/forge-std", @@ -36,8 +35,8 @@ }, }, "overrides": { - "@inco/js": "0.1.33", - "@inco/lightning": "0.1.30", + "@inco/js": "0.6.9", + "@inco/lightning": "0.6.9", "ansi-regex": "^6.2.2", "ansi-styles": "^6.2.3", "backslash": "^0.2.0", @@ -60,113 +59,93 @@ "wrap-ansi": "^9.0.2", }, "packages": { - "@adraffy/ens-normalize": ["@adraffy/ens-normalize@1.11.0", "", {}, "sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg=="], + "@adraffy/ens-normalize": ["@adraffy/ens-normalize@1.11.1", "", {}, "sha512-nhCBV3quEgesuf7c7KYfperqSS14T8bYuvJ8PcLJp6znkZpFc0AuW4qBtr8eKVyPPe/8RSr7sglCWPU5eaxwKQ=="], - "@bufbuild/protobuf": ["@bufbuild/protobuf@2.2.5", "", {}, "sha512-/g5EzJifw5GF8aren8wZ/G5oMuPoGeS6MQD3ca8ddcvdXR5UELUfdTZITCGNhNXynY/AYl3Z4plmxdj/tRl/hQ=="], + "@bufbuild/protobuf": ["@bufbuild/protobuf@2.10.0", "", {}, "sha512-fdRs9PSrBF7QUntpZpq6BTw58fhgGJojgg39m9oFOJGZT+nip9b0so5cYY1oWl5pvemDLr0cPPsH46vwThEbpQ=="], - "@confio/ics23": ["@confio/ics23@0.6.8", "", { "dependencies": { "@noble/hashes": "^1.0.0", "protobufjs": "^6.8.8" } }, "sha512-wB6uo+3A50m0sW/EWcU64xpV/8wShZ6bMTa7pF8eYsTrSkQA7oLUIJcs/wb8g4y2Oyq701BaGiO6n/ak5WXO1w=="], + "@connectrpc/connect": ["@connectrpc/connect@2.1.0", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.7.0" } }, "sha512-xhiwnYlJNHzmFsRw+iSPIwXR/xweTvTw8x5HiwWp10sbVtd4OpOXbRgE7V58xs1EC17fzusF1f5uOAy24OkBuA=="], - "@connectrpc/connect": ["@connectrpc/connect@2.0.2", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0" } }, "sha512-xZuylIUNvNlH52e/4eQsZvY4QZyDJRtEFEDnn/yBrv5Xi5ZZI/p8X+GAHH35ucVaBvv9u7OzHZo8+tEh1EFTxA=="], + "@connectrpc/connect-node": ["@connectrpc/connect-node@2.1.0", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.7.0", "@connectrpc/connect": "2.1.0" } }, "sha512-6akCXZSX5uWHLR654ne9Tnq7AnPUkLS65NvgsI5885xBkcuVy2APBd8sA4sLqaplUt84cVEr6LhjEFNx6W1KtQ=="], - "@connectrpc/connect-node": ["@connectrpc/connect-node@2.0.2", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0", "@connectrpc/connect": "2.0.2" } }, "sha512-33Ut3SRkb6SugpwVCtXXRvUrOdtiyG6z6d5+eijBOLOI75sw1tDCwcs0o/9WL3rUj1M08dLUrPmJB47fjpv6EA=="], + "@connectrpc/connect-web": ["@connectrpc/connect-web@2.1.0", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.7.0", "@connectrpc/connect": "2.1.0" } }, "sha512-4IBFeMeXS1RVtmmFE/MwH+vWq/5vDRKys70va+DAaWDh83Rdy0iUQOJbITUDzvonlY5as3vwfs5yy9Yp2miHSw=="], - "@connectrpc/connect-web": ["@connectrpc/connect-web@2.0.2", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0", "@connectrpc/connect": "2.0.2" } }, "sha512-QANMFPiL2o66BdBEctg4TsQLe5ozsBLqcle3dCBp7BwGlNGTY6NnNnqmt+YRnpeMW88GgomJwWNMGCrRD9pRKA=="], + "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="], - "@cosmjs/amino": ["@cosmjs/amino@0.32.4", "", { "dependencies": { "@cosmjs/crypto": "^0.32.4", "@cosmjs/encoding": "^0.32.4", "@cosmjs/math": "^0.32.4", "@cosmjs/utils": "^0.32.4" } }, "sha512-zKYOt6hPy8obIFtLie/xtygCkH9ZROiQ12UHfKsOkWaZfPQUvVbtgmu6R4Kn1tFLI/SRkw7eqhaogmW/3NYu/Q=="], + "@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="], - "@cosmjs/crypto": ["@cosmjs/crypto@0.32.4", "", { "dependencies": { "@cosmjs/encoding": "^0.32.4", "@cosmjs/math": "^0.32.4", "@cosmjs/utils": "^0.32.4", "@noble/hashes": "^1", "bn.js": "^5.2.0", "elliptic": "^6.5.4", "libsodium-wrappers-sumo": "^0.7.11" } }, "sha512-zicjGU051LF1V9v7bp8p7ovq+VyC91xlaHdsFOTo2oVry3KQikp8L/81RkXmUIT8FxMwdx1T7DmFwVQikcSDIw=="], + "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="], - "@cosmjs/encoding": ["@cosmjs/encoding@0.32.4", "", { "dependencies": { "base64-js": "^1.3.0", "bech32": "^1.1.4", "readonly-date": "^1.0.0" } }, "sha512-tjvaEy6ZGxJchiizzTn7HVRiyTg1i4CObRRaTRPknm5EalE13SV+TCHq38gIDfyUeden4fCuaBVEdBR5+ti7Hw=="], + "@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="], - "@cosmjs/json-rpc": ["@cosmjs/json-rpc@0.32.4", "", { "dependencies": { "@cosmjs/stream": "^0.32.4", "xstream": "^11.14.0" } }, "sha512-/jt4mBl7nYzfJ2J/VJ+r19c92mUKF0Lt0JxM3MXEJl7wlwW5haHAWtzRujHkyYMXOwIR+gBqT2S0vntXVBRyhQ=="], + "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="], - "@cosmjs/math": ["@cosmjs/math@0.32.4", "", { "dependencies": { "bn.js": "^5.2.0" } }, "sha512-++dqq2TJkoB8zsPVYCvrt88oJWsy1vMOuSOKcdlnXuOA/ASheTJuYy4+oZlTQ3Fr8eALDLGGPhJI02W2HyAQaw=="], + "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="], - "@cosmjs/proto-signing": ["@cosmjs/proto-signing@0.32.4", "", { "dependencies": { "@cosmjs/amino": "^0.32.4", "@cosmjs/crypto": "^0.32.4", "@cosmjs/encoding": "^0.32.4", "@cosmjs/math": "^0.32.4", "@cosmjs/utils": "^0.32.4", "cosmjs-types": "^0.9.0" } }, "sha512-QdyQDbezvdRI4xxSlyM1rSVBO2st5sqtbEIl3IX03uJ7YiZIQHyv6vaHVf1V4mapusCqguiHJzm4N4gsFdLBbQ=="], + "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="], - "@cosmjs/socket": ["@cosmjs/socket@0.32.4", "", { "dependencies": { "@cosmjs/stream": "^0.32.4", "isomorphic-ws": "^4.0.1", "ws": "^7", "xstream": "^11.14.0" } }, "sha512-davcyYziBhkzfXQTu1l5NrpDYv0K9GekZCC9apBRvL1dvMc9F/ygM7iemHjUA+z8tJkxKxrt/YPjJ6XNHzLrkw=="], + "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="], - "@cosmjs/stargate": ["@cosmjs/stargate@0.32.4", "", { "dependencies": { "@confio/ics23": "^0.6.8", "@cosmjs/amino": "^0.32.4", "@cosmjs/encoding": "^0.32.4", "@cosmjs/math": "^0.32.4", "@cosmjs/proto-signing": "^0.32.4", "@cosmjs/stream": "^0.32.4", "@cosmjs/tendermint-rpc": "^0.32.4", "@cosmjs/utils": "^0.32.4", "cosmjs-types": "^0.9.0", "xstream": "^11.14.0" } }, "sha512-usj08LxBSsPRq9sbpCeVdyLx2guEcOHfJS9mHGCLCXpdAPEIEQEtWLDpEUc0LEhWOx6+k/ChXTc5NpFkdrtGUQ=="], + "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="], - "@cosmjs/stream": ["@cosmjs/stream@0.32.4", "", { "dependencies": { "xstream": "^11.14.0" } }, "sha512-Gih++NYHEiP+oyD4jNEUxU9antoC0pFSg+33Hpp0JlHwH0wXhtD3OOKnzSfDB7OIoEbrzLJUpEjOgpCp5Z+W3A=="], + "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="], - "@cosmjs/tendermint-rpc": ["@cosmjs/tendermint-rpc@0.32.4", "", { "dependencies": { "@cosmjs/crypto": "^0.32.4", "@cosmjs/encoding": "^0.32.4", "@cosmjs/json-rpc": "^0.32.4", "@cosmjs/math": "^0.32.4", "@cosmjs/socket": "^0.32.4", "@cosmjs/stream": "^0.32.4", "@cosmjs/utils": "^0.32.4", "axios": "^1.6.0", "readonly-date": "^1.0.0", "xstream": "^11.14.0" } }, "sha512-MWvUUno+4bCb/LmlMIErLypXxy7ckUuzEmpufYYYd9wgbdCXaTaO08SZzyFM5PI8UJ/0S2AmUrgWhldlbxO8mw=="], + "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="], - "@cosmjs/utils": ["@cosmjs/utils@0.32.4", "", {}, "sha512-D1Yc+Zy8oL/hkUkFUL/bwxvuDBzRGpc4cF7/SkdhxX4iHpSLgdOuTt1mhCh9+kl6NQREy9t7SYZ6xeW5gFe60w=="], + "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="], - "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.19.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA=="], + "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="], - "@esbuild/android-arm": ["@esbuild/android-arm@0.19.12", "", { "os": "android", "cpu": "arm" }, "sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w=="], + "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="], - "@esbuild/android-arm64": ["@esbuild/android-arm64@0.19.12", "", { "os": "android", "cpu": "arm64" }, "sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA=="], + "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="], - "@esbuild/android-x64": ["@esbuild/android-x64@0.19.12", "", { "os": "android", "cpu": "x64" }, "sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew=="], + "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="], - "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.19.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g=="], + "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="], - "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.19.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A=="], + "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="], - "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.19.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA=="], + "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="], - "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.19.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg=="], + "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="], - "@esbuild/linux-arm": ["@esbuild/linux-arm@0.19.12", "", { "os": "linux", "cpu": "arm" }, "sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w=="], + "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="], - "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.19.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA=="], + "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="], - "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.19.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA=="], + "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="], - "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA=="], + "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="], - "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w=="], + "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="], - "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.19.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg=="], + "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="], - "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg=="], + "@grpc/grpc-js": ["@grpc/grpc-js@1.14.1", "", { "dependencies": { "@grpc/proto-loader": "^0.8.0", "@js-sdsl/ordered-map": "^4.4.2" } }, "sha512-sPxgEWtPUR3EnRJCEtbGZG2iX8LQDUls2wUS3o27jg07KqJFMq6YDeWvMo1wfpmy3rqRdS0rivpLwhqQtEyCuQ=="], - "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.19.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg=="], + "@grpc/proto-loader": ["@grpc/proto-loader@0.8.0", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.5.3", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ=="], - "@esbuild/linux-x64": ["@esbuild/linux-x64@0.19.12", "", { "os": "linux", "cpu": "x64" }, "sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg=="], + "@inco/js": ["@inco/js@0.6.9", "", { "dependencies": { "@bufbuild/protobuf": "^2.2.3", "@connectrpc/connect": "^2.0.0", "@connectrpc/connect-node": "^2.0.0", "@connectrpc/connect-web": "^2.0.1", "@grpc/grpc-js": "^1.13.4", "@types/elliptic": "^6.4.18", "ecies-geth": "^1.7.5", "effect": "^3.17.13", "elliptic": "^6.6.1", "sha3": "^2.1.4", "viem": "^2.23.6" } }, "sha512-AGKLXH8V2Co3wI+wnXBwpDk/mcIRyRsGrtVUgYvyWuCtM+vKNRMNvR3+W0q7EhuqBs/y/47DrODpNCF417MgBA=="], - "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.2", "", { "os": "none", "cpu": "arm64" }, "sha512-talAIBoY5M8vHc6EeI2WW9d/CkiO9MQJ0IOWX8hrLhxGbro/vBXJvaQXefW2cP0z0nQVTdQ/eNyGFV1GSKrxfw=="], - - "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.19.12", "", { "os": "none", "cpu": "x64" }, "sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA=="], - - "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.2", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-dcXYOC6NXOqcykeDlwId9kB6OkPUxOEqU+rkrYVqJbK2hagWOMrsTGsMr8+rW02M+d5Op5NNlgMmjzecaRf7Tg=="], - - "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.19.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw=="], - - "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.19.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA=="], - - "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.19.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A=="], - - "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.19.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ=="], - - "@esbuild/win32-x64": ["@esbuild/win32-x64@0.19.12", "", { "os": "win32", "cpu": "x64" }, "sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA=="], - - "@grpc/grpc-js": ["@grpc/grpc-js@1.13.3", "", { "dependencies": { "@grpc/proto-loader": "^0.7.13", "@js-sdsl/ordered-map": "^4.4.2" } }, "sha512-FTXHdOoPbZrBjlVLHuKbDZnsTxXv2BlHF57xw6LuThXacXvtkahEPED0CKMk6obZDf65Hv4k3z62eyPNpvinIg=="], - - "@grpc/proto-loader": ["@grpc/proto-loader@0.7.15", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.2.5", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ=="], - - "@inco/js": ["@inco/js@0.1.33", "", { "dependencies": { "@bufbuild/protobuf": "^2.2.3", "@connectrpc/connect": "^2.0.0", "@connectrpc/connect-node": "^2.0.0", "@connectrpc/connect-web": "^2.0.1", "@cosmjs/proto-signing": "^0.32.4", "@cosmjs/stargate": "^0.32.4", "@cosmjs/tendermint-rpc": "^0.32.4", "@grpc/grpc-js": "^1.12.2", "@types/elliptic": "^6.4.18", "@wagmi/cli": "^2.2.0", "bincode-ts": "^0.1.1", "ecies-geth": "^1.7.5", "effect": "^3.13.6", "sha3": "^2.1.4", "viem": "^2.23.6" } }, "sha512-K+0roA7sEXKpz7qy7+/HkexUm7MuNXnp98TFSglessA7K2YkrywrEoKZEHXi+nNdpLE0i73FgUaLOqitp7wiMw=="], - - "@inco/lightning": ["@inco/lightning@0.1.30", "", { "dependencies": { "@inco/shared": "^0.1.0", "@openzeppelin/contracts": "^5.2.0", "@openzeppelin/contracts-upgradeable": "^5.2.0", "ds-test": "https://github.com/dapphub/ds-test", "forge-std": "https://github.com/foundry-rs/forge-std", "tsx": "^4.19.3" } }, "sha512-KyNo+9muUegR+/tDF7UFifem4sumXZIRTeIvCGpfSd2CldcjkCoG+dqvf+Vwh9li7GS7q5dDZpM/W1JSkcbr2g=="], + "@inco/lightning": ["@inco/lightning@0.6.9", "", { "dependencies": { "@inco/shared": "^0.1.0", "@openzeppelin/contracts": "^5.2.0", "@openzeppelin/contracts-upgradeable": "^5.2.0", "@safe-global/safe-smart-account": "https://github.com/safe-global/safe-smart-account.git#v1.5.0", "ds-test": "https://github.com/dapphub/ds-test", "forge-std": "https://github.com/foundry-rs/forge-std", "tsx": "^4.19.3" } }, "sha512-AWeFIbaJNXoKIWa/TUjOzQqGcTwCmLgeHjU5F7KH5O4u0ecar4+xAEmYvlRgPmidIkP+vPdSX2KFpKMw/w9oaA=="], "@inco/lightning-rod-test": ["@inco/lightning-rod-test@workspace:backend"], "@inco/shared": ["@inco/shared@0.1.0", "", { "dependencies": { "@openzeppelin/contracts": "^5.2.0", "ds-test": "https://github.com/dapphub/ds-test", "forge-std": "https://github.com/foundry-rs/forge-std" } }, "sha512-Yw4KnTCGJPMGlWFq1JEpuadoNYFEXA+TObwNsR2Tq9ICgf0iVksSYatqiUeHaB1/J9Vyo5obZOKsU92Oieacog=="], - "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.0", "", {}, "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="], + "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="], "@js-sdsl/ordered-map": ["@js-sdsl/ordered-map@4.4.2", "", {}, "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw=="], - "@noble/curves": ["@noble/curves@1.8.2", "", { "dependencies": { "@noble/hashes": "1.7.2" } }, "sha512-vnI7V6lFNe0tLAuJMu+2sX+FcL14TaCWy1qiczg1VwRmPrpQCdq5ESXQMqUc2tluRNf6irBXrWbl1mGN8uaU/g=="], + "@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="], - "@noble/hashes": ["@noble/hashes@1.7.2", "", {}, "sha512-biZ0NUSxyjLLqo6KxEJ1b+C2NAx0wtDoFvCaXHGgUkeHzf3Xc1xKumFKREuT7f7DARNZ/slvYUwFG6B0f2b6hQ=="], + "@noble/curves": ["@noble/curves@1.9.1", "", { "dependencies": { "@noble/hashes": "1.8.0" } }, "sha512-k11yZxZg+t+gWvBbIswW0yoJlu8cHOC7dhunwOzoWH/mXGBiYyR4YY6hAEK/3EUs4UpB8la1RfdRpeGsFHkWsA=="], - "@openzeppelin/contracts": ["@openzeppelin/contracts@5.3.0", "", {}, "sha512-zj/KGoW7zxWUE8qOI++rUM18v+VeLTTzKs/DJFkSzHpQFPD/jKKF0TrMxBfGLl3kpdELCNccvB3zmofSzm4nlA=="], + "@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="], - "@openzeppelin/contracts-upgradeable": ["@openzeppelin/contracts-upgradeable@5.3.0", "", { "peerDependencies": { "@openzeppelin/contracts": "5.3.0" } }, "sha512-yVzSSyTMWO6rapGI5tuqkcLpcGGXA0UA1vScyV5EhE5yw8By3Ewex9rDUw8lfVw0iTkvR/egjfcW5vpk03lqZg=="], + "@openzeppelin/contracts": ["@openzeppelin/contracts@5.4.0", "", {}, "sha512-eCYgWnLg6WO+X52I16TZt8uEjbtdkgLC0SUX/xnAksjjrQI4Xfn4iBRoI5j55dmlOhDv1Y7BoR3cU7e3WWhC6A=="], + + "@openzeppelin/contracts-upgradeable": ["@openzeppelin/contracts-upgradeable@5.4.0", "", { "peerDependencies": { "@openzeppelin/contracts": "5.4.0" } }, "sha512-STJKyDzUcYuB35Zub1JpWW58JxvrFFVgQ+Ykdr8A9PGXgtq/obF5uoh07k2XmFyPxfnZdPdBdhkJ/n2YxJ87HQ=="], "@protobufjs/aspromise": ["@protobufjs/aspromise@1.1.2", "", {}, "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="], @@ -188,83 +167,93 @@ "@protobufjs/utf8": ["@protobufjs/utf8@1.1.0", "", {}, "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw=="], - "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.40.0", "", { "os": "android", "cpu": "arm" }, "sha512-+Fbls/diZ0RDerhE8kyC6hjADCXA1K4yVNlH0EYfd2XjyH0UGgzaQ8MlT0pCXAThfxv3QUAczHaL+qSv1E4/Cg=="], + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.53.2", "", { "os": "android", "cpu": "arm" }, "sha512-yDPzwsgiFO26RJA4nZo8I+xqzh7sJTZIWQOxn+/XOdPE31lAvLIYCKqjV+lNH/vxE2L2iH3plKxDCRK6i+CwhA=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.53.2", "", { "os": "android", "cpu": "arm64" }, "sha512-k8FontTxIE7b0/OGKeSN5B6j25EuppBcWM33Z19JoVT7UTXFSo3D9CdU39wGTeb29NO3XxpMNauh09B+Ibw+9g=="], + + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.53.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-A6s4gJpomNBtJ2yioj8bflM2oogDwzUiMl2yNJ2v9E7++sHrSrsQ29fOfn5DM/iCzpWcebNYEdXpaK4tr2RhfQ=="], - "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.40.0", "", { "os": "android", "cpu": "arm64" }, "sha512-PPA6aEEsTPRz+/4xxAmaoWDqh67N7wFbgFUJGMnanCFs0TV99M0M8QhhaSCks+n6EbQoFvLQgYOGXxlMGQe/6w=="], + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.53.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-e6XqVmXlHrBlG56obu9gDRPW3O3hLxpwHpLsBJvuI8qqnsrtSZ9ERoWUXtPOkY8c78WghyPHZdmPhHLWNdAGEw=="], - "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.40.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-GwYOcOakYHdfnjjKwqpTGgn5a6cUX7+Ra2HeNj/GdXvO2VJOOXCiYYlRFU4CubFM67EhbmzLOmACKEfvp3J1kQ=="], + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.53.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-v0E9lJW8VsrwPux5Qe5CwmH/CF/2mQs6xU1MF3nmUxmZUCHazCjLgYvToOk+YuuUqLQBio1qkkREhxhc656ViA=="], - "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.40.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-CoLEGJ+2eheqD9KBSxmma6ld01czS52Iw0e2qMZNpPDlf7Z9mj8xmMemxEucinev4LgHalDPczMyxzbq+Q+EtA=="], + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.53.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-ClAmAPx3ZCHtp6ysl4XEhWU69GUB1D+s7G9YjHGhIGCSrsg00nEGRRZHmINYxkdoJehde8VIsDC5t9C0gb6yqA=="], - "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.40.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-r7yGiS4HN/kibvESzmrOB/PxKMhPTlz+FcGvoUIKYoTyGd5toHp48g1uZy1o1xQvybwwpqpe010JrcGG2s5nkg=="], + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.53.2", "", { "os": "linux", "cpu": "arm" }, "sha512-EPlb95nUsz6Dd9Qy13fI5kUPXNSljaG9FiJ4YUGU1O/Q77i5DYFW5KR8g1OzTcdZUqQQ1KdDqsTohdFVwCwjqg=="], - "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.40.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-mVDxzlf0oLzV3oZOr0SMJ0lSDd3xC4CmnWJ8Val8isp9jRGl5Dq//LLDSPFrasS7pSm6m5xAcKaw3sHXhBjoRw=="], + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.53.2", "", { "os": "linux", "cpu": "arm" }, "sha512-BOmnVW+khAUX+YZvNfa0tGTEMVVEerOxN0pDk2E6N6DsEIa2Ctj48FOMfNDdrwinocKaC7YXUZ1pHlKpnkja/Q=="], - "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.40.0", "", { "os": "linux", "cpu": "arm" }, "sha512-y/qUMOpJxBMy8xCXD++jeu8t7kzjlOCkoxxajL58G62PJGBZVl/Gwpm7JK9+YvlB701rcQTzjUZ1JgUoPTnoQA=="], + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.53.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-Xt2byDZ+6OVNuREgBXr4+CZDJtrVso5woFtpKdGPhpTPHcNG7D8YXeQzpNbFRxzTVqJf7kvPMCub/pcGUWgBjA=="], - "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.40.0", "", { "os": "linux", "cpu": "arm" }, "sha512-GoCsPibtVdJFPv/BOIvBKO/XmwZLwaNWdyD8TKlXuqp0veo2sHE+A/vpMQ5iSArRUz/uaoj4h5S6Pn0+PdhRjg=="], + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.53.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-+LdZSldy/I9N8+klim/Y1HsKbJ3BbInHav5qE9Iy77dtHC/pibw1SR/fXlWyAk0ThnpRKoODwnAuSjqxFRDHUQ=="], - "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.40.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-L5ZLphTjjAD9leJzSLI7rr8fNqJMlGDKlazW2tX4IUF9P7R5TMQPElpH82Q7eNIDQnQlAyiNVfRPfP2vM5Avvg=="], + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.53.2", "", { "os": "linux", "cpu": "none" }, "sha512-8ms8sjmyc1jWJS6WdNSA23rEfdjWB30LH8Wqj0Cqvv7qSHnvw6kgMMXRdop6hkmGPlyYBdRPkjJnj3KCUHV/uQ=="], - "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.40.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-ATZvCRGCDtv1Y4gpDIXsS+wfFeFuLwVxyUBSLawjgXK2tRE6fnsQEkE4csQQYWlBlsFztRzCnBvWVfcae/1qxQ=="], + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.53.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-3HRQLUQbpBDMmzoxPJYd3W6vrVHOo2cVW8RUo87Xz0JPJcBLBr5kZ1pGcQAhdZgX9VV7NbGNipah1omKKe23/g=="], - "@rollup/rollup-linux-loongarch64-gnu": ["@rollup/rollup-linux-loongarch64-gnu@4.40.0", "", { "os": "linux", "cpu": "none" }, "sha512-wG9e2XtIhd++QugU5MD9i7OnpaVb08ji3P1y/hNbxrQ3sYEelKJOq1UJ5dXczeo6Hj2rfDEL5GdtkMSVLa/AOg=="], + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.53.2", "", { "os": "linux", "cpu": "none" }, "sha512-fMjKi+ojnmIvhk34gZP94vjogXNNUKMEYs+EDaB/5TG/wUkoeua7p7VCHnE6T2Tx+iaghAqQX8teQzcvrYpaQA=="], - "@rollup/rollup-linux-powerpc64le-gnu": ["@rollup/rollup-linux-powerpc64le-gnu@4.40.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-vgXfWmj0f3jAUvC7TZSU/m/cOE558ILWDzS7jBhiCAFpY2WEBn5jqgbqvmzlMjtp8KlLcBlXVD2mkTSEQE6Ixw=="], + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.53.2", "", { "os": "linux", "cpu": "none" }, "sha512-XuGFGU+VwUUV5kLvoAdi0Wz5Xbh2SrjIxCtZj6Wq8MDp4bflb/+ThZsVxokM7n0pcbkEr2h5/pzqzDYI7cCgLQ=="], - "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.40.0", "", { "os": "linux", "cpu": "none" }, "sha512-uJkYTugqtPZBS3Z136arevt/FsKTF/J9dEMTX/cwR7lsAW4bShzI2R0pJVw+hcBTWF4dxVckYh72Hk3/hWNKvA=="], + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.53.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-w6yjZF0P+NGzWR3AXWX9zc0DNEGdtvykB03uhonSHMRa+oWA6novflo2WaJr6JZakG2ucsyb+rvhrKac6NIy+w=="], - "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.40.0", "", { "os": "linux", "cpu": "none" }, "sha512-rKmSj6EXQRnhSkE22+WvrqOqRtk733x3p5sWpZilhmjnkHkpeCgWsFFo0dGnUGeA+OZjRl3+VYq+HyCOEuwcxQ=="], + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.53.2", "", { "os": "linux", "cpu": "x64" }, "sha512-yo8d6tdfdeBArzC7T/PnHd7OypfI9cbuZzPnzLJIyKYFhAQ8SvlkKtKBMbXDxe1h03Rcr7u++nFS7tqXz87Gtw=="], - "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.40.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-SpnYlAfKPOoVsQqmTFJ0usx0z84bzGOS9anAC0AZ3rdSo3snecihbhFTlJZ8XMwzqAcodjFU4+/SM311dqE5Sw=="], + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.53.2", "", { "os": "linux", "cpu": "x64" }, "sha512-ah59c1YkCxKExPP8O9PwOvs+XRLKwh/mV+3YdKqQ5AMQ0r4M4ZDuOrpWkUaqO7fzAHdINzV9tEVu8vNw48z0lA=="], - "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.40.0", "", { "os": "linux", "cpu": "x64" }, "sha512-RcDGMtqF9EFN8i2RYN2W+64CdHruJ5rPqrlYw+cgM3uOVPSsnAQps7cpjXe9be/yDp8UC7VLoCoKC8J3Kn2FkQ=="], + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.53.2", "", { "os": "none", "cpu": "arm64" }, "sha512-4VEd19Wmhr+Zy7hbUsFZ6YXEiP48hE//KPLCSVNY5RMGX2/7HZ+QkN55a3atM1C/BZCGIgqN+xrVgtdak2S9+A=="], - "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.40.0", "", { "os": "linux", "cpu": "x64" }, "sha512-HZvjpiUmSNx5zFgwtQAV1GaGazT2RWvqeDi0hV+AtC8unqqDSsaFjPxfsO6qPtKRRg25SisACWnJ37Yio8ttaw=="], + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.53.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-IlbHFYc/pQCgew/d5fslcy1KEaYVCJ44G8pajugd8VoOEI8ODhtb/j8XMhLpwHCMB3yk2J07ctup10gpw2nyMA=="], - "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.40.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-UtZQQI5k/b8d7d3i9AZmA/t+Q4tk3hOC0tMOMSq2GlMYOfxbesxG4mJSeDp0EHs30N9bsfwUvs3zF4v/RzOeTQ=="], + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.53.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-lNlPEGgdUfSzdCWU176ku/dQRnA7W+Gp8d+cWv73jYrb8uT7HTVVxq62DUYxjbaByuf1Yk0RIIAbDzp+CnOTFg=="], - "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.40.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-+m03kvI2f5syIqHXCZLPVYplP8pQch9JHyXKZ3AGMKlg8dCyr2PKHjwRLiW53LTrN/Nc3EqHOKxUxzoSPdKddA=="], + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.53.2", "", { "os": "win32", "cpu": "x64" }, "sha512-S6YojNVrHybQis2lYov1sd+uj7K0Q05NxHcGktuMMdIQ2VixGwAfbJ23NnlvvVV1bdpR2m5MsNBViHJKcA4ADw=="], - "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.40.0", "", { "os": "win32", "cpu": "x64" }, "sha512-lpPE1cLfP5oPzVjKMx10pgBmKELQnFJXHgvtHCtuJWOv8MxqdEIMNtgHgBFf7Ea2/7EuVwa9fodWUfXAlXZLZQ=="], + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.53.2", "", { "os": "win32", "cpu": "x64" }, "sha512-k+/Rkcyx//P6fetPoLMb8pBeqJBNGx81uuf7iljX9++yNBVRDQgD04L+SVXmXmh5ZP4/WOp4mWF0kmi06PW2tA=="], - "@scure/base": ["@scure/base@1.2.4", "", {}, "sha512-5Yy9czTO47mqz+/J8GM6GIId4umdCk1wc1q8rKERQulIoc8VP9pzDcghv10Tl2E7R96ZUx/PhND3ESYUQX8NuQ=="], + "@safe-global/safe-smart-account": ["@safe-global/safe-smart-account@github:safe-global/safe-smart-account#dc437e8", {}, "safe-fndn-safe-smart-account-dc437e8"], - "@scure/bip32": ["@scure/bip32@1.6.2", "", { "dependencies": { "@noble/curves": "~1.8.1", "@noble/hashes": "~1.7.1", "@scure/base": "~1.2.2" } }, "sha512-t96EPDMbtGgtb7onKKqxRLfE5g05k7uHnHRM2xdE6BP/ZmxaLtPek4J4KfVn/90IQNrU1IOAqMgiDtUdtbe3nw=="], + "@scure/base": ["@scure/base@1.2.6", "", {}, "sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg=="], - "@scure/bip39": ["@scure/bip39@1.5.4", "", { "dependencies": { "@noble/hashes": "~1.7.1", "@scure/base": "~1.2.4" } }, "sha512-TFM4ni0vKvCfBpohoh+/lY05i9gRbSwXWngAsF4CABQxoaOHijxuaZ2R6cStDQ5CHtHO9aGJTr4ksVJASRRyMA=="], + "@scure/bip32": ["@scure/bip32@1.7.0", "", { "dependencies": { "@noble/curves": "~1.9.0", "@noble/hashes": "~1.8.0", "@scure/base": "~1.2.5" } }, "sha512-E4FFX/N3f4B80AKWp5dP6ow+flD1LQZo/w8UnLGYZO674jS6YnYeepycOOksv+vLPSpgN35wgKgy+ybfTb2SMw=="], + + "@scure/bip39": ["@scure/bip39@1.6.0", "", { "dependencies": { "@noble/hashes": "~1.8.0", "@scure/base": "~1.2.5" } }, "sha512-+lF0BbLiJNwVlev4eKelw1WWLaiKXw7sSl8T6FvBlWkdX+94aGJ4o8XjUdlyhTCjd8c+B3KT3JfS8P0bLRNU6A=="], "@standard-schema/spec": ["@standard-schema/spec@1.0.0", "", {}, "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA=="], - "@types/bn.js": ["@types/bn.js@5.1.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-Xh8vSwUeMKeYYrj3cX4lGQgFSF/N03r+tv4AiLl1SucqV+uTQpxRcnM8AkXKHwYP9ZPXOYXRr2KPXpVlIvqh9w=="], + "@types/bn.js": ["@types/bn.js@5.2.0", "", { "dependencies": { "@types/node": "*" } }, "sha512-DLbJ1BPqxvQhIGbeu8VbUC1DiAiahHtAYvA0ZEAa4P31F7IaArc8z3C3BRQdWX4mtLQuABG4yzp76ZrS02Ui1Q=="], + + "@types/bun": ["@types/bun@1.3.2", "", { "dependencies": { "bun-types": "1.3.2" } }, "sha512-t15P7k5UIgHKkxwnMNkJbWlh/617rkDGEdSsDbu+qNHTaz9SKf7aC8fiIlUdD5RPpH6GEkP0cK7WlvmrEBRtWg=="], - "@types/bun": ["@types/bun@1.2.10", "", { "dependencies": { "bun-types": "1.2.10" } }, "sha512-eilv6WFM3M0c9ztJt7/g80BDusK98z/FrFwseZgT4bXCq2vPhXD4z8R3oddmAn+R/Nmz9vBn4kweJKmGTZj+lg=="], + "@types/chai": ["@types/chai@5.2.3", "", { "dependencies": { "@types/deep-eql": "*", "assertion-error": "^2.0.1" } }, "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA=="], + + "@types/deep-eql": ["@types/deep-eql@4.0.2", "", {}, "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw=="], "@types/elliptic": ["@types/elliptic@6.4.18", "", { "dependencies": { "@types/bn.js": "*" } }, "sha512-UseG6H5vjRiNpQvrhy4VF/JXdA3V/Fp5amvveaL+fs28BZ6xIKJBPnUPRlEaZpysD9MbpfaLi8lbl7PGUAkpWw=="], - "@types/estree": ["@types/estree@1.0.7", "", {}, "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ=="], + "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="], - "@types/long": ["@types/long@4.0.2", "", {}, "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA=="], + "@types/node": ["@types/node@24.10.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A=="], - "@types/node": ["@types/node@22.14.1", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-u0HuPQwe/dHrItgHHpmw3N2fYCR6x4ivMNbPHRkBVP4CvN+kiRrKHWk3i8tXiO/joPwXLMYvF9TTF0eqgHIuOw=="], + "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="], - "@vitest/expect": ["@vitest/expect@3.1.2", "", { "dependencies": { "@vitest/spy": "3.1.2", "@vitest/utils": "3.1.2", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-O8hJgr+zREopCAqWl3uCVaOdqJwZ9qaDwUP7vy3Xigad0phZe9APxKhPcDNqYYi0rX5oMvwJMSCAXY2afqeTSA=="], + "@vitest/expect": ["@vitest/expect@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig=="], - "@vitest/mocker": ["@vitest/mocker@3.1.2", "", { "dependencies": { "@vitest/spy": "3.1.2", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0" }, "optionalPeers": ["msw", "vite"] }, "sha512-kOtd6K2lc7SQ0mBqYv/wdGedlqPdM/B38paPY+OwJ1XiNi44w3Fpog82UfOibmHaV9Wod18A09I9SCKLyDMqgw=="], + "@vitest/mocker": ["@vitest/mocker@3.2.4", "", { "dependencies": { "@vitest/spy": "3.2.4", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ=="], - "@vitest/pretty-format": ["@vitest/pretty-format@3.1.2", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-R0xAiHuWeDjTSB3kQ3OQpT8Rx3yhdOAIm/JM4axXxnG7Q/fS8XUwggv/A4xzbQA+drYRjzkMnpYnOGAc4oeq8w=="], + "@vitest/pretty-format": ["@vitest/pretty-format@3.2.4", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA=="], - "@vitest/runner": ["@vitest/runner@3.1.2", "", { "dependencies": { "@vitest/utils": "3.1.2", "pathe": "^2.0.3" } }, "sha512-bhLib9l4xb4sUMPXnThbnhX2Yi8OutBMA8Yahxa7yavQsFDtwY/jrUZwpKp2XH9DhRFJIeytlyGpXCqZ65nR+g=="], + "@vitest/runner": ["@vitest/runner@3.2.4", "", { "dependencies": { "@vitest/utils": "3.2.4", "pathe": "^2.0.3", "strip-literal": "^3.0.0" } }, "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ=="], - "@vitest/snapshot": ["@vitest/snapshot@3.1.2", "", { "dependencies": { "@vitest/pretty-format": "3.1.2", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-Q1qkpazSF/p4ApZg1vfZSQ5Yw6OCQxVMVrLjslbLFA1hMDrT2uxtqMaw8Tc/jy5DLka1sNs1Y7rBcftMiaSH/Q=="], + "@vitest/snapshot": ["@vitest/snapshot@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ=="], - "@vitest/spy": ["@vitest/spy@3.1.2", "", { "dependencies": { "tinyspy": "^3.0.2" } }, "sha512-OEc5fSXMws6sHVe4kOFyDSj/+4MSwst0ib4un0DlcYgQvRuYQ0+M2HyqGaauUMnjq87tmUaMNDxKQx7wNfVqPA=="], + "@vitest/spy": ["@vitest/spy@3.2.4", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw=="], - "@vitest/utils": ["@vitest/utils@3.1.2", "", { "dependencies": { "@vitest/pretty-format": "3.1.2", "loupe": "^3.1.3", "tinyrainbow": "^2.0.0" } }, "sha512-5GGd0ytZ7BH3H6JTj9Kw7Prn1Nbg0wZVrIvou+UWxm54d+WoXXgAgjFJ8wn3LdagWLFSEfpPeyYrByZaGEZHLg=="], + "@vitest/utils": ["@vitest/utils@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA=="], - "@wagmi/cli": ["@wagmi/cli@2.2.1", "", { "dependencies": { "abitype": "^1.0.4", "bundle-require": "^4.0.2", "cac": "^6.7.14", "change-case": "^5.4.4", "chokidar": "4.0.1", "dedent": "^0.7.0", "dotenv": "^16.3.1", "dotenv-expand": "^10.0.0", "esbuild": "^0.19.0", "escalade": "3.2.0", "fdir": "^6.1.1", "nanospinner": "1.2.2", "pathe": "^1.1.2", "picocolors": "^1.0.0", "picomatch": "^3.0.0", "prettier": "^3.0.3", "viem": "2.x", "zod": "^3.22.2" }, "peerDependencies": { "typescript": ">=5.0.4" }, "optionalPeers": ["typescript"], "bin": { "wagmi": "dist/esm/cli.js" } }, "sha512-d7zORH7ab+TwpwDpwx28Lv5uW3cKWN8V8DOGzW+JjTJ5xuqBqmsJmwdFaQYZ6cSg5pbc74N2LLY6s6YMN71LPg=="], + "@wagmi/cli": ["@wagmi/cli@2.7.1", "", { "dependencies": { "abitype": "^1.0.4", "bundle-require": "^5.1.0", "cac": "^6.7.14", "change-case": "^5.4.4", "chokidar": "4.0.1", "dedent": "^0.7.0", "dotenv": "^16.3.1", "dotenv-expand": "^10.0.0", "esbuild": "~0.25.4", "escalade": "3.2.0", "fdir": "^6.1.1", "nanospinner": "1.2.2", "pathe": "^1.1.2", "picocolors": "^1.0.0", "picomatch": "^3.0.0", "prettier": "^3.0.3", "viem": "2.x", "zod": "^4.1.11" }, "peerDependencies": { "typescript": ">=5.0.4" }, "optionalPeers": ["typescript"], "bin": { "wagmi": "dist/esm/cli.js" } }, "sha512-yuhTvbNkOAxMVDigO2IPySmV8/2i5KeU0gQs4XoGNL+hIoH/2tYlJ2BzbC/ylC8LWatWHlNMYspWKw7rE+izqw=="], - "abitype": ["abitype@1.0.8", "", { "peerDependencies": { "typescript": ">=5.0.4", "zod": "^3 >=3.22.0" }, "optionalPeers": ["typescript", "zod"] }, "sha512-ZeiI6h3GnW06uYDLx0etQtX/p8E24UaHHBj57RSjK7YBFe7iuVn07EDpOeP451D06sF27VOz9JJPlIKJmXgkEg=="], + "abitype": ["abitype@1.1.1", "", { "peerDependencies": { "typescript": ">=5.0.4", "zod": "^3.22.0 || ^4.0.0" }, "optionalPeers": ["typescript", "zod"] }, "sha512-Loe5/6tAgsBukY95eGaPSDmQHIjRZYQq8PB1MpsNccDIK8WiV+Uw6WzaIXipvaxTEL2yEB0OpEaQv3gs8pkS9Q=="], "ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="], @@ -272,31 +261,21 @@ "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="], - "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="], - - "axios": ["axios@1.8.4", "", { "dependencies": { "follow-redirects": "^1.15.6", "form-data": "^4.0.0", "proxy-from-env": "^1.1.0" } }, "sha512-eBSYY4Y68NNlHbHBMdeDmKNtDgXWhQsJcGqzO3iLUM0GraQFSS9cVgPX5I9b3lbdFKyYoAEGAZF1DwhTaljNAw=="], - "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="], - "bech32": ["bech32@1.1.4", "", {}, "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ=="], - - "bincode-ts": ["bincode-ts@0.1.1", "", { "dependencies": { "typescript": "^4.9.4" } }, "sha512-tVKF3qwY4GiosjwO7/RZydVwWB+bduoO/iOMzdsCEt2t3K5fhAGkPfz/UooNHgnFDM/331J5ITTarnTMiBz2Zw=="], - - "bn.js": ["bn.js@5.2.1", "", {}, "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ=="], + "bn.js": ["bn.js@4.12.2", "", {}, "sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw=="], "brorand": ["brorand@1.1.0", "", {}, "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w=="], "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="], - "bun-types": ["bun-types@1.2.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-b5ITZMnVdf3m1gMvJHG+gIfeJHiQPJak0f7925Hxu6ZN5VKA8AGy4GZ4lM+Xkn6jtWxg5S3ldWvfmXdvnkp3GQ=="], + "bun-types": ["bun-types@1.3.2", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-i/Gln4tbzKNuxP70OWhJRZz1MRfvqExowP7U6JKoI8cntFrtxg7RJK3jvz7wQW54UuvNC8tbKHHri5fy74FVqg=="], - "bundle-require": ["bundle-require@4.2.1", "", { "dependencies": { "load-tsconfig": "^0.2.3" }, "peerDependencies": { "esbuild": ">=0.17" } }, "sha512-7Q/6vkyYAwOmQNRw75x+4yRtZCZJXUDmHHlFdkiV0wgv/reNjtJwpu1jPJ0w2kbEpIM0uoKI3S4/f39dU7AjSA=="], + "bundle-require": ["bundle-require@5.1.0", "", { "dependencies": { "load-tsconfig": "^0.2.3" }, "peerDependencies": { "esbuild": ">=0.18" } }, "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA=="], "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="], - "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], - - "chai": ["chai@5.2.0", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw=="], + "chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="], "change-case": ["change-case@5.4.4", "", {}, "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w=="], @@ -306,49 +285,31 @@ "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="], - "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="], - - "cosmjs-types": ["cosmjs-types@0.9.0", "", {}, "sha512-MN/yUe6mkJwHnCFfsNPeCfXVhyxHYW6c/xDUzrSbBycYzw++XvWDMJArXp2pLdgD6FQ8DW79vkPjeNKVrXaHeQ=="], + "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="], - "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="], + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], "dedent": ["dedent@0.7.0", "", {}, "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA=="], "deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="], - "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], - - "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], - - "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="], - - "dotenv": ["dotenv@16.5.0", "", {}, "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg=="], + "dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="], "dotenv-expand": ["dotenv-expand@10.0.0", "", {}, "sha512-GopVGCpVS1UKH75VKHGuQFqS1Gusej0z4FyQkPdwjil2gNIv+LNsqBlboOzpJFZKVT95GkCyWJbBSdFEFUWI2A=="], "ds-test": ["ds-test@github:dapphub/ds-test#e282159", {}, "dapphub-ds-test-e282159"], - "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], - "ecies-geth": ["ecies-geth@1.7.5", "", { "dependencies": { "elliptic": "^6.6.1", "secp256k1": "^5.0.1" } }, "sha512-0T2OBjgyCUhG/Jgs4IiUax7KvgueSt9VuoH2IJtWwKjPOuz0fRiL1MMwECV82useHk9mfYHrEL6HEZnhS7K+0Q=="], - "effect": ["effect@3.14.11", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "fast-check": "^3.23.1" } }, "sha512-PPfiu7QRtmmrgH6VWZp/rY1S8SSLJofx5betRuTPGG868G3f0C7yvPOa6SZPLG5ra2yCd1Vfm7cdeI26ZVGGlA=="], + "effect": ["effect@3.19.3", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "fast-check": "^3.23.1" } }, "sha512-LodiPXiyUJWQ5LoMhUGbu0acD2ff5A5teJtUlLKDPVfoeWEBcZLlzK8BeVXpVa0f30UsdHouVCf0C/E0TxYMrA=="], "elliptic": ["elliptic@6.6.1", "", { "dependencies": { "bn.js": "^4.11.9", "brorand": "^1.1.0", "hash.js": "^1.0.0", "hmac-drbg": "^1.0.1", "inherits": "^2.0.4", "minimalistic-assert": "^1.0.1", "minimalistic-crypto-utils": "^1.0.1" } }, "sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g=="], "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], - "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="], + "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="], - "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], - - "es-module-lexer": ["es-module-lexer@1.6.0", "", {}, "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ=="], - - "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="], - - "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="], - - "esbuild": ["esbuild@0.19.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.19.12", "@esbuild/android-arm": "0.19.12", "@esbuild/android-arm64": "0.19.12", "@esbuild/android-x64": "0.19.12", "@esbuild/darwin-arm64": "0.19.12", "@esbuild/darwin-x64": "0.19.12", "@esbuild/freebsd-arm64": "0.19.12", "@esbuild/freebsd-x64": "0.19.12", "@esbuild/linux-arm": "0.19.12", "@esbuild/linux-arm64": "0.19.12", "@esbuild/linux-ia32": "0.19.12", "@esbuild/linux-loong64": "0.19.12", "@esbuild/linux-mips64el": "0.19.12", "@esbuild/linux-ppc64": "0.19.12", "@esbuild/linux-riscv64": "0.19.12", "@esbuild/linux-s390x": "0.19.12", "@esbuild/linux-x64": "0.19.12", "@esbuild/netbsd-x64": "0.19.12", "@esbuild/openbsd-x64": "0.19.12", "@esbuild/sunos-x64": "0.19.12", "@esbuild/win32-arm64": "0.19.12", "@esbuild/win32-ia32": "0.19.12", "@esbuild/win32-x64": "0.19.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg=="], + "esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="], "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="], @@ -356,46 +317,24 @@ "eventemitter3": ["eventemitter3@5.0.1", "", {}, "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA=="], - "expect-type": ["expect-type@1.2.1", "", {}, "sha512-/kP8CAwxzLVEeFrMm4kMmy4CCDlpipyA7MYLVrdJIkV0fYF0UaigQHRsxHiuY/GEea+bh4KSv3TIlgr+2UL6bw=="], + "expect-type": ["expect-type@1.2.2", "", {}, "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA=="], "fast-check": ["fast-check@3.23.2", "", { "dependencies": { "pure-rand": "^6.1.0" } }, "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A=="], - "fdir": ["fdir@6.4.4", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg=="], + "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], - "follow-redirects": ["follow-redirects@1.15.9", "", {}, "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ=="], - - "forge-std": ["forge-std@github:foundry-rs/forge-std#551a2d3", {}, "foundry-rs-forge-std-551a2d3"], - - "form-data": ["form-data@4.0.2", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "mime-types": "^2.1.12" } }, "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w=="], + "forge-std": ["forge-std@github:foundry-rs/forge-std#27ab851", {}, "foundry-rs-forge-std-27ab851"], "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], - "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], - "get-caller-file": ["get-caller-file@2.0.5", "", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="], - "get-east-asian-width": ["get-east-asian-width@1.3.1", "", {}, "sha512-R1QfovbPsKmosqTnPoRFiJ7CF9MLRgb53ChvMZm+r4p76/+8yKDy17qLL2PKInORy2RkZZekuK0efYgmzTkXyQ=="], - - "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], - - "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], - - "get-tsconfig": ["get-tsconfig@4.10.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A=="], - - "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], - - "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], - - "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], - - "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + "get-east-asian-width": ["get-east-asian-width@1.4.0", "", {}, "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q=="], - "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="], + "get-tsconfig": ["get-tsconfig@4.13.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ=="], "hash.js": ["hash.js@1.1.7", "", { "dependencies": { "inherits": "^2.0.3", "minimalistic-assert": "^1.0.1" } }, "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA=="], - "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], - "hmac-drbg": ["hmac-drbg@1.0.1", "", { "dependencies": { "hash.js": "^1.0.3", "minimalistic-assert": "^1.0.0", "minimalistic-crypto-utils": "^1.0.1" } }, "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg=="], "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="], @@ -404,13 +343,9 @@ "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], - "isomorphic-ws": ["isomorphic-ws@4.0.1", "", { "peerDependencies": { "ws": "*" } }, "sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w=="], - - "isows": ["isows@1.0.6", "", { "peerDependencies": { "ws": "*" } }, "sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw=="], + "isows": ["isows@1.0.7", "", { "peerDependencies": { "ws": "*" } }, "sha512-I1fSfDCZL5P0v33sVqeTDSpcstAg/N+wF5HS033mogOVIp4B+oHC7oOCsA3axAbBSGTJ8QubbNmnIRN/h8U7hg=="], - "libsodium-sumo": ["libsodium-sumo@0.7.15", "", {}, "sha512-5tPmqPmq8T8Nikpm1Nqj0hBHvsLFCXvdhBFV7SGOitQPZAA6jso8XoL0r4L7vmfKXr486fiQInvErHtEvizFMw=="], - - "libsodium-wrappers-sumo": ["libsodium-wrappers-sumo@0.7.15", "", { "dependencies": { "libsodium-sumo": "^0.7.15" } }, "sha512-aSWY8wKDZh5TC7rMvEdTHoyppVq/1dTSAeAR7H6pzd6QRT3vQWcT5pGwCotLcpPEOLXX6VvqihSPkpEhYAjANA=="], + "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="], "lightning-rod-contracts": ["lightning-rod-contracts@workspace:contracts"], @@ -420,15 +355,9 @@ "long": ["long@5.3.2", "", {}, "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="], - "loupe": ["loupe@3.1.3", "", {}, "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug=="], - - "magic-string": ["magic-string@0.30.17", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0" } }, "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA=="], + "loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="], - "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], - - "mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], - - "mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], + "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="], "minimalistic-assert": ["minimalistic-assert@1.0.1", "", {}, "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A=="], @@ -444,39 +373,33 @@ "node-gyp-build": ["node-gyp-build@4.8.4", "", { "bin": { "node-gyp-build": "bin.js", "node-gyp-build-optional": "optional.js", "node-gyp-build-test": "build-test.js" } }, "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ=="], - "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], - - "ox": ["ox@0.6.9", "", { "dependencies": { "@adraffy/ens-normalize": "^1.10.1", "@noble/curves": "^1.6.0", "@noble/hashes": "^1.5.0", "@scure/bip32": "^1.5.0", "@scure/bip39": "^1.4.0", "abitype": "^1.0.6", "eventemitter3": "5.0.1" }, "peerDependencies": { "typescript": ">=5.4.0" }, "optionalPeers": ["typescript"] }, "sha512-wi5ShvzE4eOcTwQVsIPdFr+8ycyX+5le/96iAJutaZAvCes1J0+RvpEPg5QDPDiaR0XQQAvZVl7AwqQcINuUug=="], + "ox": ["ox@0.9.6", "", { "dependencies": { "@adraffy/ens-normalize": "^1.11.0", "@noble/ciphers": "^1.3.0", "@noble/curves": "1.9.1", "@noble/hashes": "^1.8.0", "@scure/bip32": "^1.7.0", "@scure/bip39": "^1.6.0", "abitype": "^1.0.9", "eventemitter3": "5.0.1" }, "peerDependencies": { "typescript": ">=5.4.0" }, "optionalPeers": ["typescript"] }, "sha512-8SuCbHPvv2eZLYXrNmC0EC12rdzXQLdhnOMlHDW2wiCPLxBrOOJwX5L5E61by+UjTPOryqQiRSnjIKCI+GykKg=="], "pathe": ["pathe@1.1.2", "", {}, "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ=="], - "pathval": ["pathval@2.0.0", "", {}, "sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA=="], + "pathval": ["pathval@2.0.1", "", {}, "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ=="], "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], "picomatch": ["picomatch@3.0.1", "", {}, "sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag=="], - "postcss": ["postcss@8.5.3", "", { "dependencies": { "nanoid": "^3.3.8", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A=="], + "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="], - "prettier": ["prettier@3.5.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="], + "prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="], - "prettier-plugin-organize-imports": ["prettier-plugin-organize-imports@4.1.0", "", { "peerDependencies": { "prettier": ">=2.0", "typescript": ">=2.9", "vue-tsc": "^2.1.0" }, "optionalPeers": ["vue-tsc"] }, "sha512-5aWRdCgv645xaa58X8lOxzZoiHAldAPChljr/MT0crXVOWTZ+Svl4hIWlz+niYSlO6ikE5UXkN1JrRvIP2ut0A=="], + "prettier-plugin-organize-imports": ["prettier-plugin-organize-imports@4.3.0", "", { "peerDependencies": { "prettier": ">=2.0", "typescript": ">=2.9", "vue-tsc": "^2.1.0 || 3" }, "optionalPeers": ["vue-tsc"] }, "sha512-FxFz0qFhyBsGdIsb697f/EkvHzi5SZOhWAjxcx2dLt+Q532bAlhswcXGYB1yzjZ69kW8UoadFBw7TyNwlq96Iw=="], - "protobufjs": ["protobufjs@6.11.4", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.4", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.0", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.0", "@types/long": "^4.0.1", "@types/node": ">=13.7.0", "long": "^4.0.0" }, "bin": { "pbjs": "bin/pbjs", "pbts": "bin/pbts" } }, "sha512-5kQWPaJHi1WoCpjTGszzQ32PG2F4+wRY6BmAT4Vfw56Q2FZ4YZzK20xUYQH4YkfehY1e6QSICrJquM6xXZNcrw=="], - - "proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="], + "protobufjs": ["protobufjs@7.5.4", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.4", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.0", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.0", "@types/node": ">=13.7.0", "long": "^5.0.0" } }, "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg=="], "pure-rand": ["pure-rand@6.1.0", "", {}, "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA=="], "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="], - "readonly-date": ["readonly-date@1.0.0", "", {}, "sha512-tMKIV7hlk0h4mO3JTmmVuIlJVXjKk3Sep9Bf5OH0O+758ruuVkUy2J9SttDLm91IEX/WHlXPSpxMGjPj4beMIQ=="], - "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="], "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="], - "rollup": ["rollup@4.40.0", "", { "dependencies": { "@types/estree": "1.0.7" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.40.0", "@rollup/rollup-android-arm64": "4.40.0", "@rollup/rollup-darwin-arm64": "4.40.0", "@rollup/rollup-darwin-x64": "4.40.0", "@rollup/rollup-freebsd-arm64": "4.40.0", "@rollup/rollup-freebsd-x64": "4.40.0", "@rollup/rollup-linux-arm-gnueabihf": "4.40.0", "@rollup/rollup-linux-arm-musleabihf": "4.40.0", "@rollup/rollup-linux-arm64-gnu": "4.40.0", "@rollup/rollup-linux-arm64-musl": "4.40.0", "@rollup/rollup-linux-loongarch64-gnu": "4.40.0", "@rollup/rollup-linux-powerpc64le-gnu": "4.40.0", "@rollup/rollup-linux-riscv64-gnu": "4.40.0", "@rollup/rollup-linux-riscv64-musl": "4.40.0", "@rollup/rollup-linux-s390x-gnu": "4.40.0", "@rollup/rollup-linux-x64-gnu": "4.40.0", "@rollup/rollup-linux-x64-musl": "4.40.0", "@rollup/rollup-win32-arm64-msvc": "4.40.0", "@rollup/rollup-win32-ia32-msvc": "4.40.0", "@rollup/rollup-win32-x64-msvc": "4.40.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-Noe455xmA96nnqH5piFtLobsGbCij7Tu+tb3c1vYjNbTkfzGqXqQXG3wJaYXkRZuQ0vEYN4bhwg7QnIrqB5B+w=="], + "rollup": ["rollup@4.53.2", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.53.2", "@rollup/rollup-android-arm64": "4.53.2", "@rollup/rollup-darwin-arm64": "4.53.2", "@rollup/rollup-darwin-x64": "4.53.2", "@rollup/rollup-freebsd-arm64": "4.53.2", "@rollup/rollup-freebsd-x64": "4.53.2", "@rollup/rollup-linux-arm-gnueabihf": "4.53.2", "@rollup/rollup-linux-arm-musleabihf": "4.53.2", "@rollup/rollup-linux-arm64-gnu": "4.53.2", "@rollup/rollup-linux-arm64-musl": "4.53.2", "@rollup/rollup-linux-loong64-gnu": "4.53.2", "@rollup/rollup-linux-ppc64-gnu": "4.53.2", "@rollup/rollup-linux-riscv64-gnu": "4.53.2", "@rollup/rollup-linux-riscv64-musl": "4.53.2", "@rollup/rollup-linux-s390x-gnu": "4.53.2", "@rollup/rollup-linux-x64-gnu": "4.53.2", "@rollup/rollup-linux-x64-musl": "4.53.2", "@rollup/rollup-openharmony-arm64": "4.53.2", "@rollup/rollup-win32-arm64-msvc": "4.53.2", "@rollup/rollup-win32-ia32-msvc": "4.53.2", "@rollup/rollup-win32-x64-gnu": "4.53.2", "@rollup/rollup-win32-x64-msvc": "4.53.2", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-MHngMYwGJVi6Fmnk6ISmnk7JAHRNF0UkuucA0CUW3N3a4KnONPEZz+vUanQP/ZC/iY1Qkf3bwPWzyY84wEks1g=="], "secp256k1": ["secp256k1@5.0.1", "", { "dependencies": { "elliptic": "^6.5.7", "node-addon-api": "^5.0.0", "node-gyp-build": "^4.2.0" } }, "sha512-lDFs9AAIaWP9UCdtWrotXWWF9t8PWgQDcxqgAnpM9rMqxb3Oaq2J0thzPVSxBwdJgyQtkU/sYtFtbM1RSt/iYA=="], @@ -488,47 +411,45 @@ "stackback": ["stackback@0.0.2", "", {}, "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="], - "std-env": ["std-env@3.9.0", "", {}, "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw=="], + "std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="], "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], "strip-ansi": ["strip-ansi@7.1.2", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA=="], - "symbol-observable": ["symbol-observable@2.0.3", "", {}, "sha512-sQV7phh2WCYAn81oAkakC5qjq2Ml0g8ozqz03wOGnx9dDlG1de6yrF+0RAzSJD8fPUow3PTSMf2SAbOGxb93BA=="], + "strip-literal": ["strip-literal@3.1.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg=="], "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="], "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="], - "tinyglobby": ["tinyglobby@0.2.13", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-mEwzpUgrLySlveBwEVDMKk5B57bhLPYovRfPAXD5gA/98Opn0rCDj3GtLwFvCvH5RK9uPCExUROW5NjDwvqkxw=="], + "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="], - "tinypool": ["tinypool@1.0.2", "", {}, "sha512-al6n+QEANGFOMf/dmUMsuS5/r9B06uwlyNjZZql/zv8J7ybHCgoihBNORZCY2mzUuAnomQa2JdhyHKzZxPCrFA=="], + "tinypool": ["tinypool@1.1.1", "", {}, "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="], "tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="], - "tinyspy": ["tinyspy@3.0.2", "", {}, "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q=="], + "tinyspy": ["tinyspy@4.0.4", "", {}, "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q=="], - "tsx": ["tsx@4.19.3", "", { "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ=="], + "tsx": ["tsx@4.20.6", "", { "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg=="], - "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="], + "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], - "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="], + "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="], - "viem": ["viem@2.28.0", "", { "dependencies": { "@noble/curves": "1.8.2", "@noble/hashes": "1.7.2", "@scure/bip32": "1.6.2", "@scure/bip39": "1.5.4", "abitype": "1.0.8", "isows": "1.0.6", "ox": "0.6.9", "ws": "8.18.1" }, "peerDependencies": { "typescript": ">=5.0.4" }, "optionalPeers": ["typescript"] }, "sha512-Z4W5O1pe+6pirYTFm451FcZmfGAUxUWt2L/eWC+YfTF28j/8rd7q6MBAi05lMN4KhLJjhN0s5YGIPB+kf1L20g=="], + "viem": ["viem@2.38.6", "", { "dependencies": { "@noble/curves": "1.9.1", "@noble/hashes": "1.8.0", "@scure/bip32": "1.7.0", "@scure/bip39": "1.6.0", "abitype": "1.1.0", "isows": "1.0.7", "ox": "0.9.6", "ws": "8.18.3" }, "peerDependencies": { "typescript": ">=5.0.4" }, "optionalPeers": ["typescript"] }, "sha512-aqO6P52LPXRjdnP6rl5Buab65sYa4cZ6Cpn+k4OLOzVJhGIK8onTVoKMFMT04YjDfyDICa/DZyV9HmvLDgcjkw=="], - "vite": ["vite@6.3.2", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.3", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.12" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-ZSvGOXKGceizRQIZSz7TGJ0pS3QLlVY/9hwxVh17W3re67je1RKYzFHivZ/t0tubU78Vkyb9WnHPENSBCzbckg=="], + "vite": ["vite@7.2.2", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-BxAKBWmIbrDgrokdGZH1IgkIk/5mMHDreLDmCJ0qpyJaAteP8NvMhkwr/ZCQNqNH97bw/dANTE9PDzqwJghfMQ=="], - "vite-node": ["vite-node@3.1.2", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.0", "es-module-lexer": "^1.6.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-/8iMryv46J3aK13iUXsei5G/A3CUlW4665THCPS+K8xAaqrVWiGB4RfXMQXCLjpK9P2eK//BczrVkn5JLAk6DA=="], + "vite-node": ["vite-node@3.2.4", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg=="], - "vitest": ["vitest@3.1.2", "", { "dependencies": { "@vitest/expect": "3.1.2", "@vitest/mocker": "3.1.2", "@vitest/pretty-format": "^3.1.2", "@vitest/runner": "3.1.2", "@vitest/snapshot": "3.1.2", "@vitest/spy": "3.1.2", "@vitest/utils": "3.1.2", "chai": "^5.2.0", "debug": "^4.4.0", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.13", "tinypool": "^1.0.2", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0", "vite-node": "3.1.2", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.1.2", "@vitest/ui": "3.1.2", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-WaxpJe092ID1C0mr+LH9MmNrhfzi8I65EX/NRU/Ld016KqQNRgxSOlGNP1hHN+a/F8L15Mh8klwaF77zR3GeDQ=="], + "vitest": ["vitest@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.4", "@vitest/mocker": "3.2.4", "@vitest/pretty-format": "^3.2.4", "@vitest/runner": "3.2.4", "@vitest/snapshot": "3.2.4", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.1", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.4", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.4", "@vitest/ui": "3.2.4", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A=="], "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="], "wrap-ansi": ["wrap-ansi@9.0.2", "", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww=="], - "ws": ["ws@8.18.1", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w=="], - - "xstream": ["xstream@11.14.0", "", { "dependencies": { "globalthis": "^1.0.1", "symbol-observable": "^2.0.3" } }, "sha512-1bLb+kKKtKPbgTK6i/BaoAn03g47PpFstlbe1BA+y3pNS/LfvcaghS5BFf9+EE1J+KwSQsEpfJvFN5GqFtiNmw=="], + "ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="], @@ -536,136 +457,26 @@ "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="], - "zod": ["zod@3.24.3", "", {}, "sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg=="], - - "@cosmjs/socket/ws": ["ws@7.5.10", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ=="], - - "@grpc/proto-loader/protobufjs": ["protobufjs@7.5.0", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.4", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.0", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.0", "@types/node": ">=13.7.0", "long": "^5.0.0" } }, "sha512-Z2E/kOY1QjoMlCytmexzYfDm/w5fKAiRwpSzGtdnXW1zC88Z2yXazHHrOtwCzn+7wSxyE8PYM4rvVcMphF9sOA=="], - - "@inco/lightning/ds-test": ["ds-test@github:dapphub/ds-test#e282159", {}, "dapphub-ds-test-e282159"], - - "@inco/lightning/forge-std": ["forge-std@github:foundry-rs/forge-std#9530d9e", {}, "foundry-rs-forge-std-9530d9e"], - - "@inco/shared/ds-test": ["ds-test@github:dapphub/ds-test#e282159", {}, "dapphub-ds-test-e282159"], - - "@inco/shared/forge-std": ["forge-std@github:foundry-rs/forge-std#6abf669", {}, "foundry-rs-forge-std-6abf669"], + "zod": ["zod@4.1.12", "", {}, "sha512-JInaHOamG8pt5+Ey8kGmdcAcg3OL9reK8ltczgHTAwNhMys/6ThXHityHxVV2p3fkw/c+MAvBHFVYHFZDmjMCQ=="], "@vitest/runner/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], "@vitest/snapshot/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], - "bincode-ts/typescript": ["typescript@4.9.5", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g=="], - - "elliptic/bn.js": ["bn.js@4.12.1", "", {}, "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg=="], - - "protobufjs/long": ["long@4.0.0", "", {}, "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA=="], - - "tinyglobby/picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="], - - "tsx/esbuild": ["esbuild@0.25.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.2", "@esbuild/android-arm": "0.25.2", "@esbuild/android-arm64": "0.25.2", "@esbuild/android-x64": "0.25.2", "@esbuild/darwin-arm64": "0.25.2", "@esbuild/darwin-x64": "0.25.2", "@esbuild/freebsd-arm64": "0.25.2", "@esbuild/freebsd-x64": "0.25.2", "@esbuild/linux-arm": "0.25.2", "@esbuild/linux-arm64": "0.25.2", "@esbuild/linux-ia32": "0.25.2", "@esbuild/linux-loong64": "0.25.2", "@esbuild/linux-mips64el": "0.25.2", "@esbuild/linux-ppc64": "0.25.2", "@esbuild/linux-riscv64": "0.25.2", "@esbuild/linux-s390x": "0.25.2", "@esbuild/linux-x64": "0.25.2", "@esbuild/netbsd-arm64": "0.25.2", "@esbuild/netbsd-x64": "0.25.2", "@esbuild/openbsd-arm64": "0.25.2", "@esbuild/openbsd-x64": "0.25.2", "@esbuild/sunos-x64": "0.25.2", "@esbuild/win32-arm64": "0.25.2", "@esbuild/win32-ia32": "0.25.2", "@esbuild/win32-x64": "0.25.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-16854zccKPnC+toMywC+uKNeYSv+/eXkevRAfwRD/G9Cleq66m8XFIrigkbvauLLlCfDL45Q2cWegSg53gGBnQ=="], + "tinyglobby/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="], - "vite/esbuild": ["esbuild@0.25.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.2", "@esbuild/android-arm": "0.25.2", "@esbuild/android-arm64": "0.25.2", "@esbuild/android-x64": "0.25.2", "@esbuild/darwin-arm64": "0.25.2", "@esbuild/darwin-x64": "0.25.2", "@esbuild/freebsd-arm64": "0.25.2", "@esbuild/freebsd-x64": "0.25.2", "@esbuild/linux-arm": "0.25.2", "@esbuild/linux-arm64": "0.25.2", "@esbuild/linux-ia32": "0.25.2", "@esbuild/linux-loong64": "0.25.2", "@esbuild/linux-mips64el": "0.25.2", "@esbuild/linux-ppc64": "0.25.2", "@esbuild/linux-riscv64": "0.25.2", "@esbuild/linux-s390x": "0.25.2", "@esbuild/linux-x64": "0.25.2", "@esbuild/netbsd-arm64": "0.25.2", "@esbuild/netbsd-x64": "0.25.2", "@esbuild/openbsd-arm64": "0.25.2", "@esbuild/openbsd-x64": "0.25.2", "@esbuild/sunos-x64": "0.25.2", "@esbuild/win32-arm64": "0.25.2", "@esbuild/win32-ia32": "0.25.2", "@esbuild/win32-x64": "0.25.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-16854zccKPnC+toMywC+uKNeYSv+/eXkevRAfwRD/G9Cleq66m8XFIrigkbvauLLlCfDL45Q2cWegSg53gGBnQ=="], + "viem/abitype": ["abitype@1.1.0", "", { "peerDependencies": { "typescript": ">=5.0.4", "zod": "^3.22.0 || ^4.0.0" }, "optionalPeers": ["typescript", "zod"] }, "sha512-6Vh4HcRxNMLA0puzPjM5GBgT4aAcFGKZzSgAXvuZ27shJP6NEpielTuqbBmZILR5/xd0PizkBGy5hReKz9jl5A=="], - "vite/picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="], + "vite/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="], "vite-node/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], "vitest/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], - "wrap-ansi/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], - - "tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-wCIboOL2yXZym2cgm6mlA742s9QeJ8DjGVaL39dLN4rRwrOgOyYSnOaFPhKZGLb2ngj4EyfAFjsNJwPXZvseag=="], - - "tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.2", "", { "os": "android", "cpu": "arm" }, "sha512-NQhH7jFstVY5x8CKbcfa166GoV0EFkaPkCKBQkdPJFvo5u+nGXLEH/ooniLb3QI8Fk58YAx7nsPLozUWfCBOJA=="], - - "tsx/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.2", "", { "os": "android", "cpu": "arm64" }, "sha512-5ZAX5xOmTligeBaeNEPnPaeEuah53Id2tX4c2CVP3JaROTH+j4fnfHCkr1PjXMd78hMst+TlkfKcW/DlTq0i4w=="], - - "tsx/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.25.2", "", { "os": "android", "cpu": "x64" }, "sha512-Ffcx+nnma8Sge4jzddPHCZVRvIfQ0kMsUsCMcJRHkGJ1cDmhe4SsrYIjLUKn1xpHZybmOqCWwB0zQvsjdEHtkg=="], - - "tsx/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-MpM6LUVTXAzOvN4KbjzU/q5smzryuoNjlriAIx+06RpecwCkL9JpenNzpKd2YMzLJFOdPqBpuub6eVRP5IgiSA=="], - - "tsx/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-5eRPrTX7wFyuWe8FqEFPG2cU0+butQQVNcT4sVipqjLYQjjh8a8+vUTfgBKM88ObB85ahsnTwF7PSIt6PG+QkA=="], - - "tsx/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-mLwm4vXKiQ2UTSX4+ImyiPdiHjiZhIaE9QvC7sw0tZ6HoNMjYAqQpGyui5VRIi5sGd+uWq940gdCbY3VLvsO1w=="], - - "tsx/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-6qyyn6TjayJSwGpm8J9QYYGQcRgc90nmfdUb0O7pp1s4lTY+9D0H9O02v5JqGApUyiHOtkz6+1hZNvNtEhbwRQ=="], - - "tsx/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.2", "", { "os": "linux", "cpu": "arm" }, "sha512-UHBRgJcmjJv5oeQF8EpTRZs/1knq6loLxTsjc3nxO9eXAPDLcWW55flrMVc97qFPbmZP31ta1AZVUKQzKTzb0g=="], - - "tsx/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-gq/sjLsOyMT19I8obBISvhoYiZIAaGF8JpeXu1u8yPv8BE5HlWYobmlsfijFIZ9hIVGYkbdFhEqC0NvM4kNO0g=="], - - "tsx/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.2", "", { "os": "linux", "cpu": "ia32" }, "sha512-bBYCv9obgW2cBP+2ZWfjYTU+f5cxRoGGQ5SeDbYdFCAZpYWrfjjfYwvUpP8MlKbP0nwZ5gyOU/0aUzZ5HWPuvQ=="], - - "tsx/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-SHNGiKtvnU2dBlM5D8CXRFdd+6etgZ9dXfaPCeJtz+37PIUlixvlIhI23L5khKXs3DIzAn9V8v+qb1TRKrgT5w=="], - - "tsx/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-hDDRlzE6rPeoj+5fsADqdUZl1OzqDYow4TB4Y/3PlKBD0ph1e6uPHzIQcv2Z65u2K0kpeByIyAjCmjn1hJgG0Q=="], - - "tsx/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-tsHu2RRSWzipmUi9UBDEzc0nLc4HtpZEI5Ba+Omms5456x5WaNuiG3u7xh5AO6sipnJ9r4cRWQB2tUjPyIkc6g=="], - - "tsx/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-k4LtpgV7NJQOml/10uPU0s4SAXGnowi5qBSjaLWMojNCUICNu7TshqHLAEbkBdAszL5TabfvQ48kK84hyFzjnw=="], - - "tsx/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-GRa4IshOdvKY7M/rDpRR3gkiTNp34M0eLTaC1a08gNrh4u488aPhuZOCpkF6+2wl3zAN7L7XIpOFBhnaE3/Q8Q=="], - - "tsx/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.2", "", { "os": "linux", "cpu": "x64" }, "sha512-QInHERlqpTTZ4FRB0fROQWXcYRD64lAoiegezDunLpalZMjcUcld3YzZmVJ2H/Cp0wJRZ8Xtjtj0cEHhYc/uUg=="], - - "tsx/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.2", "", { "os": "none", "cpu": "x64" }, "sha512-voZT9Z+tpOxrvfKFyfDYPc4DO4rk06qamv1a/fkuzHpiVBMOhpjK+vBmWM8J1eiB3OLSMFYNaOaBNLXGChf5tg=="], - - "tsx/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-t/TkWwahkH0Tsgoq1Ju7QfgGhArkGLkF1uYz8nQS/PPFlXbP5YgRpqQR3ARRiC2iXoLTWFxc6DJMSK10dVXluw=="], + "vitest/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="], - "tsx/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.2", "", { "os": "sunos", "cpu": "x64" }, "sha512-cfZH1co2+imVdWCjd+D1gf9NjkchVhhdpgb1q5y6Hcv9TP6Zi9ZG/beI3ig8TvwT9lH9dlxLq5MQBBgwuj4xvA=="], - - "tsx/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-7Loyjh+D/Nx/sOTzV8vfbB3GJuHdOQyrOryFdZvPHLf42Tk9ivBU5Aedi7iyX+x6rbn2Mh68T4qq1SDqJBQO5Q=="], - - "tsx/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-WRJgsz9un0nqZJ4MfhabxaD9Ft8KioqU3JMinOTvobbX6MOSUigSBlogP8QB3uxpJDsFS6yN+3FDBdqE5lg9kg=="], - - "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.2", "", { "os": "win32", "cpu": "x64" }, "sha512-kM3HKb16VIXZyIeVrM1ygYmZBKybX8N4p754bw390wGO3Tf2j4L2/WYL+4suWujpgf6GBYs3jv7TyUivdd05JA=="], - - "vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-wCIboOL2yXZym2cgm6mlA742s9QeJ8DjGVaL39dLN4rRwrOgOyYSnOaFPhKZGLb2ngj4EyfAFjsNJwPXZvseag=="], - - "vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.2", "", { "os": "android", "cpu": "arm" }, "sha512-NQhH7jFstVY5x8CKbcfa166GoV0EFkaPkCKBQkdPJFvo5u+nGXLEH/ooniLb3QI8Fk58YAx7nsPLozUWfCBOJA=="], - - "vite/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.2", "", { "os": "android", "cpu": "arm64" }, "sha512-5ZAX5xOmTligeBaeNEPnPaeEuah53Id2tX4c2CVP3JaROTH+j4fnfHCkr1PjXMd78hMst+TlkfKcW/DlTq0i4w=="], - - "vite/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.25.2", "", { "os": "android", "cpu": "x64" }, "sha512-Ffcx+nnma8Sge4jzddPHCZVRvIfQ0kMsUsCMcJRHkGJ1cDmhe4SsrYIjLUKn1xpHZybmOqCWwB0zQvsjdEHtkg=="], - - "vite/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-MpM6LUVTXAzOvN4KbjzU/q5smzryuoNjlriAIx+06RpecwCkL9JpenNzpKd2YMzLJFOdPqBpuub6eVRP5IgiSA=="], - - "vite/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-5eRPrTX7wFyuWe8FqEFPG2cU0+butQQVNcT4sVipqjLYQjjh8a8+vUTfgBKM88ObB85ahsnTwF7PSIt6PG+QkA=="], - - "vite/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-mLwm4vXKiQ2UTSX4+ImyiPdiHjiZhIaE9QvC7sw0tZ6HoNMjYAqQpGyui5VRIi5sGd+uWq940gdCbY3VLvsO1w=="], - - "vite/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-6qyyn6TjayJSwGpm8J9QYYGQcRgc90nmfdUb0O7pp1s4lTY+9D0H9O02v5JqGApUyiHOtkz6+1hZNvNtEhbwRQ=="], - - "vite/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.2", "", { "os": "linux", "cpu": "arm" }, "sha512-UHBRgJcmjJv5oeQF8EpTRZs/1knq6loLxTsjc3nxO9eXAPDLcWW55flrMVc97qFPbmZP31ta1AZVUKQzKTzb0g=="], - - "vite/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-gq/sjLsOyMT19I8obBISvhoYiZIAaGF8JpeXu1u8yPv8BE5HlWYobmlsfijFIZ9hIVGYkbdFhEqC0NvM4kNO0g=="], - - "vite/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.2", "", { "os": "linux", "cpu": "ia32" }, "sha512-bBYCv9obgW2cBP+2ZWfjYTU+f5cxRoGGQ5SeDbYdFCAZpYWrfjjfYwvUpP8MlKbP0nwZ5gyOU/0aUzZ5HWPuvQ=="], - - "vite/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-SHNGiKtvnU2dBlM5D8CXRFdd+6etgZ9dXfaPCeJtz+37PIUlixvlIhI23L5khKXs3DIzAn9V8v+qb1TRKrgT5w=="], - - "vite/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-hDDRlzE6rPeoj+5fsADqdUZl1OzqDYow4TB4Y/3PlKBD0ph1e6uPHzIQcv2Z65u2K0kpeByIyAjCmjn1hJgG0Q=="], - - "vite/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-tsHu2RRSWzipmUi9UBDEzc0nLc4HtpZEI5Ba+Omms5456x5WaNuiG3u7xh5AO6sipnJ9r4cRWQB2tUjPyIkc6g=="], - - "vite/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.2", "", { "os": "linux", "cpu": "none" }, "sha512-k4LtpgV7NJQOml/10uPU0s4SAXGnowi5qBSjaLWMojNCUICNu7TshqHLAEbkBdAszL5TabfvQ48kK84hyFzjnw=="], - - "vite/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-GRa4IshOdvKY7M/rDpRR3gkiTNp34M0eLTaC1a08gNrh4u488aPhuZOCpkF6+2wl3zAN7L7XIpOFBhnaE3/Q8Q=="], - - "vite/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.2", "", { "os": "linux", "cpu": "x64" }, "sha512-QInHERlqpTTZ4FRB0fROQWXcYRD64lAoiegezDunLpalZMjcUcld3YzZmVJ2H/Cp0wJRZ8Xtjtj0cEHhYc/uUg=="], - - "vite/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.2", "", { "os": "none", "cpu": "x64" }, "sha512-voZT9Z+tpOxrvfKFyfDYPc4DO4rk06qamv1a/fkuzHpiVBMOhpjK+vBmWM8J1eiB3OLSMFYNaOaBNLXGChf5tg=="], - - "vite/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-t/TkWwahkH0Tsgoq1Ju7QfgGhArkGLkF1uYz8nQS/PPFlXbP5YgRpqQR3ARRiC2iXoLTWFxc6DJMSK10dVXluw=="], - - "vite/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.2", "", { "os": "sunos", "cpu": "x64" }, "sha512-cfZH1co2+imVdWCjd+D1gf9NjkchVhhdpgb1q5y6Hcv9TP6Zi9ZG/beI3ig8TvwT9lH9dlxLq5MQBBgwuj4xvA=="], - - "vite/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-7Loyjh+D/Nx/sOTzV8vfbB3GJuHdOQyrOryFdZvPHLf42Tk9ivBU5Aedi7iyX+x6rbn2Mh68T4qq1SDqJBQO5Q=="], - - "vite/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-WRJgsz9un0nqZJ4MfhabxaD9Ft8KioqU3JMinOTvobbX6MOSUigSBlogP8QB3uxpJDsFS6yN+3FDBdqE5lg9kg=="], - - "vite/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.2", "", { "os": "win32", "cpu": "x64" }, "sha512-kM3HKb16VIXZyIeVrM1ygYmZBKybX8N4p754bw390wGO3Tf2j4L2/WYL+4suWujpgf6GBYs3jv7TyUivdd05JA=="], + "wrap-ansi/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], - "wrap-ansi/string-width/emoji-regex": ["emoji-regex@10.5.0", "", {}, "sha512-lb49vf1Xzfx080OKA0o6l8DQQpV+6Vg95zyCJX9VB/BqKYlhG7N4wgROUUHRA+ZPUefLnteQOad7z1kT2bV7bg=="], + "wrap-ansi/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], } } diff --git a/contracts/foundry.toml b/contracts/foundry.toml index a39b1b8..67c248d 100644 --- a/contracts/foundry.toml +++ b/contracts/foundry.toml @@ -5,3 +5,6 @@ allow_paths = ['../'] evm_version = 'cancun' solc = '0.8.28' optimizer = true + +[lint] +lint_on_build = false \ No newline at end of file diff --git a/contracts/package.json b/contracts/package.json index 344dd34..17fcf3f 100644 --- a/contracts/package.json +++ b/contracts/package.json @@ -2,8 +2,7 @@ "name": "lightning-rod-contracts", "private": true, "dependencies": { - "@inco/lightning": "^0.1.21", - "@inco/shared": "^0.1.0", + "@inco/lightning": "0.6.8", "@openzeppelin/contracts": "^5.3.0", "ds-test": "https://github.com/dapphub/ds-test", "forge-std": "https://github.com/foundry-rs/forge-std" diff --git a/contracts/remappings.txt b/contracts/remappings.txt index 64d0db6..1a29b28 100644 --- a/contracts/remappings.txt +++ b/contracts/remappings.txt @@ -1,4 +1,5 @@ @openzeppelin/=../node_modules/@openzeppelin/ forge-std/=../node_modules/forge-std/src/ ds-test/=../node_modules/ds-test/src/ +@inco/lightning/=../node_modules/@inco/lightning/ @inco/=../node_modules/@inco/ diff --git a/contracts/src/AddTwo.sol b/contracts/src/AddTwo.sol index 2482d0f..8d21352 100644 --- a/contracts/src/AddTwo.sol +++ b/contracts/src/AddTwo.sol @@ -2,15 +2,13 @@ pragma solidity ^0.8; import {euint256, ebool, e} from "@inco/lightning/src/Lib.sol"; +import {Fee} from "@inco/lightning/src/lightning-parts/Fee.sol"; -contract AddTwo { +contract AddTwo is Fee { using e for euint256; using e for uint256; using e for bytes; - // Stores the result of the last callback. - uint256 public lastResult; - function addTwo(euint256 a) external returns (euint256) { uint256 two = 2; return a.add(two.asEuint256()); @@ -23,26 +21,11 @@ contract AddTwo { // addTwoEOA is the equivalent of addTwo, but it allows an EOA to call it // with an encrypted input. - function addTwoEOA( - bytes memory uint256EInput - ) external returns (uint256, euint256) { - euint256 value = uint256EInput.newEuint256(msg.sender); + function addTwoEOA(bytes memory uint256EInput) external payable refundUnspent returns (euint256 result) { + euint256 value = e.newEuint256(uint256EInput, msg.sender); euint256 result = this.addTwo(value); e.allow(result, address(this)); e.allow(result, msg.sender); - uint256 requestId = e.requestDecryption( - result, - this.callback.selector, - "" - ); - return (requestId, result); - } - - function callback( - uint256 /* requestId */, - uint256 result, - bytes memory /* data */ - ) external { - lastResult = result; + return result; } } diff --git a/contracts/src/LibTest.sol b/contracts/src/LibTest.sol new file mode 100644 index 0000000..5e28967 --- /dev/null +++ b/contracts/src/LibTest.sol @@ -0,0 +1,448 @@ +// SPDX-License-Identifier: No License +pragma solidity ^0.8; + +import {euint256, ebool, eaddress, e, inco} from "@inco/lightning/src/Lib.sol"; + +contract LibTest { + using e for euint256; + using e for uint256; + using e for bytes; + using e for ebool; + using e for bool; + using e for eaddress; + using e for address; + + // bytes public encryptedBytes; + // uint256 public encryptedUint256Scalar; + // bool public encryptedBoolScalar; + // address public encryptedAddressScalar; + // bytes public encryptedBytesScalar; + + // ============ ARITHMETIC OPERATIONS ============ + + function testAdd(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.add(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testAddScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.add(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testSub(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.sub(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testSubScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.sub(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMul(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.mul(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMulScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.mul(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testDiv(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.div(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testDivScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.div(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRem(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.rem(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRemScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.rem(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + // ============ BITWISE OPERATIONS ============ + + function testAnd(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.and(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testAndScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.and(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testAndBool(ebool a, ebool b) external returns (ebool) { + ebool result = a.and(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testAndBoolScalar(ebool a, bool b) external returns (ebool) { + ebool result = a.and(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testOr(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.or(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testOrScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.or(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testOrBool(ebool a, ebool b) external returns (ebool) { + ebool result = a.or(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testOrBoolScalar(ebool a, bool b) external returns (ebool) { + ebool result = a.or(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testXor(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.xor(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testXorScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.xor(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testXorBool(ebool a, ebool b) external returns (ebool) { + ebool result = a.xor(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testXorBoolScalar(ebool a, bool b) external returns (ebool) { + ebool result = a.xor(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testShl(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.shl(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testShlScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.shl(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testShr(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.shr(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testShrScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.shr(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRotl(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.rotl(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRotlScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.rotl(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRotr(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.rotr(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRotrScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.rotr(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + // ============ COMPARISON OPERATIONS ============ + + function testEq(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.eq(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testEqScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.eq(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testEqAddress(eaddress a, eaddress b) external returns (ebool) { + ebool result = a.eq(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testEqAddressScalar(eaddress a, address b) external returns (ebool) { + ebool result = a.eq(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testNe(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.ne(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testNeScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.ne(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testNeAddress(eaddress a, eaddress b) external returns (ebool) { + ebool result = a.ne(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testNeAddressScalar(eaddress a, address b) external returns (ebool) { + ebool result = a.ne(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testGe(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.ge(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testGeScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.ge(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testGt(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.gt(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testGtScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.gt(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testLe(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.le(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testLeScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.le(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testLt(euint256 a, euint256 b) external returns (ebool) { + ebool result = a.lt(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testLtScalar(euint256 a, uint256 b) external returns (ebool) { + ebool result = a.lt(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMin(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.min(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMinScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.min(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMax(euint256 a, euint256 b) external returns (euint256) { + euint256 result = a.max(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testMaxScalar(euint256 a, uint256 b) external returns (euint256) { + euint256 result = a.max(b); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + // ============ LOGICAL OPERATIONS ============ + + function testNot(ebool a) external returns (ebool) { + ebool result = a.not(); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + // ============ RANDOM NUMBER GENERATION ============ + + function testRand() external payable returns (euint256) { + euint256 result = e.rand(); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRandBounded(uint256 upperBound) external payable returns (euint256) { + euint256 result = e.randBounded(upperBound); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + function testRandBoundedEncrypted(euint256 upperBound) external payable returns (euint256) { + euint256 result = e.randBounded(upperBound); + e.allow(result, address(this)); + e.allow(result, msg.sender); + return result; + } + + // ============ ENCRYPTED INPUT CREATION ============ + + function testNewEuint256(bytes memory ciphertext, address user) external payable returns (euint256) { + require(msg.value == inco.getFee(),"Fee not paid"); + euint256 encryptedUint256 = e.newEuint256(ciphertext, user); + e.allow(encryptedUint256, address(this)); + e.allow(encryptedUint256, user); + return encryptedUint256; + } + + function testNewEbool(bytes memory ciphertext, address user) external payable returns (ebool) { + require(msg.value == inco.getFee(),"Fee not paid"); + ebool encryptedBool = e.newEbool(ciphertext, user); + e.allow(encryptedBool, address(this)); + e.allow(encryptedBool, user); + return encryptedBool; + } + + function testNewEaddress(bytes memory ciphertext, address user) external payable returns (eaddress) { + require(msg.value == inco.getFee(),"Fee not paid"); + eaddress encryptedAddress = e.newEaddress(ciphertext, user); + e.allow(encryptedAddress, address(this)); + e.allow(encryptedAddress, user); + return encryptedAddress; + } + + // ============ REVEAL OPERATIONS ============ + + function testRevealEUint(euint256 a) external { + e.reveal(a); + } + + function testRevealEBool(ebool a) external { + e.reveal(a); + } + + function testRevealEAddress(eaddress a) external { + e.reveal(a); + } +} diff --git a/contracts/src/test/TestSimpleConfidentialToken.t.sol b/contracts/src/test/TestSimpleConfidentialToken.t.sol index b2ce590..10a064a 100644 --- a/contracts/src/test/TestSimpleConfidentialToken.t.sol +++ b/contracts/src/test/TestSimpleConfidentialToken.t.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8; import {SimpleConfidentialToken} from "../SimpleConfidentialToken.sol"; import {IncoTest} from "@inco/lightning/src/test/IncoTest.sol"; -import {GWEI} from "@inco/shared/src/TypeUtils.sol"; // 1 GWEI = 1e9 +import {GWEI} from "@inco/lightning/src/shared/TypeUtils.sol"; // 1 GWEI = 1e9 // IncoTest extends forge-std's Test contract TestSimpleConfidentialToken is IncoTest { @@ -14,12 +14,12 @@ contract TestSimpleConfidentialToken is IncoTest { super.setUp(); token = new SimpleConfidentialToken(); // use `fakePrepareEuint256Ciphertext` to simulate producing a ciphertext using the @inco/js sdk - token.transfer(alice, fakePrepareEuint256Ciphertext(10 * GWEI)); + token.transfer(alice, fakePrepareEuint256Ciphertext(10 * GWEI, alice, address(token))); } function testTransfer() public { vm.prank(alice); - token.transfer(bob, fakePrepareEuint256Ciphertext(1 * GWEI)); + token.transfer(bob, fakePrepareEuint256Ciphertext(1 * GWEI, bob, address(token))); // Inco processes the operations over encrypted variables asynchronously offchain. // call processAllOperations() to simulate this offchain processing, which will assign to each e-variable // its encrypted value. if you don't call this function and try to simulate a decrypt on a handle diff --git a/docker-compose.yaml b/docker-compose.yaml index 905bcf6..8a8274d 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -2,14 +2,14 @@ services: # Anvil node anvil: platform: linux/amd64 # mac compatibility - image: inconetwork/local-node-anvil:${DOCKER_IMAGE_TAG} + image: inconetwork/local-node-anvil-alphanet:${DOCKER_IMAGE_TAG} ports: - "8545:8545" # Covalidator service that waits for deployer to be healthy covalidator: platform: linux/amd64 # mac compatibility - image: inconetwork/local-node-covalidator:${DOCKER_IMAGE_TAG} + image: inconetwork/local-node-covalidator-alphanet:${DOCKER_IMAGE_TAG} depends_on: anvil: condition: service_healthy diff --git a/package.json b/package.json index 7863069..bfa0aac 100644 --- a/package.json +++ b/package.json @@ -25,8 +25,8 @@ "typescript": "^5.8.3" }, "overrides": { - "@inco/lightning": "0.1.30", - "@inco/js": "0.1.33", + "@inco/lightning": "0.6.9", + "@inco/js": "0.6.9", "ansi-styles": "^6.2.3", "is-core-module": "2.13.1", "error-ex": "1.3.2", @@ -48,4 +48,4 @@ "chalk-template": "^1.1.2", "backslash": "^0.2.0" } -} +} \ No newline at end of file