@aztec/txe 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/dest/oracle/txe_oracle_registry.js

@@ -0,0 +1,767 @@
+/* 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, BLOCK_NUMBER, BOOL, ETH_ADDRESS, FIELD, FIXED_ARRAY, FUNCTION_SELECTOR, LEAF, OPTION, ORACLE_REGISTRY, SCALAR, STR, STRUCT, U32, U64, buildACIRCallback, 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 = LEAF({
+    kind: '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_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 PRIVATE_CONTEXT_INPUTS = LEAF({
+    kind: 'private-context-inputs',
+    serialization: {
+        fn: (v)=>v.toFields()
+    },
+    shape: Array(PRIVATE_CONTEXT_INPUTS_LENGTH).fill('scalar')
+});
+const COMPLETE_ADDRESS = LEAF({
+    kind: 'complete-address',
+    serialization: {
+        fn: (v)=>[
+                v.address.toField(),
+                ...v.publicKeys.toFields()
+            ]
+    },
+    shape: Array(8).fill('scalar')
+});
+const TXE_TX_EFFECTS = LEAF({
+    kind: '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 = LEAF({
+    kind: '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 = LEAF({
+    kind: '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 = FIXED_ARRAY(STRUCT([
+    {
+        name: 'exists',
+        type: BOOL
+    },
+    {
+        name: 'member',
+        type: FIELD
+    }
+]), 1);
+const EVENT_SELECTOR = SCALAR({
+    kind: 'event-selector',
+    serialization: {
+        fn: (v)=>[
+                v.toField()
+            ]
+    },
+    deserialization: {
+        fn: ([reader])=>EventSelector.fromField(reader.readField())
+    }
+});
+const TXE_PRIVATE_EVENTS = LEAF({
+    kind: '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: 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: ARRAY(FIELD)
+            }
+        ]
+    }),
+    aztec_avm_returndataSize: makeEntry({
+        returnType: U32
+    }),
+    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);
+    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))
+    };
+}