@aztec-labs/txe 6.0.0-nightly.20260829

package/dest/oracle/txe_oracle_registry.js

@@ -0,0 +1,753 @@
+/* eslint-disable camelcase */ import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { withHexPrefix, withoutHexPrefix } from '@aztec-labs/foundation/string';
+import { ARRAY, AZTEC_ADDRESS, BLOCK_HEADER, BLOCK_NUMBER, BOOL, ETH_ADDRESS, FIELD, FIXED_ARRAY, FIXED_BOUNDED_VEC, FUNCTION_SELECTOR, GAS_FEES, LEAF, OPTION, ORACLE_REGISTRY, PUBLIC_KEYS, SCALAR, STR, STRUCT, TX_HASH, U32, U64, VECTOR, buildACIRCallback, makeEntry } from '@aztec-labs/pxe/simulator';
+import { EventSelector } from '@aztec-labs/stdlib/abi';
+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 = STRUCT([
+    {
+        name: 'daGas',
+        type: U32
+    },
+    {
+        name: 'l2Gas',
+        type: U32
+    }
+]);
+const GAS_SETTINGS = STRUCT([
+    {
+        name: 'gasLimits',
+        type: GAS
+    },
+    {
+        name: 'teardownGasLimits',
+        type: GAS
+    },
+    {
+        name: 'maxFeesPerGas',
+        type: GAS_FEES
+    },
+    {
+        name: 'maxPriorityFeesPerGas',
+        type: GAS_FEES
+    }
+]);
+// 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_strategies`
+// 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 STRATEGY_INTERACTIVE_HANDSHAKE = 4;
+const TAGGING_SECRET_STRATEGY = LEAF({
+    kind: '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 'interactive-handshake':
+                    return [
+                        new Fr(STRATEGY_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_INTERACTIVE_HANDSHAKE:
+                    return {
+                        type: '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 CALL_CONTEXT = STRUCT([
+    {
+        name: 'msgSender',
+        type: AZTEC_ADDRESS
+    },
+    {
+        name: 'contractAddress',
+        type: AZTEC_ADDRESS
+    },
+    {
+        name: 'functionSelector',
+        type: FUNCTION_SELECTOR
+    },
+    {
+        name: 'isStaticCall',
+        type: BOOL
+    }
+]);
+const TX_CONTEXT = STRUCT([
+    {
+        name: 'chainId',
+        type: FIELD
+    },
+    {
+        name: 'version',
+        type: FIELD
+    },
+    {
+        name: 'gasSettings',
+        type: GAS_SETTINGS
+    }
+]);
+const PRIVATE_CONTEXT_INPUTS = STRUCT([
+    {
+        name: 'callContext',
+        type: CALL_CONTEXT
+    },
+    {
+        name: 'anchorBlockHeader',
+        type: BLOCK_HEADER
+    },
+    {
+        name: 'txContext',
+        type: TX_CONTEXT
+    },
+    {
+        name: 'startSideEffectCounter',
+        type: U32
+    },
+    {
+        name: 'txRequestSalt',
+        type: FIELD
+    }
+]);
+const COMPLETE_ADDRESS = STRUCT([
+    {
+        name: 'address',
+        type: AZTEC_ADDRESS
+    },
+    {
+        name: 'publicKeys',
+        type: PUBLIC_KEYS
+    }
+]);
+const TXE_TX_EFFECTS = STRUCT([
+    {
+        name: 'txHash',
+        type: TX_HASH
+    },
+    {
+        name: 'noteHashes',
+        type: FIXED_BOUNDED_VEC(FIELD, MAX_NOTE_HASHES_PER_TX)
+    },
+    {
+        name: 'nullifiers',
+        type: FIXED_BOUNDED_VEC(FIELD, MAX_NULLIFIERS_PER_TX)
+    },
+    {
+        name: 'privateLogs',
+        type: FIXED_BOUNDED_VEC(FIXED_BOUNDED_VEC(FIELD, PRIVATE_LOG_SIZE_IN_FIELDS), MAX_PRIVATE_LOGS_PER_TX)
+    }
+]);
+const TXE_OFFCHAIN_EFFECTS = FIXED_BOUNDED_VEC(FIXED_BOUNDED_VEC(FIELD, MAX_OFFCHAIN_EFFECT_LEN), MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY);
+const TXE_CALL_CONTEXT = STRUCT([
+    {
+        name: 'txHash',
+        type: OPTION(FIELD)
+    },
+    {
+        name: 'anchorBlockTimestamp',
+        type: U64
+    }
+]);
+const CONTRACT_INSTANCE_MEMBER = FIXED_ARRAY(STRUCT([
+    {
+        name: 'exists',
+        type: BOOL
+    },
+    {
+        name: 'member',
+        type: FIELD
+    }
+]), 1);
+export const EVENT_SELECTOR = SCALAR({
+    kind: 'event-selector',
+    serialization: {
+        fn: (v)=>[
+                v.toField()
+            ]
+    },
+    deserialization: {
+        fn: ([reader])=>EventSelector.fromField(reader.readField())
+    }
+});
+const TXE_PRIVATE_EVENTS = FIXED_BOUNDED_VEC(FIXED_BOUNDED_VEC(FIELD, MAX_PRIVATE_EVENT_LEN), MAX_PRIVATE_EVENTS_PER_TXE_QUERY);
+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: U64
+    }),
+    aztec_txe_advanceBlocksBy: makeEntry({
+        params: [
+            {
+                name: 'blocks',
+                type: U32
+            }
+        ]
+    }),
+    aztec_txe_advanceTimestampBy: makeEntry({
+        params: [
+            {
+                name: 'duration',
+                type: U64
+            }
+        ]
+    }),
+    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
+            },
+            {
+                name: 'partialAddress',
+                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_setTaggingSecretStrategies: makeEntry({
+        params: [
+            {
+                name: 'unconstrainedStrategy',
+                type: OPTION(TAGGING_SECRET_STRATEGY)
+            },
+            {
+                name: 'constrainedStrategy',
+                type: OPTION(TAGGING_SECRET_STRATEGY)
+            }
+        ]
+    }),
+    aztec_txe_setAuthorizeAllUtilityCallTargets: makeEntry({
+        params: [
+            {
+                name: 'authorizeAll',
+                type: BOOL
+            }
+        ]
+    }),
+    aztec_txe_getLastBlockTimestamp: makeEntry({
+        returnType: U64
+    }),
+    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: U64
+    }),
+    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: VECTOR(FIELD)
+            }
+        ]
+    }),
+    aztec_avm_returndataSize: makeEntry({
+        returnType: U32
+    }),
+    aztec_avm_returndataCopy: makeEntry({
+        params: [
+            {
+                name: 'rdOffset',
+                type: U32
+            },
+            {
+                name: 'copySize',
+                type: U32
+            }
+        ],
+        returnType: VECTOR(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);
+    return outputSlotsToForeignCallResult(entry.serializeReturn(result));
+}
+/**
+ * Dispatches an oracle that has been retired into the PXE legacy registry. TXE has no explicit handler method for such
+ * names; this runs them through the same `buildACIRCallback` legacy path that contract execution already uses, so
+ * TXE's top-level oracle path and its in-contract path treat the legacy registry identically.
+ */ const legacyCallbacksByHandler = new WeakMap();
+export async function callTxeLegacyHandler(oracle, inputs, oracleHandler) {
+    // `buildACIRCallback` materializes the whole real+legacy closure set, so memoize it per handler rather than
+    // rebuilding on every call (TXE routes one legacy oracle through here on each top-level discovery).
+    let callback = legacyCallbacksByHandler.get(oracleHandler);
+    if (!callback) {
+        callback = buildACIRCallback(oracleHandler);
+        legacyCallbacksByHandler.set(oracleHandler, callback);
+    }
+    const outputSlots = await callback[oracle](...toInputSlots(inputs));
+    return outputSlotsToForeignCallResult(outputSlots);
+}
+/**
+ * Strips the `0x` prefix from each serialized output slot (TXE foreign calls use bare hex strings) and wraps them in a
+ * `ForeignCallResult`.
+ */ function outputSlotsToForeignCallResult(outputSlots) {
+    return {
+        values: outputSlots.map((slot)=>Array.isArray(slot) ? slot.map(withoutHexPrefix) : withoutHexPrefix(slot))
+    };
+}