Database Changes Uniswaps

// Describes a complete .proto file.

// Describes a oneof.

// Describes a method of a service.

// Binary represents some code compiled to its binary form.

// `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": <string>, "lastName": <string> } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }

// Encapsulates information about the original source file from which a FileDescriptorProto was generated.

// https://github.com/semiotic-ai/sql-wrapper

// https://github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol https://github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol https://github.com/Uniswap/v3-core/blob/main/contracts/interfaces/pool/IUniswapV3PoolEvents.sol

// / @notice Emitted when the protocol fee is changed by the pool / @param feeProtocol0Old The previous value of the token0 protocol fee / @param feeProtocol1Old The previous value of the token1 protocol fee / @param feeProtocol0New The updated value of the token0 protocol fee / @param feeProtocol1New The updated value of the token1 protocol fee

// / @notice Emitted when the collected protocol fees are withdrawn by the factory owner / @param sender The address that collects the protocol fees / @param recipient The address that receives the collected protocol fees / @param amount0 The amount of token0 protocol fees that is withdrawn / @param amount0 The amount of token1 protocol fees that is withdrawn

// / @notice Emitted when a bid is withdrawn (V1 - deprecated) / @param bidId The id of the bid / @param owner The owner of the bid / @param tokensFilled The amount of tokens claimed

// ModuleStats gathers metrics and statistics from each module, running on tier1 or tier2 All the 'count' and 'time_ms' values may include duplicate for each stage going over that module

// / @notice Emitted when a new fee amount is enabled for pool creation via the factory / @param fee The enabled fee, denominated in hundredths of a bip / @param tickSpacing The minimum number of ticks between initialized ticks for pools created with the given fee

// / @notice Emitted for swaps between currency0 and currency1 / @param id The abi encoded hash of the pool key struct for the pool that was modified / @param sender The address that initiated the swap call, and that received the callback / @param amount0 The delta of the currency0 balance of the pool / @param amount1 The delta of the currency1 balance of the pool / @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96 / @param liquidity The liquidity of the pool after the swap / @param tick The log base 1.0001 of the price of the pool after the swap / @param fee The swap fee in hundredths of a bip

// / @notice Emitted when approval is given to `spender` to manage `id`.

// / @notice Emitted when a bid is submitted (V1 - deprecated) / @param id The id of the tick / @param owner The owner of the bid / @param price The price of the bid / @param exactIn Whether the bid is exact in / @param amount The amount of the bid

// A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # Examples Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from Java `Instant.now()`. Instant now = Instant.now(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(now.getEpochSecond()) .setNanos(now.getNano()).build(); Example 6: Compute Timestamp from current time in Python. timestamp = Timestamp() timestamp.GetCurrentTime() # JSON Mapping In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.

// / @notice Emitted when a position's liquidity is removed / @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect / @param owner The owner of the position for which liquidity is removed / @param tickLower The lower tick of the position / @param tickUpper The upper tick of the position / @param amount The amount of liquidity to remove / @param amount0 The amount of token0 withdrawn / @param amount1 The amount of token1 withdrawn

// / @notice Emitted when fees are collected by the owner of a position / @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees / @param owner The owner of the position for which fees are collected / @param tickLower The lower tick of the position / @param tickUpper The upper tick of the position / @param amount0 The amount of token0 fees collected / @param amount1 The amount of token1 fees collected

// / @notice Emitted when fees are collected from a position via the PositionManager.

// https://github.com/Uniswap/v4-core/blob/main/src/interfaces/IPoolManager.sol https://github.com/Uniswap/v4-core/blob/59d3ecf53afa9264a16bba0e38f4c5d2231f80bc/src/interfaces/IProtocolFees.sol

// / @notice Emitted when a position unsubscribes from a subscriber contract.

// Describes a service.

// / @notice Emitted when a position's liquidity is increased via the PositionManager.

// / @notice Emitted when `operator` is enabled or disabled for `owner`.

// Range of reserved tag numbers. Reserved tag numbers may not be used by fields or extension ranges in the same message. Reserved ranges may not overlap.

// BlockRef is a pointer to a block to which we don't know the timestamp

// BlockUndoSignal informs you that every bit of data with a block number above 'last_valid_block' has been reverted on-chain. Delete that data and restart from 'last_valid_cursor'

// Range of reserved numeric values. Reserved values may not be used by entries in the same enum. Reserved ranges may not overlap. Note that this is distinct from DescriptorProto.ReservedRange in that it is inclusive such that it can appropriately represent the entire int32 domain.

// https://www.getdbt.com/product/what-is-dbt

// Describes the relationship between generated code and its original source file. A GeneratedCodeInfo message is associated with only one generated source file, but may contain references to different source .proto files.

// A message representing a option the parser does not recognize. This only appears in options protos created by the compiler::Parser class. DescriptorPool resolves these when building Descriptor objects. Therefore, options protos in descriptor objects (e.g. returned by Descriptor::options(), or produced by Descriptor::CopyTo()) will never have UninterpretedOptions in them.

// / @notice Emitted when a new pool is initialized / @param id The abi encoded hash of the pool key struct for the new pool / @param currency0 The first currency of the pool by address sort order / @param currency1 The second currency of the pool by address sort order / @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip / @param tickSpacing The minimum number of ticks between initialized ticks / @param hooks The hooks contract address for the pool, or address(0) if none / @param sqrtPriceX96 The price of the pool on initialization / @param tick The initial tick of the pool corresponding to the initialized price

// / @notice Emitted when a new checkpoint is created (V1 - deprecated) / @param blockNumber The block number of the checkpoint / @param clearingPrice The clearing price of the checkpoint / @param totalCleared The total amount of tokens cleared / @param cumulativeMps The cumulative percentage of total tokens allocated across all previous steps, represented in ten-millionths of the total supply (1e7 = 100%)

// / @notice Emitted when a pool is created / @param token0 The first token of the pool by address sort order / @param token1 The second token of the pool by address sort order / @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip / @param tickSpacing The minimum number of ticks between initialized ticks / @param pool The address of the created pool

// * In Uniswap v3, the `initialize` function is a crucial setup step that configures a newly deployed pool by setting its initial square root price (`sqrtPriceX96`) and corresponding tick value. After the pool is created via the `PoolCreated` event, calling `initialize` establishes the starting price and essential parameters, thereby enabling the pool to process swaps and support liquidity provisioning. Without this initialization, the pool remains unconfigured and cannot operate properly.

// / @notice Emitted when a position NFT is transferred.

// / @notice Emitted when `operator` is enabled or disabled for `owner`.

// / @notice Emitted when a bid is submitted (V2 - current) / @param id The id of the tick / @param owner The owner of the bid / @param price The price of the bid / @param amount The amount of the bid

// StoreModuleOutput are produced for store modules in development mode. It is not possible to retrieve store models in production, with parallelization enabled. If you need the deltas directly, write a pass through mapper module that will get them down to you.

// / @notice Emitted when the protocol fee controller address is updated in setProtocolFeeController.

// / @notice Emitted when a position subscribes to a subscriber contract.

// / @notice Emitted when a bid is claimed / @param bidId The id of the bid / @param owner The owner of the bid / @param tokensFilled The amount of tokens claimed

// ModulesProgress is a message that is sent every 500ms

// / @notice Emitted by the pool for increases to the number of observations that can be stored / @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index / just before a mint/swap/burn. / @param observationCardinalityNextOld The previous value of the next observation cardinality / @param observationCardinalityNextNew The updated value of the next observation cardinality

// / @notice Emitted when approval is given to `approved` to manage `tokenId`.

// / @notice Emitted when an auction is created / @param auction The address of the created auction / @param token The token being auctioned / @param amount The amount of tokens deposited to the auction / @param configData The configuration data for the auction

// / @notice Emitted when a position's liquidity is decreased via the PositionManager.