diff --git a/engine-bridge/event-queue.db-shm b/engine-bridge/event-queue.db-shm deleted file mode 100644 index fc29af5..0000000 Binary files a/engine-bridge/event-queue.db-shm and /dev/null differ diff --git a/engine-bridge/event-queue.db-wal b/engine-bridge/event-queue.db-wal deleted file mode 100644 index 8821759..0000000 Binary files a/engine-bridge/event-queue.db-wal and /dev/null differ diff --git a/engine-bridge/src/__tests__/relayer-auth.test.ts b/engine-bridge/src/__tests__/relayer-auth.test.ts index 71a4355..1931d50 100644 --- a/engine-bridge/src/__tests__/relayer-auth.test.ts +++ b/engine-bridge/src/__tests__/relayer-auth.test.ts @@ -159,9 +159,17 @@ describe("ZkStateSyncer with auth", () => { ws.close(); }); - it("works without auth when no auth config is provided", async () => { + it("accepts any client when unauthenticated mode is explicitly opted into", async () => { + const warn = jest.spyOn(console, "warn").mockImplementation(() => {}); prop = makePropagator(); - syncer = new ZkStateSyncer(prop, { port: 0, pingIntervalMs: 60_000 }); + // Previously this passed no auth options at all and the server silently + // came up wide open. That is now an explicit opt-in. + syncer = new ZkStateSyncer(prop, { + port: 0, + pingIntervalMs: 60_000, + allowUnauthenticated: true, + }); + warn.mockRestore(); await syncer.ready; const ws = await new Promise((resolve, reject) => { diff --git a/engine-bridge/src/__tests__/wallet-connector.test.ts b/engine-bridge/src/__tests__/wallet-connector.test.ts index 626be40..d6f2579 100644 --- a/engine-bridge/src/__tests__/wallet-connector.test.ts +++ b/engine-bridge/src/__tests__/wallet-connector.test.ts @@ -1,5 +1,5 @@ import { Keypair, Networks, WebAuth } from "@stellar/stellar-sdk"; -import { WalletConnector } from "../wallet-connector"; +import { WalletConnector, type AccountLoader } from "../wallet-connector"; describe("WalletConnector", () => { const networkPassphrase = Networks.TESTNET; @@ -7,7 +7,14 @@ describe("WalletConnector", () => { const serverKeypair = Keypair.random(); const clientKeypair = Keypair.random(); - it("creates and verifies a valid challenge-response", () => { + /** A single master key at full weight, med_threshold 1 — the common case. */ + const masterKeyLoader = (accountId: string): AccountLoader => + async () => ({ + signers: [{ key: accountId, weight: 1, type: "ed25519_public_key" }], + thresholds: { med_threshold: 1 }, + }); + + function signedChallenge(signer: Keypair): string { const xdr = WalletConnector.createChallenge({ serverKeypair, clientAddress: clientKeypair.publicKey(), @@ -15,9 +22,6 @@ describe("WalletConnector", () => { domain, }); - expect(xdr).toBeDefined(); - - // Sign the challenge as the client const { tx: transaction } = WebAuth.readChallengeTx( xdr, serverKeypair.publicKey(), @@ -26,47 +30,94 @@ describe("WalletConnector", () => { domain ); - transaction.sign(clientKeypair); - const signedXdr = transaction.toEnvelope().toXDR("base64").toString(); + transaction.sign(signer); + return transaction.toEnvelope().toXDR("base64").toString(); + } - const verifiedAddress = WalletConnector.verifyResponse( - signedXdr, + it("creates and verifies a valid challenge-response", async () => { + const verifiedAddress = await WalletConnector.verifyResponse( + signedChallenge(clientKeypair), serverKeypair.publicKey(), networkPassphrase, - domain + domain, + masterKeyLoader(clientKeypair.publicKey()) ); expect(verifiedAddress).toBe(clientKeypair.publicKey()); }); - it("throws error for invalid signature", () => { - const xdr = WalletConnector.createChallenge({ - serverKeypair, - clientAddress: clientKeypair.publicKey(), - networkPassphrase, - domain, + it("throws error for invalid signature", async () => { + const otherKeypair = Keypair.random(); + + await expect( + WalletConnector.verifyResponse( + signedChallenge(otherKeypair), + serverKeypair.publicKey(), + networkPassphrase, + domain, + masterKeyLoader(clientKeypair.publicKey()) + ) + ).rejects.toThrow("Invalid signature: client signature missing or incorrect"); + }); + + // Verification used to pass a fabricated signer set — the account ID read out + // of the submitted XDR, at weight 1, threshold 1 — and never fetched the real + // account. A revoked master key (weight 0) therefore still authenticated. + it("rejects a master key whose weight has been revoked to zero", async () => { + const revokedLoader: AccountLoader = async () => ({ + signers: [ + { key: clientKeypair.publicKey(), weight: 0, type: "ed25519_public_key" }, + ], + thresholds: { med_threshold: 1 }, }); - // Don't sign as the client (or sign with wrong key) - const otherKeypair = Keypair.random(); - const { tx: transaction } = WebAuth.readChallengeTx( - xdr, - serverKeypair.publicKey(), - networkPassphrase, - domain, - domain - ); + await expect( + WalletConnector.verifyResponse( + signedChallenge(clientKeypair), + serverKeypair.publicKey(), + networkPassphrase, + domain, + revokedLoader + ) + ).rejects.toThrow("Invalid signature: client signature missing or incorrect"); + }); + + // A single signature must not satisfy a multi-sig account: the old fabricated + // set hardcoded threshold 1 regardless of the account's real med_threshold. + it("rejects a single signature on a multi-sig account below threshold", async () => { + const coSigner = Keypair.random(); + const multisigLoader: AccountLoader = async () => ({ + signers: [ + { key: clientKeypair.publicKey(), weight: 1, type: "ed25519_public_key" }, + { key: coSigner.publicKey(), weight: 1, type: "ed25519_public_key" }, + ], + thresholds: { med_threshold: 2 }, + }); + + await expect( + WalletConnector.verifyResponse( + signedChallenge(clientKeypair), + serverKeypair.publicKey(), + networkPassphrase, + domain, + multisigLoader + ) + ).rejects.toThrow("Invalid signature: client signature missing or incorrect"); + }); - transaction.sign(otherKeypair); - const signedXdr = transaction.toEnvelope().toXDR("base64").toString(); + it("fails closed when the account cannot be loaded", async () => { + const failingLoader: AccountLoader = async () => { + throw new Error("404 Not Found"); + }; - expect(() => { + await expect( WalletConnector.verifyResponse( - signedXdr, + signedChallenge(clientKeypair), serverKeypair.publicKey(), networkPassphrase, - domain - ); - }).toThrow("Invalid signature: client signature missing or incorrect"); + domain, + failingLoader + ) + ).rejects.toThrow(/unable to load account/i); }); }); diff --git a/engine-bridge/src/__tests__/zk-state-syncer.test.ts b/engine-bridge/src/__tests__/zk-state-syncer.test.ts index 2dc0651..c6c62ac 100644 --- a/engine-bridge/src/__tests__/zk-state-syncer.test.ts +++ b/engine-bridge/src/__tests__/zk-state-syncer.test.ts @@ -35,13 +35,23 @@ async function connectClient(port: number): Promise { // ── ZkStateSyncer ───────────────────────────────────────────────────────────── +// These suites deliberately run the syncer unauthenticated, which now emits a +// warning by design. Silence it so it doesn't read as an unexpected log. +let warnSpy: jest.SpyInstance; +beforeAll(() => { + warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {}); +}); +afterAll(() => { + warnSpy.mockRestore(); +}); + describe("ZkStateSyncer", () => { let syncer: ZkStateSyncer; let prop: ReturnType; beforeEach(async () => { prop = makePropagator(); - syncer = new ZkStateSyncer(prop, { port: 0, pingIntervalMs: 60_000 }); + syncer = new ZkStateSyncer(prop, { port: 0, pingIntervalMs: 60_000, allowUnauthenticated: true }); await syncer.ready; }); @@ -120,7 +130,7 @@ describe("ZkStateSyncer", () => { it("respects a custom zkTopic filter", async () => { await syncer.close(); prop = makePropagator(); - syncer = new ZkStateSyncer(prop, { port: 0, zkTopic: "breaker_open", pingIntervalMs: 60_000 }); + syncer = new ZkStateSyncer(prop, { port: 0, zkTopic: "breaker_open", pingIntervalMs: 60_000, allowUnauthenticated: true }); await syncer.ready; const ws = await connectClient(syncer.getPort()); @@ -152,3 +162,52 @@ describe("ZkStateSyncer", () => { ws.close(); }); }); + +describe("ZkStateSyncer authentication guard", () => { + const prop = { onEvent: () => {} }; + + // main.ts constructed the syncer as `new ZkStateSyncer(propagator, { port })`. + // Both auth options are optional, so verifyClient was never installed and the + // broadcast guard short-circuited: every socket connected and received all ZK + // state commitments, with RelayerAuth unreachable in production. + it("refuses to start with no authentication configured", () => { + expect(() => new ZkStateSyncer(prop, { port: 0 })).toThrow( + /refusing to start without authentication/i, + ); + }); + + it("starts when auth is configured", async () => { + const s = new ZkStateSyncer(prop, { + port: 0, + pingIntervalMs: 60_000, + auth: { apiKeys: ["test-key"] }, + }); + await s.ready; + await s.close(); + }); + + it("starts when a server signing key is configured", async () => { + const s = new ZkStateSyncer(prop, { + port: 0, + pingIntervalMs: 60_000, + serverSigningKey: "SIGNING_KEY", + }); + await s.ready; + await s.close(); + }); + + it("starts unauthenticated only when explicitly opted in, and warns", async () => { + const warn = jest.spyOn(console, "warn").mockImplementation(() => {}); + const s = new ZkStateSyncer(prop, { + port: 0, + pingIntervalMs: 60_000, + allowUnauthenticated: true, + }); + expect(warn).toHaveBeenCalledWith( + expect.stringContaining("running without authentication"), + ); + warn.mockRestore(); + await s.ready; + await s.close(); + }); +}); diff --git a/engine-bridge/src/main.ts b/engine-bridge/src/main.ts index f1fc785..3940544 100644 --- a/engine-bridge/src/main.ts +++ b/engine-bridge/src/main.ts @@ -8,6 +8,8 @@ import { RpcClient } from "./rpc-client"; import { EventPropagator } from "./event-propagator"; import { ZkStateSyncer } from "./zk-state-syncer"; +import { horizonAccountLoader } from "./wallet-connector"; +import { Horizon } from "@stellar/stellar-sdk"; import { HeartbeatMonitor } from "./heartbeat-monitor"; import { AlertChannelService, WebhookAlertChannel, ConsoleAlertChannel } from "./alert-channel"; @@ -18,6 +20,24 @@ async function main() { const cursor = process.env.EVENT_CURSOR; const webhookUrl = process.env.ALERT_WEBHOOK_URL || ""; + // Relayer authentication. Previously none of this was passed to the syncer, + // so `verifyClient` was never installed and the broadcast guard short- + // circuited — the server accepted every connection and sent all ZK state + // commitments to it, with RelayerAuth unreachable in the only production + // entrypoint. + const apiKeys = (process.env.RELAYER_API_KEYS || "") + .split(",") + .map((k) => k.trim()) + .filter(Boolean); + const jwtSecret = process.env.RELAYER_JWT_SECRET || undefined; + const serverSigningKey = process.env.SERVER_SIGNING_KEY || undefined; + const allowUnauthenticated = process.env.ALLOW_UNAUTHENTICATED_SYNCER === "true"; + // SEP-10 verification needs the client account's real signer set. + const horizonUrl = process.env.HORIZON_URL || "https://horizon-testnet.stellar.org"; + const loadAccount = serverSigningKey + ? horizonAccountLoader(new Horizon.Server(horizonUrl)) + : undefined; + console.log("[Bridge] Starting service..."); console.log(`[Bridge] RPC URLs: ${rpcUrls.join(", ")}`); console.log(`[Bridge] Contract: ${contractId}`); @@ -33,7 +53,16 @@ async function main() { } const alertService = new AlertChannelService({ channels: alertChannels }); - const syncer = new ZkStateSyncer(propagator, { port }); + const hasAuth = apiKeys.length > 0 || Boolean(jwtSecret); + const syncer = new ZkStateSyncer(propagator, { + port, + ...(hasAuth && { auth: { apiKeys: apiKeys.length ? apiKeys : undefined, jwtSecret } }), + ...(serverSigningKey && { serverSigningKey }), + ...(loadAccount && { loadAccount }), + ...(process.env.NETWORK_PASSPHRASE && { networkPassphrase: process.env.NETWORK_PASSPHRASE }), + ...(process.env.AUTH_DOMAIN && { domain: process.env.AUTH_DOMAIN }), + allowUnauthenticated, + }); const heartbeat = new HeartbeatMonitor(rpc, propagator, { alertService }); heartbeat.start(); diff --git a/engine-bridge/src/wallet-connector.ts b/engine-bridge/src/wallet-connector.ts index 908f56e..22754dd 100644 --- a/engine-bridge/src/wallet-connector.ts +++ b/engine-bridge/src/wallet-connector.ts @@ -1,4 +1,5 @@ import { + Horizon, Keypair, WebAuth, } from "@stellar/stellar-sdk"; @@ -11,6 +12,30 @@ export interface ChallengeOptions { timeout?: number; } +/** The subset of a Horizon account this module needs. Keeps it mockable in tests. */ +export interface AccountSigners { + signers: Array<{ key: string; weight: number; type: string }>; + thresholds: { med_threshold: number }; +} + +/** Loads a client account's real signer configuration. */ +export type AccountLoader = (accountId: string) => Promise; + +/** Builds an `AccountLoader` backed by a real Horizon server. */ +export function horizonAccountLoader(server: Horizon.Server): AccountLoader { + return async (accountId: string) => { + const account = await server.loadAccount(accountId); + return { + signers: account.signers.map((s) => ({ + key: s.key, + weight: s.weight, + type: s.type, + })), + thresholds: { med_threshold: account.thresholds.med_threshold }, + }; + }; +} + export class WalletConnector { /** * Generates a SEP-10 challenge transaction XDR. @@ -29,14 +54,29 @@ export class WalletConnector { } /** - * Verifies a signed SEP-10 challenge transaction. + * Verifies a signed SEP-10 challenge transaction against the client + * account's **real** signer configuration. + * + * This previously passed a fabricated signer set — `[{ key: clientAccountID, + * weight: 1 }]` with `threshold: 1`, where the account ID was read out of the + * submitted XDR itself. The account was never fetched, so: + * + * - a master key whose weight had been set to 0 (the standard revocation + * after a key compromise) still authenticated as that account, and + * - any single signer on a multi-sig account satisfied verification, + * regardless of the account's actual `med_threshold`. + * + * Both matter here because the accounts this gate protects are the treasury + * and governance accounts, which are exactly the ones expected to be + * multi-sig. */ - static verifyResponse( + static async verifyResponse( xdr: string, serverAddress: string, networkPassphrase: string, - domain: string - ): string { + domain: string, + loadAccount: AccountLoader, + ): Promise { const { clientAccountID } = WebAuth.readChallengeTx( xdr, serverAddress, @@ -45,14 +85,35 @@ export class WalletConnector { domain // webAuthDomain ); + let account: AccountSigners; + try { + account = await loadAccount(clientAccountID); + } catch (err) { + // A missing account cannot be verified against a signer set. Fail closed + // rather than falling back to the master-key assumption. + throw new Error( + `Cannot verify challenge: unable to load account ${clientAccountID}`, + ); + } + + const signerSummary = account.signers.map((s) => ({ + key: s.key, + weight: s.weight, + type: s.type, + })); + + // med_threshold governs signature-weight operations, which is the category + // a SEP-10 challenge falls under. + const threshold = account.thresholds.med_threshold; + let signersFound: string[]; try { signersFound = WebAuth.verifyChallengeTxThreshold( xdr, serverAddress, networkPassphrase, - 1, // threshold - [{ key: clientAccountID, weight: 1, type: "ed25519_public_key" }], + threshold, + signerSummary, domain, domain // webAuthDomain ); diff --git a/engine-bridge/src/zk-state-syncer.ts b/engine-bridge/src/zk-state-syncer.ts index 9f29f6f..25244f0 100644 --- a/engine-bridge/src/zk-state-syncer.ts +++ b/engine-bridge/src/zk-state-syncer.ts @@ -14,7 +14,7 @@ import { Keypair } from "@stellar/stellar-sdk"; import type { EventPropagator, EngineEvent } from "./event-propagator"; import { RelayerAuth } from "./relayer-auth"; import type { RelayerAuthOptions } from "./relayer-auth"; -import { WalletConnector } from "./wallet-connector"; +import { WalletConnector, type AccountLoader } from "./wallet-connector"; export interface ZkStateSnapshot { type: "zk_state_update"; @@ -41,6 +41,22 @@ export interface ZkStateSyncerOptions { serverSigningKey?: string; networkPassphrase?: string; domain?: string; + /** + * Loads a client account's real signer configuration for SEP-10 + * verification. Required whenever `serverSigningKey` is set — without it, + * verification cannot check signer weights or the account threshold. + */ + loadAccount?: AccountLoader; + /** + * Explicitly run without authentication. + * + * Required when neither `auth` nor `serverSigningKey` is supplied. Both are + * optional, so omitting them used to silently produce a server that accepted + * every connection and broadcast all ZK state commitments to it — with the + * whole RelayerAuth layer unreachable. Making that an explicit opt-in means a + * misconfigured deployment fails at startup instead of running wide open. + */ + allowUnauthenticated?: boolean; } const DEFAULT_ZK_TOPIC = "state_commitment"; @@ -63,6 +79,24 @@ export class ZkStateSyncer { this.options = options; this.zkTopic = options.zkTopic ?? DEFAULT_ZK_TOPIC; + // Fail closed. `auth` gates who may connect; `serverSigningKey` gates who + // receives broadcasts. With neither, every socket connects and receives + // everything, and RelayerAuth never runs at all. + if (!options.auth && !options.serverSigningKey && !options.allowUnauthenticated) { + throw new Error( + "ZkStateSyncer: refusing to start without authentication. " + + "Supply `auth` and/or `serverSigningKey`, or set `allowUnauthenticated: true` " + + "to run open deliberately (local development only).", + ); + } + + if (options.allowUnauthenticated && !options.auth && !options.serverSigningKey) { + console.warn( + "[ZkStateSyncer] WARNING: running without authentication. Every connecting " + + "client will receive all ZK state commitments.", + ); + } + this.wss = new WebSocketServer({ port: options.port, ...(options.auth && { verifyClient: (info, cb) => new RelayerAuth(options.auth!).verifyClient(info, cb) }), @@ -144,17 +178,28 @@ export class ZkStateSyncer { } } - private handleAuthSubmit(ws: WebSocket, xdr: string): void { - const { serverSigningKey, networkPassphrase, domain } = this.options; + private async handleAuthSubmit(ws: WebSocket, xdr: string): Promise { + const { serverSigningKey, networkPassphrase, domain, loadAccount } = this.options; if (!serverSigningKey || !networkPassphrase || !domain) return; + if (!loadAccount) { + // Verification needs the account's real signer set. Without a loader we + // cannot check weights or thresholds, so refuse rather than fall back to + // assuming a single master key at weight 1. + ws.send( + JSON.stringify({ type: "auth_error", message: "Account loader not configured on server" }), + ); + return; + } + try { const serverKeypair = Keypair.fromSecret(serverSigningKey); - const address = WalletConnector.verifyResponse( + const address = await WalletConnector.verifyResponse( xdr, serverKeypair.publicKey(), networkPassphrase, - domain + domain, + loadAccount, ); const client = this.clients.get(ws); diff --git a/engine-core/src/core/control_plane.rs b/engine-core/src/core/control_plane.rs index 04a93fb..413a7e0 100644 --- a/engine-core/src/core/control_plane.rs +++ b/engine-core/src/core/control_plane.rs @@ -49,6 +49,16 @@ const RESERVED_KEYS: &[Symbol] = &[ symbol_short!("VERSION"), symbol_short!("VER_INIT"), symbol_short!("ZK_COUNT"), + // RBAC slots owned by core::access. Without these, update_param could + // overwrite C_ADMIN (an Address) with a u64, after which every + // require_role fails host conversion — and access::initialize refuses to + // re-run because C_INIT is still set, so there is no recovery path. + symbol_short!("C_INIT"), + symbol_short!("C_ADMIN"), + symbol_short!("C_OPERS"), + symbol_short!("C_AUDIT"), + // Proxy storage gap. + symbol_short!("GAP"), ]; #[contracterror] diff --git a/engine-core/src/core/tests.rs b/engine-core/src/core/tests.rs index baf143d..33599c7 100644 --- a/engine-core/src/core/tests.rs +++ b/engine-core/src/core/tests.rs @@ -378,3 +378,32 @@ fn test_proxy_upgrade_rejects_non_admin() { let result = client.try_upgrade(&new_wasm_hash); assert!(result.is_err()); } + +/// `update_param` must refuse the RBAC storage slots owned by `core::access`. +/// +/// `RESERVED_KEYS` previously omitted them, so an admin could write `C_ADMIN` +/// — replacing an `Address` with a `u64`. Every later `require_role` then fails +/// host conversion, and `access::initialize` refuses to re-run because +/// `C_INIT` is still set, leaving no way to restore the role layer. +#[test] +fn test_update_param_rejects_rbac_storage_keys() { + let env = Env::default(); + let (client, admin, _) = initialized_client(&env); + + for key in [ + symbol_short!("C_ADMIN"), + symbol_short!("C_INIT"), + symbol_short!("C_OPERS"), + symbol_short!("C_AUDIT"), + symbol_short!("GAP"), + ] { + let payload = BytesN::from_array(&env, &[7u8; 32]); + let commitment = commitment(&env, &admin, 1, &payload); + let result = client.try_update_param(&admin, &key, &1u64, &commitment, &payload); + assert!( + result.is_err(), + "update_param must reject reserved RBAC key {:?}", + key + ); + } +} diff --git a/engine-core/test_snapshots/core/tests/test_batch_update_param_rejects_version_keys.1.json b/engine-core/test_snapshots/core/tests/test_batch_update_param_rejects_version_keys.1.json new file mode 100644 index 0000000..7652532 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_batch_update_param_rejects_version_keys.1.json @@ -0,0 +1,1253 @@ +{ + "generators": { + "address": 3, + "nonce": 0 + }, + "auth": [ + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "initialize", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "CP_INIT" + }, + "val": { + "bool": true + } + }, + { + "key": { + "symbol": "P_COUNT" + }, + "val": { + "u64": 0 + } + }, + { + "key": { + "symbol": "VERSION" + }, + "val": { + "u32": 1 + } + }, + { + "key": { + "symbol": "VER_INIT" + }, + "val": { + "bool": true + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "batch_update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "VERSION" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "symbol": "EVENT" + }, + { + "symbol": "LOG" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "flags" + }, + "val": { + "u32": 257 + } + }, + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "value" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "seq" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "batch_update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "VERSION" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "batch_update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "VER_INIT" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "symbol": "EVENT" + }, + { + "symbol": "LOG" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "flags" + }, + "val": { + "u32": 257 + } + }, + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "value" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "seq" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "batch_update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "VER_INIT" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "batch_update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "ZK_COUNT" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "symbol": "EVENT" + }, + { + "symbol": "LOG" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "flags" + }, + "val": { + "u32": 257 + } + }, + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "value" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "contract", + "body": { + "v0": { + "topics": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "data": { + "map": [ + { + "key": { + "symbol": "hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + }, + { + "key": { + "symbol": "seq" + }, + "val": { + "u64": 2 + } + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "batch_update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "vec": [ + { + "vec": [ + { + "symbol": "ZK_COUNT" + }, + { + "u64": 999 + } + ] + } + ] + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 101 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 2 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "4e8e1d41197ef7a08d5b52417f8128512def2b8ecfecebcdfe6b6ef818908a24" + } + } + ] + }, + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_non_admin.1.json b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_non_admin.1.json new file mode 100644 index 0000000..92d3b65 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_non_admin.1.json @@ -0,0 +1,392 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "GAP" + }, + "val": { + "vec": [ + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "upgrade" + } + ], + "data": { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "auth": "invalid_action" + } + } + ], + "data": { + "vec": [ + { + "string": "Unauthorized function call for address" + }, + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "auth": "invalid_action" + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "auth": "invalid_action" + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "auth": "invalid_action" + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "upgrade" + }, + { + "vec": [ + { + "bytes": "0202020202020202020202020202020202020202020202020202020202020202" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_pre_init.1.json b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_pre_init.1.json new file mode 100644 index 0000000..6a44e39 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_pre_init.1.json @@ -0,0 +1,248 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "upgrade" + } + ], + "data": { + "bytes": "0101010101010101010101010101010101010101010101010101010101010101" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 1 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "vec": [ + { + "string": "contract call failed" + }, + { + "symbol": "upgrade" + }, + { + "vec": [ + { + "bytes": "0101010101010101010101010101010101010101010101010101010101010101" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_zero_hash.1.json b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_zero_hash.1.json new file mode 100644 index 0000000..945fd03 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_rejects_zero_hash.1.json @@ -0,0 +1,490 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "init", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "GAP" + }, + "val": { + "vec": [ + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "init" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "init" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "upgrade" + } + ], + "data": { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 3 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "upgrade" + }, + { + "vec": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_proxy_upgrade_success.1.json b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_success.1.json new file mode 100644 index 0000000..6de6e20 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_proxy_upgrade_success.1.json @@ -0,0 +1,481 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "init", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "upgrade", + "args": [ + { + "bytes": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ] + } + }, + "sub_invocations": [] + } + ] + ] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "GAP" + }, + "val": { + "vec": [ + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + }, + { + "u64": 0 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 5541220902715666415 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 5541220902715666415 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "init" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "init" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "upgrade" + } + ], + "data": { + "bytes": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "system", + "body": { + "v0": { + "topics": [ + { + "symbol": "executable_update" + }, + { + "vec": [ + { + "symbol": "Wasm" + }, + { + "bytes": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ] + }, + { + "vec": [ + { + "symbol": "Wasm" + }, + { + "bytes": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ] + } + ], + "data": { + "vec": [] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "upgrade" + } + ], + "data": "void" + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_proxy_verify_integrity_rejects_pre_init.1.json b/engine-core/test_snapshots/core/tests/test_proxy_verify_integrity_rejects_pre_init.1.json new file mode 100644 index 0000000..9a4f27b --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_proxy_verify_integrity_rejects_pre_init.1.json @@ -0,0 +1,324 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "verify_integrity" + } + ], + "data": { + "vec": [ + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 0 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "a98c7906f6f958b7ced77caeadfbc6b7e6fc864ba3786164610386e92e6750bf" + } + } + ] + }, + { + "bytes": "0101010101010101010101010101010101010101010101010101010101010101" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 100 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 100 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 100 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 100 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 100 + } + } + ], + "data": { + "vec": [ + { + "string": "contract call failed" + }, + { + "symbol": "verify_integrity" + }, + { + "vec": [ + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 0 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "a98c7906f6f958b7ced77caeadfbc6b7e6fc864ba3786164610386e92e6750bf" + } + } + ] + }, + { + "bytes": "0101010101010101010101010101010101010101010101010101010101010101" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 100 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_update_param_rejects_rbac_storage_keys.1.json b/engine-core/test_snapshots/core/tests/test_update_param_rejects_rbac_storage_keys.1.json new file mode 100644 index 0000000..8913ac4 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_update_param_rejects_rbac_storage_keys.1.json @@ -0,0 +1,1425 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "initialize", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [], + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "CP_INIT" + }, + "val": { + "bool": true + } + }, + { + "key": { + "symbol": "P_COUNT" + }, + "val": { + "u64": 0 + } + }, + { + "key": { + "symbol": "VERSION" + }, + "val": { + "u32": 1 + } + }, + { + "key": { + "symbol": "VER_INIT" + }, + "val": { + "bool": true + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_ADMIN" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_ADMIN" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_INIT" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_INIT" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_OPERS" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_OPERS" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_AUDIT" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "C_AUDIT" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "GAP" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "GAP" + }, + { + "u64": 1 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "704b191ecd5a8c781a0a1d64c4ff31371e199df79a5597f7d68ee4469d8ad278" + } + } + ] + }, + { + "bytes": "0707070707070707070707070707070707070707070707070707070707070707" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/engine-core/test_snapshots/core/tests/test_update_param_rejects_version_keys.1.json b/engine-core/test_snapshots/core/tests/test_update_param_rejects_version_keys.1.json new file mode 100644 index 0000000..3efaa66 --- /dev/null +++ b/engine-core/test_snapshots/core/tests/test_update_param_rejects_version_keys.1.json @@ -0,0 +1,941 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "initialize", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [], + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "ADMIN" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "CP_INIT" + }, + "val": { + "bool": true + } + }, + { + "key": { + "symbol": "P_COUNT" + }, + "val": { + "u64": 0 + } + }, + { + "key": { + "symbol": "VERSION" + }, + "val": { + "u32": 1 + } + }, + { + "key": { + "symbol": "VER_INIT" + }, + "val": { + "bool": true + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 801925984706572462 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "VERSION" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "VERSION" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "VER_INIT" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "VER_INIT" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "update_param" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "ZK_COUNT" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "failing with contract error" + }, + { + "u32": 6 + } + ] + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 6 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "update_param" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "symbol": "ZK_COUNT" + }, + { + "u64": 999 + }, + { + "map": [ + { + "key": { + "symbol": "author" + }, + "val": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + }, + { + "key": { + "symbol": "ledger" + }, + "val": { + "u32": 0 + } + }, + { + "key": { + "symbol": "sequence" + }, + "val": { + "u64": 1 + } + }, + { + "key": { + "symbol": "state_hash" + }, + "val": { + "bytes": "33b17a720159c724cbded2b74624dc582c4aff2ee91fa6fa0fcca4c589356812" + } + } + ] + }, + { + "bytes": "0404040404040404040404040404040404040404040404040404040404040404" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/src/audit-guard/test_snapshots/test/test_validate_and_audit_empty_payload.1.json b/src/audit-guard/test_snapshots/test/test_validate_and_audit_empty_payload.1.json new file mode 100644 index 0000000..92cd152 --- /dev/null +++ b/src/audit-guard/test_snapshots/test/test_validate_and_audit_empty_payload.1.json @@ -0,0 +1,207 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "validate_and_audit" + } + ], + "data": { + "vec": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "" + }, + { + "bytes": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "validate_and_audit" + } + ], + "data": { + "error": { + "contract": 3 + } + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "string": "escalating Ok(ScErrorType::Contract) frame-exit to Err" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 3 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "validate_and_audit" + }, + { + "vec": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "" + }, + { + "bytes": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ] + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/src/audit-guard/test_snapshots/test/test_validate_and_audit_invalid_signature.1.json b/src/audit-guard/test_snapshots/test/test_validate_and_audit_invalid_signature.1.json new file mode 100644 index 0000000..2d402eb --- /dev/null +++ b/src/audit-guard/test_snapshots/test/test_validate_and_audit_invalid_signature.1.json @@ -0,0 +1,257 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "validate_and_audit" + } + ], + "data": { + "vec": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "74657374207061796c6f6164" + }, + { + "bytes": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "crypto": "invalid_input" + } + } + ], + "data": { + "string": "failed ED25519 verification" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "crypto": "invalid_input" + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "crypto": "invalid_input" + } + } + ], + "data": { + "string": "caught error from function" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "crypto": "invalid_input" + } + } + ], + "data": { + "vec": [ + { + "string": "contract call failed" + }, + { + "symbol": "validate_and_audit" + }, + { + "vec": [ + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "bytes": "74657374207061796c6f6164" + }, + { + "bytes": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "crypto": "invalid_input" + } + } + ], + "data": { + "string": "escalating error to panic" + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/src/audit-guard/test_snapshots/test/test_verify_context.1.json b/src/audit-guard/test_snapshots/test/test_verify_context.1.json new file mode 100644 index 0000000..a284cb1 --- /dev/null +++ b/src/audit-guard/test_snapshots/test/test_verify_context.1.json @@ -0,0 +1,408 @@ +{ + "generators": { + "address": 2, + "nonce": 0 + }, + "auth": [ + [], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "set_verified", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "bool": true + } + ] + } + }, + "sub_invocations": [] + } + ] + ], + [ + [ + "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + { + "function": { + "contract_fn": { + "contract_address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "function_name": "verify_context", + "args": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + }, + "sub_invocations": [] + } + ] + ] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + "val": { + "bool": true + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 1033654523790656264 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 1033654523790656264 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 5541220902715666415 + } + }, + "durability": "temporary" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4", + "key": { + "ledger_key_nonce": { + "nonce": 5541220902715666415 + } + }, + "durability": "temporary", + "val": "void" + } + }, + "ext": "v0" + }, + 6311999 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "verify_context" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "verify_context" + } + ], + "data": { + "error": { + "contract": 1 + } + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "string": "escalating Ok(ScErrorType::Contract) frame-exit to Err" + } + } + } + }, + "failed_call": true + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "error" + }, + { + "error": { + "contract": 1 + } + } + ], + "data": { + "vec": [ + { + "string": "contract try_call failed" + }, + { + "symbol": "verify_context" + }, + { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + ] + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "set_verified" + } + ], + "data": { + "vec": [ + { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + }, + { + "bool": true + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "set_verified" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "verify_context" + } + ], + "data": { + "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4" + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "verify_context" + } + ], + "data": "void" + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file