@aztec/txe 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/oracle/txe_oracle_registry.js

@@ -0,0 +1,715 @@
+/* eslint-disable camelcase */ import { GAS_SETTINGS_LENGTH, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, PRIVATE_CONTEXT_INPUTS_LENGTH, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { withHexPrefix, withoutHexPrefix } from '@aztec/foundation/string';
+import { ARRAY, AZTEC_ADDRESS, BIGINT, BLOCK_NUMBER, BOOL, ETH_ADDRESS, FIELD, FUNCTION_SELECTOR, OPTION, ORACLE_REGISTRY, STR, U32, makeEntry } from '@aztec/pxe/simulator';
+import { EventSelector } from '@aztec/stdlib/abi';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY, MAX_OFFCHAIN_EFFECT_LEN, MAX_PRIVATE_EVENTS_PER_TXE_QUERY, MAX_PRIVATE_EVENT_LEN } from '../constants.js';
+const GAS_SETTINGS = {
+    deserialization: {
+        fn: ([reader])=>GasSettings.fromFields(reader.readFieldArray(GAS_SETTINGS_LENGTH))
+    },
+    shape: [
+        {
+            len: GAS_SETTINGS_LENGTH
+        }
+    ]
+};
+// Tagging secret strategy discriminants. Must match the Noir test helper `TaggingSecretStrategy` in
+// aztec-nr `test/helpers/tagging_secret_strategy.nr`. This is a test-only oracle (only `set_tagging_secret_strategy`
+// reads it), so the mapping lives here on the TXE side rather than in the production oracle type mappings.
+const STRATEGY_NON_INTERACTIVE_HANDSHAKE = 1;
+const STRATEGY_ARBITRARY_SECRET = 2;
+const STRATEGY_ADDRESS_DERIVED = 3;
+const TAGGING_SECRET_STRATEGY = {
+    serialization: {
+        fn: (strategy)=>{
+            switch(strategy.type){
+                case 'non-interactive-handshake':
+                    return [
+                        new Fr(STRATEGY_NON_INTERACTIVE_HANDSHAKE),
+                        Fr.ZERO,
+                        Fr.ZERO
+                    ];
+                case 'address-derived':
+                    return [
+                        new Fr(STRATEGY_ADDRESS_DERIVED),
+                        Fr.ZERO,
+                        Fr.ZERO
+                    ];
+                case 'arbitrary-secret':
+                    return [
+                        new Fr(STRATEGY_ARBITRARY_SECRET),
+                        strategy.secret.x,
+                        strategy.secret.y
+                    ];
+            }
+        }
+    },
+    deserialization: {
+        fn: ([kindReader, xReader, yReader])=>{
+            const kind = kindReader.readField().toNumber();
+            const [x, y] = [
+                xReader.readField(),
+                yReader.readField()
+            ];
+            switch(kind){
+                case STRATEGY_NON_INTERACTIVE_HANDSHAKE:
+                    return {
+                        type: 'non-interactive-handshake'
+                    };
+                case STRATEGY_ADDRESS_DERIVED:
+                    return {
+                        type: 'address-derived'
+                    };
+                case STRATEGY_ARBITRARY_SECRET:
+                    return {
+                        type: 'arbitrary-secret',
+                        secret: Point.fromFields([
+                            x,
+                            y
+                        ])
+                    };
+                default:
+                    throw new Error(`Unrecognized tagging secret strategy kind: ${kind}`);
+            }
+        }
+    },
+    shape: [
+        'scalar',
+        'scalar',
+        'scalar'
+    ]
+};
+const PRIVATE_CONTEXT_INPUTS = {
+    serialization: {
+        fn: (v)=>v.toFields()
+    },
+    shape: Array(PRIVATE_CONTEXT_INPUTS_LENGTH).fill('scalar')
+};
+const COMPLETE_ADDRESS = {
+    serialization: {
+        fn: (v)=>[
+                v.address.toField(),
+                ...v.publicKeys.toFields()
+            ]
+    },
+    shape: Array(8).fill('scalar')
+};
+const TXE_TX_EFFECTS = {
+    serialization: {
+        fn: ({ txHash, noteHashes, nullifiers, privateLogs })=>{
+            const emittedLogs = privateLogs.map((log)=>log.getEmittedFields());
+            const rawLogStorage = emittedLogs.map((fields)=>fields.concat(Array(PRIVATE_LOG_SIZE_IN_FIELDS - fields.length).fill(Fr.ZERO))).concat(Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(Array(PRIVATE_LOG_SIZE_IN_FIELDS).fill(Fr.ZERO))).flat();
+            const logLengths = emittedLogs.map((fields)=>new Fr(fields.length)).concat(Array(MAX_PRIVATE_LOGS_PER_TX - emittedLogs.length).fill(Fr.ZERO));
+            const paddedNoteHashes = noteHashes.concat(Array(MAX_NOTE_HASHES_PER_TX - noteHashes.length).fill(Fr.ZERO));
+            const paddedNullifiers = nullifiers.concat(Array(MAX_NULLIFIERS_PER_TX - nullifiers.length).fill(Fr.ZERO));
+            return [
+                txHash.hash,
+                paddedNoteHashes,
+                new Fr(noteHashes.length),
+                paddedNullifiers,
+                new Fr(nullifiers.length),
+                rawLogStorage,
+                logLengths,
+                new Fr(emittedLogs.length)
+            ];
+        }
+    },
+    // txHash, padded note hashes + count, padded nullifiers + count, flattened private-log storage + lengths + count.
+    shape: [
+        'scalar',
+        {
+            len: MAX_NOTE_HASHES_PER_TX
+        },
+        'scalar',
+        {
+            len: MAX_NULLIFIERS_PER_TX
+        },
+        'scalar',
+        {
+            len: MAX_PRIVATE_LOGS_PER_TX * PRIVATE_LOG_SIZE_IN_FIELDS
+        },
+        {
+            len: MAX_PRIVATE_LOGS_PER_TX
+        },
+        'scalar'
+    ]
+};
+const TXE_OFFCHAIN_EFFECTS = {
+    serialization: {
+        fn: ({ effects })=>{
+            const rawArrayStorage = effects.map((e)=>e.concat(Array(MAX_OFFCHAIN_EFFECT_LEN - e.length).fill(Fr.ZERO))).concat(Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(Array(MAX_OFFCHAIN_EFFECT_LEN).fill(Fr.ZERO))).flat();
+            const effectLengths = effects.map((e)=>new Fr(e.length)).concat(Array(MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY - effects.length).fill(Fr.ZERO));
+            return [
+                rawArrayStorage,
+                effectLengths,
+                new Fr(effects.length)
+            ];
+        }
+    },
+    // Flattened effect storage, per-effect lengths, then the effect count.
+    shape: [
+        {
+            len: MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY * MAX_OFFCHAIN_EFFECT_LEN
+        },
+        {
+            len: MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY
+        },
+        'scalar'
+    ]
+};
+const TXE_CALL_CONTEXT = {
+    serialization: {
+        fn: ({ txHash, anchorBlockTimestamp })=>{
+            const isSome = txHash.isZero() ? 0 : 1;
+            return [
+                new Fr(isSome),
+                txHash,
+                new Fr(anchorBlockTimestamp)
+            ];
+        }
+    },
+    shape: [
+        'scalar',
+        'scalar',
+        'scalar'
+    ]
+};
+const CONTRACT_INSTANCE_MEMBER = {
+    serialization: {
+        fn: ({ member, exists })=>[
+                member,
+                new Fr(exists)
+            ]
+    },
+    shape: [
+        'scalar',
+        'scalar'
+    ]
+};
+const EVENT_SELECTOR = {
+    serialization: {
+        fn: (v)=>[
+                v.toField()
+            ]
+    },
+    deserialization: {
+        fn: ([reader])=>EventSelector.fromField(reader.readField())
+    },
+    shape: [
+        'scalar'
+    ]
+};
+const TXE_PRIVATE_EVENTS = {
+    serialization: {
+        fn: (events)=>{
+            const rawArrayStorage = events.map((e)=>e.concat(Array(MAX_PRIVATE_EVENT_LEN - e.length).fill(Fr.ZERO))).concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(Array(MAX_PRIVATE_EVENT_LEN).fill(Fr.ZERO))).flat();
+            const eventLengths = events.map((e)=>new Fr(e.length)).concat(Array(MAX_PRIVATE_EVENTS_PER_TXE_QUERY - events.length).fill(Fr.ZERO));
+            return [
+                rawArrayStorage,
+                eventLengths,
+                new Fr(events.length)
+            ];
+        }
+    },
+    // Flattened event storage, per-event lengths, then the event count.
+    shape: [
+        {
+            len: MAX_PRIVATE_EVENTS_PER_TXE_QUERY * MAX_PRIVATE_EVENT_LEN
+        },
+        {
+            len: MAX_PRIVATE_EVENTS_PER_TXE_QUERY
+        },
+        'scalar'
+    ]
+};
+export const TXE_ORACLE_REGISTRY = {
+    ...ORACLE_REGISTRY,
+    aztec_txe_assertCompatibleOracleVersion: makeEntry({
+        params: [
+            {
+                name: 'major',
+                type: U32
+            },
+            {
+                name: 'minor',
+                type: U32
+            }
+        ]
+    }),
+    aztec_txe_setTopLevelTXEContext: makeEntry(),
+    aztec_txe_setPrivateTXEContext: makeEntry({
+        params: [
+            {
+                name: 'contractAddress',
+                type: OPTION(AZTEC_ADDRESS)
+            },
+            {
+                name: 'anchorBlockNumber',
+                type: OPTION(BLOCK_NUMBER)
+            },
+            {
+                name: 'gasSettings',
+                type: GAS_SETTINGS
+            }
+        ],
+        returnType: PRIVATE_CONTEXT_INPUTS
+    }),
+    aztec_txe_setPublicTXEContext: makeEntry({
+        params: [
+            {
+                name: 'contractAddress',
+                type: OPTION(AZTEC_ADDRESS)
+            }
+        ]
+    }),
+    aztec_txe_setUtilityTXEContext: makeEntry({
+        params: [
+            {
+                name: 'contractAddress',
+                type: OPTION(AZTEC_ADDRESS)
+            }
+        ]
+    }),
+    aztec_txe_getDefaultAddress: makeEntry({
+        returnType: AZTEC_ADDRESS
+    }),
+    aztec_txe_getNextBlockNumber: makeEntry({
+        returnType: BLOCK_NUMBER
+    }),
+    aztec_txe_getNextBlockTimestamp: makeEntry({
+        returnType: BIGINT
+    }),
+    aztec_txe_advanceBlocksBy: makeEntry({
+        params: [
+            {
+                name: 'blocks',
+                type: U32
+            }
+        ]
+    }),
+    aztec_txe_advanceTimestampBy: makeEntry({
+        params: [
+            {
+                name: 'duration',
+                type: BIGINT
+            }
+        ]
+    }),
+    aztec_txe_deploy: makeEntry({
+        params: [
+            {
+                name: 'contractPath',
+                type: STR
+            },
+            {
+                name: 'initializer',
+                type: STR
+            },
+            {
+                name: 'argsLength',
+                type: U32
+            },
+            {
+                name: 'args',
+                type: ARRAY(FIELD)
+            },
+            {
+                name: 'secret',
+                type: FIELD
+            },
+            {
+                name: 'salt',
+                type: FIELD
+            },
+            {
+                name: 'deployer',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: ARRAY(FIELD)
+    }),
+    aztec_txe_createAccount: makeEntry({
+        params: [
+            {
+                name: 'secret',
+                type: FIELD
+            }
+        ],
+        returnType: COMPLETE_ADDRESS
+    }),
+    aztec_txe_addAccount: makeEntry({
+        params: [
+            {
+                name: 'secret',
+                type: FIELD
+            }
+        ],
+        returnType: COMPLETE_ADDRESS
+    }),
+    aztec_txe_addAuthWitness: makeEntry({
+        params: [
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'messageHash',
+                type: FIELD
+            }
+        ]
+    }),
+    aztec_txe_sendL1ToL2Message: makeEntry({
+        params: [
+            {
+                name: 'content',
+                type: FIELD
+            },
+            {
+                name: 'secretHash',
+                type: FIELD
+            },
+            {
+                name: 'sender',
+                type: ETH_ADDRESS
+            },
+            {
+                name: 'recipient',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: FIELD
+    }),
+    aztec_txe_setTaggingSecretStrategy: makeEntry({
+        params: [
+            {
+                name: 'strategy',
+                type: OPTION(TAGGING_SECRET_STRATEGY)
+            }
+        ]
+    }),
+    aztec_txe_getLastBlockTimestamp: makeEntry({
+        returnType: BIGINT
+    }),
+    aztec_txe_getLastTxEffects: makeEntry({
+        returnType: TXE_TX_EFFECTS
+    }),
+    aztec_txe_getLastCallOffchainEffects: makeEntry({
+        returnType: TXE_OFFCHAIN_EFFECTS
+    }),
+    aztec_txe_getLastCallContext: makeEntry({
+        returnType: TXE_CALL_CONTEXT
+    }),
+    aztec_txe_getPrivateEvents: makeEntry({
+        params: [
+            {
+                name: 'selector',
+                type: EVENT_SELECTOR
+            },
+            {
+                name: 'contractAddress',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'scope',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: TXE_PRIVATE_EVENTS
+    }),
+    aztec_txe_privateCallNewFlow: makeEntry({
+        params: [
+            {
+                name: 'from',
+                type: OPTION(AZTEC_ADDRESS)
+            },
+            {
+                name: 'targetContractAddress',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'functionSelector',
+                type: FUNCTION_SELECTOR
+            },
+            {
+                name: 'args',
+                type: ARRAY(FIELD)
+            },
+            {
+                name: 'argsHash',
+                type: FIELD
+            },
+            {
+                name: 'isStaticCall',
+                type: BOOL
+            },
+            {
+                name: 'additionalScopes',
+                type: ARRAY(AZTEC_ADDRESS)
+            },
+            {
+                name: 'authorizedUtilityCallTargets',
+                type: ARRAY(AZTEC_ADDRESS)
+            },
+            {
+                name: 'gasSettings',
+                type: GAS_SETTINGS
+            }
+        ],
+        returnType: ARRAY(FIELD)
+    }),
+    aztec_txe_executeUtilityFunction: makeEntry({
+        params: [
+            {
+                name: 'from',
+                type: OPTION(AZTEC_ADDRESS)
+            },
+            {
+                name: 'targetContractAddress',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'functionSelector',
+                type: FUNCTION_SELECTOR
+            },
+            {
+                name: 'args',
+                type: ARRAY(FIELD)
+            },
+            {
+                name: 'authorizedUtilityCallTargets',
+                type: ARRAY(AZTEC_ADDRESS)
+            }
+        ],
+        returnType: ARRAY(FIELD)
+    }),
+    aztec_txe_publicCallNewFlow: makeEntry({
+        params: [
+            {
+                name: 'from',
+                type: OPTION(AZTEC_ADDRESS)
+            },
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'calldata',
+                type: ARRAY(FIELD)
+            },
+            {
+                name: 'isStaticCall',
+                type: BOOL
+            },
+            {
+                name: 'gasSettings',
+                type: GAS_SETTINGS
+            }
+        ],
+        returnType: ARRAY(FIELD)
+    }),
+    aztec_avm_address: makeEntry({
+        returnType: AZTEC_ADDRESS
+    }),
+    aztec_avm_sender: makeEntry({
+        returnType: AZTEC_ADDRESS
+    }),
+    aztec_avm_blockNumber: makeEntry({
+        returnType: BLOCK_NUMBER
+    }),
+    aztec_avm_timestamp: makeEntry({
+        returnType: BIGINT
+    }),
+    aztec_avm_isStaticCall: makeEntry({
+        returnType: BOOL
+    }),
+    aztec_avm_chainId: makeEntry({
+        returnType: FIELD
+    }),
+    aztec_avm_version: makeEntry({
+        returnType: FIELD
+    }),
+    aztec_avm_emitNullifier: makeEntry({
+        params: [
+            {
+                name: 'nullifier',
+                type: FIELD
+            }
+        ]
+    }),
+    aztec_avm_emitNoteHash: makeEntry({
+        params: [
+            {
+                name: 'noteHash',
+                type: FIELD
+            }
+        ]
+    }),
+    aztec_avm_nullifierExists: makeEntry({
+        params: [
+            {
+                name: 'siloedNullifier',
+                type: FIELD
+            }
+        ],
+        returnType: BOOL
+    }),
+    aztec_avm_storageRead: makeEntry({
+        params: [
+            {
+                name: 'slot',
+                type: FIELD
+            },
+            {
+                name: 'contractAddress',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: FIELD
+    }),
+    aztec_avm_storageWrite: makeEntry({
+        params: [
+            {
+                name: 'slot',
+                type: FIELD
+            },
+            {
+                name: 'value',
+                type: FIELD
+            }
+        ]
+    }),
+    aztec_avm_emitPublicLog: makeEntry({
+        params: [
+            {
+                name: 'message',
+                type: ARRAY(FIELD)
+            }
+        ]
+    }),
+    aztec_avm_returndataSize: makeEntry({
+        returnType: FIELD
+    }),
+    aztec_avm_returndataCopy: makeEntry({
+        params: [
+            {
+                name: 'rdOffset',
+                type: U32
+            },
+            {
+                name: 'copySize',
+                type: U32
+            }
+        ],
+        returnType: ARRAY(FIELD)
+    }),
+    aztec_avm_call: makeEntry({
+        params: [
+            {
+                name: 'l2Gas',
+                type: U32
+            },
+            {
+                name: 'daGas',
+                type: U32
+            },
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'argsLength',
+                type: U32
+            },
+            {
+                name: 'args',
+                type: ARRAY(FIELD)
+            }
+        ]
+    }),
+    aztec_avm_staticCall: makeEntry({
+        params: [
+            {
+                name: 'l2Gas',
+                type: U32
+            },
+            {
+                name: 'daGas',
+                type: U32
+            },
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'argsLength',
+                type: U32
+            },
+            {
+                name: 'args',
+                type: ARRAY(FIELD)
+            }
+        ]
+    }),
+    aztec_avm_successCopy: makeEntry({
+        returnType: BOOL
+    }),
+    aztec_avm_getContractInstanceDeployer: makeEntry({
+        params: [
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: CONTRACT_INSTANCE_MEMBER
+    }),
+    aztec_avm_getContractInstanceClassId: makeEntry({
+        params: [
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: CONTRACT_INSTANCE_MEMBER
+    }),
+    aztec_avm_getContractInstanceInitializationHash: makeEntry({
+        params: [
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: CONTRACT_INSTANCE_MEMBER
+    }),
+    aztec_avm_getContractInstanceImmutablesHash: makeEntry({
+        params: [
+            {
+                name: 'address',
+                type: AZTEC_ADDRESS
+            }
+        ],
+        returnType: CONTRACT_INSTANCE_MEMBER
+    })
+};
+export function toInputSlots(inputs) {
+    // TXE foreign calls use bare hex strings, but Fr.fromString requires a 0x prefix to parse as hex.
+    return inputs.map((v)=>Array.isArray(v) ? v.map(withHexPrefix) : [
+            withHexPrefix(v)
+        ]);
+}
+/**
+ * Deserializes oracle inputs, calls the handler with typed params, serializes the result, and wraps
+ * it in a `ForeignCallResult`. Normalizes `ForeignCallArgs` (which may contain bare strings) into
+ * `InputSlot[]` (always arrays) before deserialization.
+ */ export async function callTxeHandler({ oracle, inputs, handler }) {
+    const entry = TXE_ORACLE_REGISTRY[oracle];
+    const named = entry.deserializeParams(toInputSlots(inputs));
+    const positional = named.map((p)=>p.value);
+    const result = await handler(positional);
+    const outputSlots = entry.serializeReturn(result);
+    return {
+        values: outputSlots.map((slot)=>Array.isArray(slot) ? slot.map(withoutHexPrefix) : withoutHexPrefix(slot))
+    };
+}