>,
+) => {
+ const manifest = constructManifest(
+ connectedAccount,
+ ignitionAddress,
+ liquidityReceipt,
+ localId,
+ );
+ console.log(manifest);
+ dAppToolkit.walletApi
+ .sendTransaction({ transactionManifest: manifest })
+ .map((item) => setLastTxHash(item.transactionIntentHash));
+};
diff --git a/frontend/src/components/MintUtility.tsx b/frontend/src/components/MintUtility.tsx
new file mode 100644
index 00000000..310f97f8
--- /dev/null
+++ b/frontend/src/components/MintUtility.tsx
@@ -0,0 +1,113 @@
+import Container from "react-bootstrap/Container";
+import Row from "react-bootstrap/Row";
+import Col from "react-bootstrap/Col";
+import Form from "react-bootstrap/Form";
+import { Button } from "react-bootstrap";
+
+import {
+ DexEntities,
+ TestingBootstrapInformation,
+ bootstrapInformation,
+} from "../BootstrapInformation";
+import {
+ ConnectedAccount,
+ useConnectedAccounts,
+} from "../hooks/ConnectedAccounts";
+import { RadixDappToolkit } from "@radixdlt/radix-dapp-toolkit";
+import { SUPPORTED_EXCHANGES } from "../constants";
+import { dAppToolkit } from "../RadixDappToolkit";
+import { Dispatch, SetStateAction } from "react";
+
+const NO_X_AXIS_BORDERS_CLASS_NAME: string = "mx-0 px-0";
+
+export const MintUtility = (props: Props) => {
+ const connectedAccount = useConnectedAccounts();
+
+ const isAccountConnected = connectedAccount.status === "success";
+
+ if (connectedAccount.status === "success") {
+ return (
+
+
+ {props.title || "Mint Utility"}
+
+
+
+ {[
+ [bootstrapInformation.protocol.protocol_resource, "XRD"],
+ ...Object.entries(bootstrapInformation.resources).map(
+ ([address, information]) => [address, information.symbol],
+ ),
+ ].map(([resourceAddress, symbol]) => (
+
+ ))}
+
+
+
+ {props.title || "Mint Utility"}
+
+
+
+ {[
+ [bootstrapInformation.protocol.protocol_resource, "XRD"],
+ ...Object.entries(bootstrapInformation.resources).map(
+ ([address, information]) => [address, information.symbol],
+ ),
+ ].map(([resourceAddress, symbol]) => (
+
+ ))}
+
+
+
+ {props.title || "Provide Liquidity"}
+
+
+
+
+
+ Exchange
+
+
+ User Resource
+
+
+ Lockup Period
+
+
+ Amount
+
+
+
+
+
+ {
+ const selectedValue = event.target.value;
+ const evaluatedValue =
+ selectedValue === "none" ? undefined : selectedValue;
+
+ // Set the state
+ setOpenLiquidityPositionData({
+ ...openLiquidityPositionData,
+ exchange: evaluatedValue,
+ });
+
+ // Fire an event
+ if (props.onExchangeChange !== undefined) {
+ props.onExchangeChange(evaluatedValue);
+ }
+ }}
+ >
+
+ {Object.entries(SUPPORTED_EXCHANGES).map(
+ ([logicalName, physicalName]) => {
+ return (
+
+ );
+ },
+ )}
+
+
+
+ {
+ const selectedValue = event.target.value;
+ const evaluatedValue =
+ selectedValue === "none" ? undefined : selectedValue;
+
+ // Set the state
+ setOpenLiquidityPositionData({
+ ...openLiquidityPositionData,
+ resourceAddress: evaluatedValue,
+ });
+
+ // Fire an event
+ if (props.onUserResourceChange !== undefined) {
+ props.onUserResourceChange(evaluatedValue);
+ }
+ }}
+ >
+
+ {Object.entries(bootstrapInformation?.resources || {}).map(
+ ([address, information]) => {
+ return (
+
+ );
+ },
+ )}
+
+
+
+ {
+ const selectedValue = event.target.value;
+ const evaluatedValue =
+ selectedValue === "none" ? undefined : selectedValue;
+
+ // Set the state
+ setOpenLiquidityPositionData({
+ ...openLiquidityPositionData,
+ lockupPeriodSeconds: evaluatedValue,
+ });
+
+ // Fire an event
+ if (props.onUserResourceChange !== undefined) {
+ props.onUserResourceChange(evaluatedValue);
+ }
+ }}
+ >
+
+ {Object.entries(
+ bootstrapInformation?.protocol.reward_rates || {},
+ ).map(([periodInSeconds, percentage]) => {
+ return (
+
+ );
+ })}
+
+
+
+
+ {
+ // Remove anything that is not a number
+ let numbers = Array.from({ length: 10 }, (_, i) =>
+ i.toString(),
+ );
+ let string = Array.from(event.target.value).filter((char) =>
+ numbers.includes(char),
+ );
+
+ // Add the comma separator
+ const evaluatedValue = string.join("");
+ event.target.value = evaluatedValue
+ .toString()
+ .replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+
+ // Set the state
+ setOpenLiquidityPositionData({
+ ...openLiquidityPositionData,
+ amount: evaluatedValue,
+ });
+
+ // Fire an event
+ if (props.onAmountChange !== undefined) {
+ props.onAmountChange(evaluatedValue);
+ }
+ }}
+ />
+
+
+
+
+
+
+
+
+ );
+};
+
+interface Props {
+ title?: string;
+ style?: React.CSSProperties;
+ /* Callbacks */
+ onExchangeChange?: (newExchange?: string) => void;
+ onUserResourceChange?: (newResourceAddress?: string) => void;
+ onAmountChange?: (newAmount?: string) => void;
+ /* Last Tx */
+ lastTx: string | null;
+ setLastTx: Dispatch>;
+}
+
+const constructManifest = (
+ ignitionAddress: string,
+ connectedAccount: string,
+ selections: {
+ pool: string;
+ resourceAddress: string;
+ amount: string;
+ lockupPeriodInSeconds: string;
+ },
+): string => {
+ return `
+ MINT_FUNGIBLE
+ Address("${selections.resourceAddress}")
+ Decimal("${selections.amount}")
+ ;
+
+ TAKE_FROM_WORKTOP
+ Address("${selections.resourceAddress}")
+ Decimal("${selections.amount}")
+ Bucket("bucket")
+ ;
+
+ CALL_METHOD
+ Address("${ignitionAddress}")
+ "open_liquidity_position"
+ Bucket("bucket")
+ Address("${selections.pool}")
+ ${selections.lockupPeriodInSeconds}u64
+ ;
+
+ CALL_METHOD
+ Address("${connectedAccount}")
+ "try_deposit_batch_or_abort"
+ Expression("ENTIRE_WORKTOP")
+ None
+ ;
+ `;
+};
+
+const constructAndSendManifestToWallet = (
+ dAppToolkit: RadixDappToolkit,
+ ignitionAddress: string,
+ connectedAccount: string,
+ selections: {
+ pool: string;
+ resourceAddress: string;
+ amount: string;
+ lockupPeriodInSeconds: string;
+ },
+ setLastTxHash: Dispatch>,
+) => {
+ const manifest = constructManifest(
+ ignitionAddress,
+ connectedAccount,
+ selections,
+ );
+ console.log(manifest);
+ dAppToolkit.walletApi
+ .sendTransaction({ transactionManifest: manifest })
+ .map((item) => item.transactionIntentHash)
+ .map(setLastTxHash);
+};
+
+const highLevelConstructAndSendManifestToWallet = (
+ dAppToolkit: RadixDappToolkit | undefined,
+ bootstrapInformation: TestingBootstrapInformation | null,
+ connectedAccount: ConnectedAccount,
+ selectedInformation: OpenLiquidityPositionData,
+ setLastTxHash: Dispatch>,
+) => {
+ if (
+ selectedInformation.amount !== undefined &&
+ selectedInformation.exchange !== undefined &&
+ selectedInformation.resourceAddress !== undefined &&
+ selectedInformation.lockupPeriodSeconds !== undefined &&
+ bootstrapInformation !== null &&
+ dAppToolkit !== undefined &&
+ connectedAccount.status === "success"
+ ) {
+ const exchangePhysicalName =
+ selectedInformation.exchange as keyof TestingBootstrapInformation;
+
+ const exchangeEntries = bootstrapInformation[
+ exchangePhysicalName
+ ] as DexEntities;
+
+ const ignitionAddress = bootstrapInformation.protocol.ignition;
+ const account = connectedAccount.account;
+
+ const poolAddress =
+ exchangeEntries.pools[selectedInformation.resourceAddress];
+
+ constructAndSendManifestToWallet(
+ dAppToolkit,
+ ignitionAddress,
+ account,
+ {
+ pool: poolAddress,
+ resourceAddress: selectedInformation.resourceAddress,
+ amount: selectedInformation.amount,
+ lockupPeriodInSeconds: selectedInformation.lockupPeriodSeconds,
+ },
+ setLastTxHash,
+ );
+ } else {
+ console.error(
+ "Something was undefined when attempting to construct and send the transaction",
+ );
+ }
+};
diff --git a/frontend/src/config.json b/frontend/src/config.json
new file mode 100644
index 00000000..bb67e984
--- /dev/null
+++ b/frontend/src/config.json
@@ -0,0 +1,65 @@
+{
+ "network_id": 1,
+ "resources": {
+ "resource_rdx1tkafx32lu72mcxr85gjx0rh3rx9q89zqffg4phmv5rxdqg5fnd0w7s": {
+ "divisibility": 6,
+ "name": "USDT",
+ "symbol": "USDT",
+ "icon_url": "https://assets.instabridge.io/tokens/icons/xUSDT.png"
+ },
+ "resource_rdx1tkscrlztcyn82ej5z3n232f0qqp0qur69arjf279ppmg5usa3xhnsm": {
+ "divisibility": 18,
+ "name": "Ethereum",
+ "symbol": "ETH",
+ "icon_url": "https://assets.instabridge.io/tokens/icons/xETH.png"
+ },
+ "resource_rdx1th7nx2hy0cf6aea6mz7zhkdmy4p45s488xutltnp7296zxj8hwchpf": {
+ "divisibility": 6,
+ "name": "USDC",
+ "symbol": "USDC",
+ "icon_url": "https://assets.instabridge.io/tokens/icons/xUSDC.png"
+ },
+ "resource_rdx1t58dla7ykxzxe5es89wlhgzatqla0gceukg0eeduzvtj4cxd55etn8": {
+ "divisibility": 6,
+ "name": "Bitcoin",
+ "symbol": "BTC",
+ "icon_url": "https://assets.instabridge.io/tokens/icons/xwBTC.png"
+ }
+ },
+ "protocol": {
+ "ignition_package_address": "package_rdx1pha09dtl3zmp4cjeurttsx52k3d2f2wu5nxlpdvvsupzsj3ekh04rp",
+ "ignition": "component_rdx1czwd54pv35dx8cgrt5p2gn52ryd98keep7slghhvwv2et5y79ml6uw",
+ "protocol_resource": "resource_rdx1t4dekrf58h0r28s3c93z92w3jt5ngx87jzd63mgc597zmf3534rxfv",
+ "oracle_package_address": "package_rdx1pkuzv0njgy4w30hyq8z8cs4t4mknx7flf0lv52gp56y93fyzkymy8n",
+ "oracle": "component_rdx1cq8k08lfvwfwd3qfmpfj6w6e2z2y9m9y72zyujrnxycg7885xnk8tc",
+ "dapp_definition": "account_rdx1cx9gtftg0lylun6jxglkgd0c9qnwe2j3p0kfg5us747nyfplzdz439",
+ "reward_rates": {
+ "0": "0.125",
+ "60": "0.15"
+ }
+ },
+ "caviarnine": {
+ "package": "package_rdx1p4r9rkp0cq67wmlve544zgy0l45mswn6h798qdqm47x4762h383wa3",
+ "pools": {
+ "resource_rdx1tkafx32lu72mcxr85gjx0rh3rx9q89zqffg4phmv5rxdqg5fnd0w7s": "component_rdx1cqfszkwhtxm2wwl9puae9n833j8c5hrp9tasw9escun2nvkptj7ggz",
+ "resource_rdx1tkscrlztcyn82ej5z3n232f0qqp0qur69arjf279ppmg5usa3xhnsm": "component_rdx1cr7scefltr6y9ljknuctd9j2qdc9k53063p635xwlrk50msfksna6m",
+ "resource_rdx1th7nx2hy0cf6aea6mz7zhkdmy4p45s488xutltnp7296zxj8hwchpf": "component_rdx1cpl4pf7sh766cnd6wjcwkc6tx54ze3qy4jf50d22wc2nuz54zzpa0q",
+ "resource_rdx1t58dla7ykxzxe5es89wlhgzatqla0gceukg0eeduzvtj4cxd55etn8": "component_rdx1crx32l52mep7j7jyljv2j9nfp983yakvm6qcydc7zwrp7tzlxdfkvk"
+ },
+ "adapter_package": "package_rdx1p5dve4800m3tx65ns2qvqr4plgrjc5gkucwuwl62ezewtjz443xn6r",
+ "adapter": "component_rdx1cqddn4r9asgz36z27wzfd9848erm8cdh8j6j5t03clgl8ec59e0kez",
+ "receipt_resource": "resource_rdx1n2t8c52rdraa3wcehpckp8k9katl098gmrcyr59u7txv5t68w804cq"
+ },
+ "ociswap": {
+ "package": "package_rdx1p5l6dp3slnh9ycd7gk700czwlck9tujn0zpdnd0efw09n2zdnn0lzx",
+ "pools": {
+ "resource_rdx1tkafx32lu72mcxr85gjx0rh3rx9q89zqffg4phmv5rxdqg5fnd0w7s": "component_rdx1cq96chge0q6kkk962heg0mgfl82gjw7x25dp9jv80gkx90mc3hk2ua",
+ "resource_rdx1tkscrlztcyn82ej5z3n232f0qqp0qur69arjf279ppmg5usa3xhnsm": "component_rdx1cqylpcl8p45l2h5ew0qrkwyz23dky3e6ucs7kkhrtm90k9z3kzeztn",
+ "resource_rdx1th7nx2hy0cf6aea6mz7zhkdmy4p45s488xutltnp7296zxj8hwchpf": "component_rdx1cz3fa8qtfgfwjt3fzrtm544a89p5laerww7590g2tfcradqwdv3laq",
+ "resource_rdx1t58dla7ykxzxe5es89wlhgzatqla0gceukg0eeduzvtj4cxd55etn8": "component_rdx1cr5uxxjq4a0r3gfn6yd62lk96fqca34tnmyqdxkwefhckcjea4t3am"
+ },
+ "adapter_package": "package_rdx1p5ds7ljdf26zdg6dsve764ksdz58ydegwjd24djcz034eepqrl7p8q",
+ "adapter": "component_rdx1czgd9jpdkaac6xwq6t5dc0hzvhggme4ahxeedma6p98ma3ylr7arz6",
+ "receipt_resource": "resource_rdx1n2n52tx9y2phac6tyfjncksmh6hpujgztunxrxyh8y92frzf8duzr2"
+ }
+}
\ No newline at end of file
diff --git a/frontend/src/constants.ts b/frontend/src/constants.ts
new file mode 100644
index 00000000..5f2ce5eb
--- /dev/null
+++ b/frontend/src/constants.ts
@@ -0,0 +1,5 @@
+/// Logical Name => Physical Name
+export const SUPPORTED_EXCHANGES: Record = {
+ Caviarnine: "caviarnine",
+ Ociswap: "ociswap",
+};
\ No newline at end of file
diff --git a/frontend/src/hooks/ConnectedAccounts.ts b/frontend/src/hooks/ConnectedAccounts.ts
new file mode 100644
index 00000000..bb4d4aa1
--- /dev/null
+++ b/frontend/src/hooks/ConnectedAccounts.ts
@@ -0,0 +1,33 @@
+import { useState, useEffect } from 'react';
+import { switchMap, map } from 'rxjs'
+import { dAppToolkit } from '../RadixDappToolkit';
+
+export const useConnectedAccounts = () => {
+ const [state, setState] = useState({ status: 'pending' })
+
+ useEffect(() => {
+ const subscription = dAppToolkit.walletApi.walletData$
+ .pipe(
+ map((walletData) => walletData.accounts),
+ switchMap((accounts) => {
+ if (accounts?.[0]?.address !== undefined) {
+ setState({ status: 'success', account: accounts?.[0]?.address })
+ }
+
+ return accounts
+ })
+ )
+ .subscribe()
+
+ return () => {
+ subscription.unsubscribe()
+ }
+ }, [dAppToolkit])
+
+ return state
+}
+
+export type ConnectedAccount =
+ { status: 'success', account: string }
+ | { status: 'pending' }
+ | { status: 'error' }
diff --git a/frontend/src/hooks/LastTransactionHash.ts b/frontend/src/hooks/LastTransactionHash.ts
new file mode 100644
index 00000000..4f577ffb
--- /dev/null
+++ b/frontend/src/hooks/LastTransactionHash.ts
@@ -0,0 +1,5 @@
+import { useState } from "react"
+
+export const useLastTransactionHash = () => {
+ return useState(null);
+}
\ No newline at end of file
diff --git a/frontend/src/hooks/OpenLiquidityPositionData.ts b/frontend/src/hooks/OpenLiquidityPositionData.ts
new file mode 100644
index 00000000..8a5a8ae6
--- /dev/null
+++ b/frontend/src/hooks/OpenLiquidityPositionData.ts
@@ -0,0 +1,17 @@
+import { useState } from "react";
+
+export const useOpenLiquidityPositionData = () => {
+ return useState({
+ exchange: undefined,
+ resourceAddress: undefined,
+ amount: undefined,
+ lockupPeriodSeconds: undefined
+ });
+};
+
+export interface OpenLiquidityPositionData {
+ exchange: string | undefined;
+ resourceAddress: string | undefined;
+ amount: string | undefined;
+ lockupPeriodSeconds: string | undefined
+}
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 00000000..f62968f0
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1,31 @@
+body {
+ margin: 0;
+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
+ "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
+ sans-serif;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+ font-family: "Iosevka", source-code-pro, Menlo, Monaco, Consolas,
+ "Courier New", monospace;
+}
+
+.iosevka {
+ font-family: "Iosevka";
+}
+
+.ibm-plex-sans {
+ font-family: "Ibm Plex Sans";
+}
+
+#ignition-root {
+ background-color: white;
+ height: 100vh;
+ width: 100vw;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ flex-direction: column;
+}
diff --git a/frontend/src/index.tsx b/frontend/src/index.tsx
new file mode 100644
index 00000000..ccbac81f
--- /dev/null
+++ b/frontend/src/index.tsx
@@ -0,0 +1,19 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import "./index.css";
+import App from "./App";
+import reportWebVitals from "./reportWebVitals";
+
+const root = ReactDOM.createRoot(
+ document.getElementById("root") as HTMLElement
+);
+root.render(
+
+
+
+);
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();
diff --git a/frontend/src/logo.svg b/frontend/src/logo.svg
new file mode 100644
index 00000000..9dfc1c05
--- /dev/null
+++ b/frontend/src/logo.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/frontend/src/react-app-env.d.ts b/frontend/src/react-app-env.d.ts
new file mode 100644
index 00000000..6431bc5f
--- /dev/null
+++ b/frontend/src/react-app-env.d.ts
@@ -0,0 +1 @@
+///
diff --git a/frontend/src/reportWebVitals.ts b/frontend/src/reportWebVitals.ts
new file mode 100644
index 00000000..5fa3583b
--- /dev/null
+++ b/frontend/src/reportWebVitals.ts
@@ -0,0 +1,15 @@
+import { ReportHandler } from "web-vitals";
+
+const reportWebVitals = (onPerfEntry?: ReportHandler) => {
+ if (onPerfEntry && onPerfEntry instanceof Function) {
+ import("web-vitals").then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
+ getCLS(onPerfEntry);
+ getFID(onPerfEntry);
+ getFCP(onPerfEntry);
+ getLCP(onPerfEntry);
+ getTTFB(onPerfEntry);
+ });
+ }
+};
+
+export default reportWebVitals;
diff --git a/frontend/src/setupTests.ts b/frontend/src/setupTests.ts
new file mode 100644
index 00000000..1dd407a6
--- /dev/null
+++ b/frontend/src/setupTests.ts
@@ -0,0 +1,5 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import "@testing-library/jest-dom";
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
new file mode 100644
index 00000000..9d379a3c
--- /dev/null
+++ b/frontend/tsconfig.json
@@ -0,0 +1,20 @@
+{
+ "compilerOptions": {
+ "target": "es5",
+ "lib": ["dom", "dom.iterable", "esnext"],
+ "allowJs": true,
+ "skipLibCheck": true,
+ "esModuleInterop": true,
+ "allowSyntheticDefaultImports": true,
+ "strict": true,
+ "forceConsistentCasingInFileNames": true,
+ "noFallthroughCasesInSwitch": true,
+ "module": "esnext",
+ "moduleResolution": "node",
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "jsx": "react-jsx"
+ },
+ "include": ["src"]
+}
diff --git a/libraries/common/Cargo.toml b/libraries/common/Cargo.toml
new file mode 100644
index 00000000..3140d6bf
--- /dev/null
+++ b/libraries/common/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "common"
+version.workspace = true
+edition.workspace = true
+description = "A crate that defines types used by the other crates."
+
+[dependencies]
+sbor = { workspace = true }
+scrypto = { workspace = true }
+transaction = { workspace = true, optional = true }
+radix-engine-common = { workspace = true }
+radix-engine-derive = { workspace = true }
+radix-engine-interface = { workspace = true }
+
+# Used to print the lockup period in a readable format.
+humantime = { version = "2.1.0" }
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
\ No newline at end of file
diff --git a/libraries/common/src/any_value.rs b/libraries/common/src/any_value.rs
new file mode 100644
index 00000000..2c8e5997
--- /dev/null
+++ b/libraries/common/src/any_value.rs
@@ -0,0 +1,61 @@
+use radix_engine_interface::prelude::*;
+
+#[derive(Clone, Debug, ScryptoSbor, PartialEq, Eq)]
+#[sbor(transparent)]
+pub struct AnyValue((ScryptoValue,));
+
+impl AnyValue {
+ pub fn from_typed(typed: &T) -> Result
+ where
+ T: ScryptoEncode,
+ {
+ scrypto_encode(typed)
+ .map_err(Into::into)
+ .and_then(|value| scrypto_decode(&value).map_err(Into::into))
+ .map(|value| Self((value,)))
+ }
+
+ pub fn as_typed(&self) -> Result
+ where
+ T: ScryptoDecode,
+ {
+ scrypto_encode(&self.0 .0)
+ .map_err(Into::into)
+ .and_then(|value| scrypto_decode(&value).map_err(Into::into))
+ }
+}
+
+#[derive(Clone, Debug)]
+pub enum AnyValueError {
+ EncodeError(EncodeError),
+ DecodeError(DecodeError),
+}
+
+impl From for AnyValueError {
+ fn from(value: EncodeError) -> Self {
+ Self::EncodeError(value)
+ }
+}
+
+impl From for AnyValueError {
+ fn from(value: DecodeError) -> Self {
+ Self::DecodeError(value)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::AnyValue;
+
+ #[test]
+ fn simple_roundtrip_test() {
+ // Arrange
+ let value = 12;
+
+ // Act
+ let any_value = AnyValue::from_typed(&value).unwrap();
+
+ // Assert
+ assert_eq!(any_value.as_typed::().unwrap(), value)
+ }
+}
diff --git a/libraries/common/src/lib.rs b/libraries/common/src/lib.rs
new file mode 100644
index 00000000..2965da90
--- /dev/null
+++ b/libraries/common/src/lib.rs
@@ -0,0 +1,7 @@
+mod any_value;
+mod liquidity_receipt;
+mod lockup_period;
+mod price;
+mod volatility;
+
+pub mod prelude;
diff --git a/libraries/common/src/liquidity_receipt.rs b/libraries/common/src/liquidity_receipt.rs
new file mode 100644
index 00000000..5994503e
--- /dev/null
+++ b/libraries/common/src/liquidity_receipt.rs
@@ -0,0 +1,79 @@
+use crate::prelude::*;
+use scrypto::prelude::*;
+
+/// The data of the liquidity positions given to the users of Ignition.
+#[derive(ScryptoSbor, Clone, Debug, PartialEq, Eq, NonFungibleData)]
+pub struct LiquidityReceipt
+where
+ T: ScryptoSbor,
+{
+ /* Metadata/NonFungibleData standard */
+ pub name: String,
+
+ /* Display Data - Just for wallet display, no logic depends on this. */
+ /// A string of the lockup period of the liquidity provided through the
+ /// protocol (e.g., "6 Months").
+ pub lockup_period: String,
+
+ /* Application data */
+ /// The pool that the resources were contributed to.
+ pub pool_address: ComponentAddress,
+
+ /// The address of the resource that the user contributed through the
+ /// protocol.
+ pub user_resource_address: ResourceAddress,
+
+ /// The amount of the resource that the user contributed through the
+ /// protocol.
+ pub user_contribution_amount: Decimal,
+
+ /// The volatility classification of the user resource at the time when the
+ /// liquidity position was opened. This will be used to later deposit any
+ /// protocol assets back into the same vault.
+ pub user_resource_volatility_classification: Volatility,
+
+ /// The amount of XRD that was contributed by the Ignition protocol to
+ /// match the users contribution.
+ pub protocol_contribution_amount: Decimal,
+
+ /// The date after which this liquidity position can be closed.
+ pub maturity_date: Instant,
+
+ /// This is adapter specific data passed by the adapter when a position is
+ /// opened. This is information that the adapter expects to be passed back
+ /// when a liquidity position is closed. This is used in calculating the
+ /// fees.
+ pub adapter_specific_information: T,
+}
+
+impl LiquidityReceipt
+where
+ T: ScryptoSbor,
+{
+ pub fn new(
+ lockup_period: LockupPeriod,
+ pool_address: ComponentAddress,
+ user_resource_address: ResourceAddress,
+ user_contribution_amount: Decimal,
+ user_volatility_classification: Volatility,
+ protocol_contribution_amount: Decimal,
+ adapter_specific_information: T,
+ ) -> Self {
+ let maturity_date = Clock::current_time_rounded_to_minutes()
+ .add_seconds(*lockup_period.seconds() as i64)
+ .unwrap();
+
+ Self {
+ name: "Liquidity Contribution".to_owned(),
+ lockup_period: lockup_period.to_string(),
+ pool_address,
+ user_resource_address,
+ user_contribution_amount,
+ maturity_date,
+ protocol_contribution_amount,
+ user_resource_volatility_classification:
+ user_volatility_classification,
+ adapter_specific_information,
+ }
+ }
+}
diff --git a/libraries/common/src/lockup_period.rs b/libraries/common/src/lockup_period.rs
new file mode 100644
index 00000000..e8a2e54c
--- /dev/null
+++ b/libraries/common/src/lockup_period.rs
@@ -0,0 +1,81 @@
+use scrypto::prelude::*;
+use std::ops::*;
+
+use humantime::format_duration;
+
+/// A type used for the lockup period that can be creates from various time
+/// durations and that implements display in the desired way.
+#[derive(Clone, Copy, Sbor, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[sbor(transparent)]
+pub struct LockupPeriod(u64);
+
+impl LockupPeriod {
+ pub const fn from_seconds(seconds: u64) -> Self {
+ Self(seconds)
+ }
+
+ pub const fn from_minutes(minutes: u64) -> Option {
+ let value = minutes.checked_mul(60);
+ match value {
+ Some(value) => Some(Self::from_seconds(value)),
+ None => None,
+ }
+ }
+
+ pub const fn from_hours(hours: u64) -> Option {
+ let value = hours.checked_mul(60);
+ match value {
+ Some(value) => Self::from_minutes(value),
+ None => None,
+ }
+ }
+
+ pub const fn from_days(days: u64) -> Option {
+ let value = days.checked_mul(24);
+ match value {
+ Some(value) => Self::from_hours(value),
+ None => None,
+ }
+ }
+
+ pub const fn from_weeks(weeks: u64) -> Option {
+ let value = weeks.checked_mul(7);
+ match value {
+ Some(value) => Self::from_days(value),
+ None => None,
+ }
+ }
+
+ // One month approx 30.44 days
+ pub const fn from_months(months: u64) -> Option {
+ let value = months.checked_mul(2_630_016);
+ match value {
+ Some(value) => Some(Self::from_seconds(value)),
+ None => None,
+ }
+ }
+
+ pub const fn seconds(&self) -> &u64 {
+ &self.0
+ }
+}
+
+impl Display for LockupPeriod {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ Display::fmt(&format_duration(std::time::Duration::new(self.0, 0)), f)
+ }
+}
+
+impl Debug for LockupPeriod {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{} seconds", self.0)
+ }
+}
+
+impl Deref for LockupPeriod {
+ type Target = u64;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
diff --git a/libraries/common/src/prelude.rs b/libraries/common/src/prelude.rs
new file mode 100644
index 00000000..d9383b20
--- /dev/null
+++ b/libraries/common/src/prelude.rs
@@ -0,0 +1,5 @@
+pub use crate::any_value::*;
+pub use crate::liquidity_receipt::*;
+pub use crate::lockup_period::*;
+pub use crate::price::*;
+pub use crate::volatility::*;
diff --git a/libraries/common/src/price.rs b/libraries/common/src/price.rs
new file mode 100644
index 00000000..18e9c38f
--- /dev/null
+++ b/libraries/common/src/price.rs
@@ -0,0 +1,234 @@
+use radix_engine_derive::*;
+use scrypto::prelude::*;
+
+/// A price type representing the price in terms of some base and quote assets.
+///
+/// The information of the base and quote assets is captured by this type to
+/// make certain calculations easier and to also allow for some checks to make
+/// sure that an incorrect price is not used for calculations.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, ScryptoSbor)]
+pub struct Price {
+ pub base: ResourceAddress,
+ pub quote: ResourceAddress,
+ pub price: Decimal,
+}
+
+impl Price {
+ /// Computes the difference ratio between `self` and `other`.
+ ///
+ /// Attempts to compute the difference ratio between the two prices: `self`
+ /// and `other`. If the base and the quote are different then a inverse of
+ /// the price is used to calculate the difference. A [`None`] is returned if
+ /// `other` has a base or quote resource address that is neither the base
+ /// nor the quote of `self`.
+ ///
+ /// The equation used for the ratio calculation is obtained from this
+ /// [article] can is provided below:
+ ///
+ /// ```math
+ /// ratio = |other.price - self.price| / self.price
+ /// ```
+ ///
+ /// # Arguments
+ ///
+ /// * `other`: [`&Self`] - A reference to another [`Price`] object to
+ /// compute the difference ratio between.
+ ///
+ /// # Returns:
+ ///
+ /// [`Option`] - An optional [`Decimal`] value is returned which is
+ /// in the range [0, ∞] which is of the difference ratio and not percentage
+ /// and thus, it is not multiplied by 100. This means that a return of 0
+ /// indicates no difference, a return of 1 indicated 100% difference, and
+ /// so on. If [`None`] is returned then these two prices where of two
+ /// different pairs.
+ ///
+ /// [article]: https://en.wikipedia.org/wiki/Relative_change
+ pub fn relative_difference(&self, other: &Self) -> Option {
+ if self.base == other.base && self.quote == other.quote {
+ other
+ .price
+ .checked_sub(self.price)
+ .and_then(|value| value.checked_abs())
+ .and_then(|value| value.checked_div(self.price))
+ } else if self.base == other.quote && self.quote == other.base {
+ self.relative_difference(&other.inverse())
+ } else {
+ None
+ }
+ }
+
+ /// Computes the output amount based on some input amount.
+ ///
+ /// This method calculates the output if an exchange happens at this price
+ /// where the output has a [`ResourceAddress`] to make it clear what unit
+ /// the output is in. If a resource that is neither the base nor the quote
+ /// is passed then [`None`] is returned.
+ ///
+ /// In a price that is BASE/QUOTE the unit is QUOTE/BASE. Therefore, if the
+ /// base tokens are passed, their amount is multiplied by the price and then
+ /// returned. If the quote tokens are passed, the inverse of the price is
+ /// multiplied by the passed amount. Otherwise, the resource does not belong
+ /// to this price.
+ ///
+ /// # Arguments
+ ///
+ /// `resource_address`: [`ResourceAddress`] - The address of the input
+ /// resources.
+ /// `amount`: [`Decimal`] - The amount of the input resources.
+ ///
+ /// # Returns
+ ///
+ /// [`Option<(ResourceAddress, Decimal)>`] - The address and amount of the
+ /// output if the input resource is either the base or the quote asset. Else
+ /// this is [`None`].
+ pub fn exchange(
+ &self,
+ resource_address: ResourceAddress,
+ amount: Decimal,
+ ) -> Option<(ResourceAddress, Decimal)> {
+ if resource_address == self.base {
+ Some((self.quote, self.price.checked_mul(amount)?))
+ } else if resource_address == self.quote {
+ Some((self.base, amount.checked_div(self.price)?))
+ } else {
+ None
+ }
+ }
+
+ /// Computes the inverse of the address.
+ ///
+ /// This method computes the price's inverse by exchanging the base with
+ /// the quote and diving 1 by the price.
+ ///
+ /// # Returns
+ ///
+ /// [`Price`] - The inverse of the price.
+ pub fn inverse(&self) -> Price {
+ Price {
+ base: self.quote,
+ quote: self.base,
+ // Panics if price is zero.
+ price: dec!(1).checked_div(self.price).unwrap(),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ const BITCOIN: ResourceAddress = ResourceAddress::new_or_panic([
+ 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1,
+ ]);
+ const USD: ResourceAddress = ResourceAddress::new_or_panic([
+ 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 2,
+ ]);
+
+ #[test]
+ fn percentage_difference_with_opposite_base_and_quote_is_calculated_correctly(
+ ) {
+ // Arrange
+ let p1 = Price {
+ base: BITCOIN,
+ quote: USD,
+ price: dec!(100),
+ };
+ let p2 = Price {
+ base: USD,
+ quote: BITCOIN,
+ price: dec!(1) / dec!(100),
+ };
+
+ // Act
+ let difference = p1.relative_difference(&p2).unwrap();
+
+ // Assert
+ assert_eq!(difference, dec!(0))
+ }
+
+ #[test]
+ fn simple_percentage_difference_is_calculated_correctly() {
+ // Arrange
+ let p1 = Price {
+ base: BITCOIN,
+ quote: USD,
+ price: dec!(100),
+ };
+ let p2 = Price {
+ base: BITCOIN,
+ quote: USD,
+ price: dec!(50),
+ };
+
+ // Act
+ let difference = p1.relative_difference(&p2).unwrap();
+
+ // Assert
+ assert_eq!(difference, dec!(0.5))
+ }
+
+ #[test]
+ fn exchange_method_calculates_as_expected1() {
+ // Arrange
+ let btc = BITCOIN;
+ let usd = USD;
+
+ let price = Price {
+ base: btc,
+ quote: usd,
+ price: dec!(43000),
+ };
+
+ // Act
+ let (out_address, out_amount) = price.exchange(btc, dec!(1)).unwrap();
+
+ // Assert
+ assert_eq!(out_address, usd);
+ assert_eq!(out_amount, dec!(43000));
+ }
+
+ #[test]
+ fn exchange_method_calculates_as_expected2() {
+ // Arrange
+ let btc = BITCOIN;
+ let usd = USD;
+
+ let price = Price {
+ base: btc,
+ quote: usd,
+ price: dec!(43000),
+ };
+
+ // Act
+ let (out_address, out_amount) =
+ price.exchange(usd, dec!(43000)).unwrap();
+
+ // Assert
+ assert_eq!(out_address, btc);
+ assert_eq!(out_amount, dec!(1));
+ }
+
+ #[test]
+ fn price_inverse_is_what_we_expect_it_to_be() {
+ // Arrange
+ let btc = BITCOIN;
+ let usd = USD;
+
+ let price = Price {
+ base: btc,
+ quote: usd,
+ price: dec!(2),
+ };
+
+ // Act
+ let inverse = price.inverse();
+
+ // Assert
+ assert_eq!(inverse.base, price.quote);
+ assert_eq!(inverse.quote, price.base);
+ assert_eq!(inverse.price, dec!(1) / price.price);
+ }
+}
diff --git a/libraries/common/src/volatility.rs b/libraries/common/src/volatility.rs
new file mode 100644
index 00000000..b022ee3c
--- /dev/null
+++ b/libraries/common/src/volatility.rs
@@ -0,0 +1,8 @@
+use scrypto::prelude::*;
+
+/// An enum that describes the volatility of an asset.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, ScryptoSbor, ManifestSbor)]
+pub enum Volatility {
+ Volatile,
+ NonVolatile,
+}
diff --git a/libraries/gateway-client/Cargo.toml b/libraries/gateway-client/Cargo.toml
new file mode 100644
index 00000000..38eb1630
--- /dev/null
+++ b/libraries/gateway-client/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "gateway-client"
+description = "An auto-generated gateway client used by the various Ignition tools."
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+serde = { version = "1.0.195", features = ["derive"] }
+serde_with = { version = "3.5.1", features = ["hex"] }
+serde_json = { version = "1.0.111" }
+url = { version = "2.5.0" }
+uuid = { version = "1.7.0", features = ["serde", "v4"] }
+reqwest = { version = "0.11.23", features = ["json", "blocking", "multipart"] }
+
+[lints]
+workspace = true
\ No newline at end of file
diff --git a/libraries/gateway-client/src/apis/configuration.rs b/libraries/gateway-client/src/apis/configuration.rs
new file mode 100644
index 00000000..9e0df6d2
--- /dev/null
+++ b/libraries/gateway-client/src/apis/configuration.rs
@@ -0,0 +1,38 @@
+#[derive(Debug, Clone)]
+pub struct Configuration {
+ pub base_path: String,
+ pub user_agent: Option,
+ pub client: reqwest::blocking::Client,
+ pub basic_auth: Option,
+ pub oauth_access_token: Option,
+ pub bearer_access_token: Option,
+ pub api_key: Option,
+}
+
+pub type BasicAuth = (String, Option);
+
+#[derive(Debug, Clone)]
+pub struct ApiKey {
+ pub prefix: Option,
+ pub key: String,
+}
+
+impl Configuration {
+ pub fn new() -> Configuration {
+ Configuration::default()
+ }
+}
+
+impl Default for Configuration {
+ fn default() -> Self {
+ Configuration {
+ base_path: "http://localhost".to_owned(),
+ user_agent: Some("OpenAPI-Generator/v1.2.2/rust".to_owned()),
+ client: reqwest::blocking::Client::new(),
+ basic_auth: None,
+ oauth_access_token: None,
+ bearer_access_token: None,
+ api_key: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/apis/mod.rs b/libraries/gateway-client/src/apis/mod.rs
new file mode 100644
index 00000000..a9ebf3e9
--- /dev/null
+++ b/libraries/gateway-client/src/apis/mod.rs
@@ -0,0 +1,109 @@
+use std::error;
+use std::fmt;
+
+#[derive(Debug, Clone)]
+pub struct ResponseContent {
+ pub status: reqwest::StatusCode,
+ pub content: String,
+ pub entity: Option,
+}
+
+#[derive(Debug)]
+pub enum Error {
+ Reqwest(reqwest::Error),
+ Serde(serde_json::Error),
+ Io(std::io::Error),
+ ResponseError(ResponseContent),
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let (module, e) = match self {
+ Error::Reqwest(e) => ("reqwest", e.to_string()),
+ Error::Serde(e) => ("serde", e.to_string()),
+ Error::Io(e) => ("IO", e.to_string()),
+ Error::ResponseError(e) => {
+ ("response", format!("status code {}", e.status))
+ }
+ };
+ write!(f, "error in {}: {}", module, e)
+ }
+}
+
+impl error::Error for Error {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ Some(match self {
+ Error::Reqwest(e) => e,
+ Error::Serde(e) => e,
+ Error::Io(e) => e,
+ Error::ResponseError(_) => return None,
+ })
+ }
+}
+
+impl From for Error {
+ fn from(e: reqwest::Error) -> Self {
+ Error::Reqwest(e)
+ }
+}
+
+impl From for Error {
+ fn from(e: serde_json::Error) -> Self {
+ Error::Serde(e)
+ }
+}
+
+impl From for Error {
+ fn from(e: std::io::Error) -> Self {
+ Error::Io(e)
+ }
+}
+
+pub fn urlencode>(s: T) -> String {
+ ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
+}
+
+pub fn parse_deep_object(
+ prefix: &str,
+ value: &serde_json::Value,
+) -> Vec<(String, String)> {
+ if let serde_json::Value::Object(object) = value {
+ let mut params = vec![];
+
+ for (key, value) in object {
+ match value {
+ serde_json::Value::Object(_) => {
+ params.append(&mut parse_deep_object(
+ &format!("{}[{}]", prefix, key),
+ value,
+ ))
+ }
+ serde_json::Value::Array(array) => {
+ for (i, value) in array.iter().enumerate() {
+ params.append(&mut parse_deep_object(
+ &format!("{}[{}][{}]", prefix, key, i),
+ value,
+ ));
+ }
+ }
+ serde_json::Value::String(s) => {
+ params.push((format!("{}[{}]", prefix, key), s.clone()))
+ }
+ _ => params
+ .push((format!("{}[{}]", prefix, key), value.to_string())),
+ }
+ }
+
+ return params;
+ }
+
+ unimplemented!("Only objects are supported with style=deepObject")
+}
+
+pub mod state_api;
+pub mod statistics_api;
+pub mod status_api;
+pub mod stream_api;
+pub mod transaction_api;
+
+pub mod configuration;
diff --git a/libraries/gateway-client/src/apis/state_api.rs b/libraries/gateway-client/src/apis/state_api.rs
new file mode 100644
index 00000000..72ba9c7d
--- /dev/null
+++ b/libraries/gateway-client/src/apis/state_api.rs
@@ -0,0 +1,650 @@
+use reqwest;
+
+use super::{configuration, Error};
+use crate::apis::ResponseContent;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityFungibleResourceVaultPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityFungiblesPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityMetadataPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityNonFungibleIdsPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityNonFungibleResourceVaultPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum EntityNonFungiblesPageError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum KeyValueStoreDataError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum NonFungibleDataError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum NonFungibleIdsError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum NonFungibleLocationError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum StateEntityDetailsError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum StateValidatorsListError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+pub fn entity_fungible_resource_vault_page(
+ configuration: &configuration::Configuration,
+ state_entity_fungible_resource_vaults_page_request: crate::models::StateEntityFungibleResourceVaultsPageRequest,
+) -> Result<
+ crate::models::StateEntityFungibleResourceVaultsPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/fungible-vaults/",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder = local_var_req_builder
+ .json(&state_entity_fungible_resource_vaults_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn entity_fungibles_page(
+ configuration: &configuration::Configuration,
+ state_entity_fungibles_page_request: crate::models::StateEntityFungiblesPageRequest,
+) -> Result<
+ crate::models::StateEntityFungiblesPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/fungibles/",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_entity_fungibles_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn entity_metadata_page(
+ configuration: &configuration::Configuration,
+ state_entity_metadata_page_request: crate::models::StateEntityMetadataPageRequest,
+) -> Result<
+ crate::models::StateEntityMetadataPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/metadata",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_entity_metadata_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn entity_non_fungible_ids_page(
+ configuration: &configuration::Configuration,
+ state_entity_non_fungible_ids_page_request: crate::models::StateEntityNonFungibleIdsPageRequest,
+) -> Result<
+ crate::models::StateEntityNonFungibleIdsPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/non-fungible-vault/ids",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_entity_non_fungible_ids_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn entity_non_fungible_resource_vault_page(
+ configuration: &configuration::Configuration,
+ state_entity_non_fungible_resource_vaults_page_request: crate::models::StateEntityNonFungibleResourceVaultsPageRequest,
+) -> Result<
+ crate::models::StateEntityNonFungibleResourceVaultsPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/non-fungible-vaults/",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder = local_var_req_builder
+ .json(&state_entity_non_fungible_resource_vaults_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn entity_non_fungibles_page(
+ configuration: &configuration::Configuration,
+ state_entity_non_fungibles_page_request: crate::models::StateEntityNonFungiblesPageRequest,
+) -> Result<
+ crate::models::StateEntityNonFungiblesPageResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/entity/page/non-fungibles/",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_entity_non_fungibles_page_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn key_value_store_data(
+ configuration: &configuration::Configuration,
+ state_key_value_store_data_request: crate::models::StateKeyValueStoreDataRequest,
+) -> Result<
+ crate::models::StateKeyValueStoreDataResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/key-value-store/data",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_key_value_store_data_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn non_fungible_data(
+ configuration: &configuration::Configuration,
+ state_non_fungible_data_request: crate::models::StateNonFungibleDataRequest,
+) -> Result<
+ crate::models::StateNonFungibleDataResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/non-fungible/data",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_non_fungible_data_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn non_fungible_ids(
+ configuration: &configuration::Configuration,
+ state_non_fungible_ids_request: crate::models::StateNonFungibleIdsRequest,
+) -> Result<
+ crate::models::StateNonFungibleIdsResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/non-fungible/ids",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_non_fungible_ids_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn non_fungible_location(
+ configuration: &configuration::Configuration,
+ state_non_fungible_location_request: crate::models::StateNonFungibleLocationRequest,
+) -> Result<
+ crate::models::StateNonFungibleLocationResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/non-fungible/location",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_non_fungible_location_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn state_entity_details(
+ configuration: &configuration::Configuration,
+ state_entity_details_request: crate::models::StateEntityDetailsRequest,
+) -> Result<
+ crate::models::StateEntityDetailsResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str =
+ format!("{}/state/entity/details", local_var_configuration.base_path);
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_entity_details_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn state_validators_list(
+ configuration: &configuration::Configuration,
+ state_validators_list_request: crate::models::StateValidatorsListRequest,
+) -> Result<
+ crate::models::StateValidatorsListResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/state/validators/list",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&state_validators_list_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
diff --git a/libraries/gateway-client/src/apis/statistics_api.rs b/libraries/gateway-client/src/apis/statistics_api.rs
new file mode 100644
index 00000000..66d92e6f
--- /dev/null
+++ b/libraries/gateway-client/src/apis/statistics_api.rs
@@ -0,0 +1,56 @@
+use reqwest;
+
+use super::{configuration, Error};
+use crate::apis::ResponseContent;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum ValidatorsUptimeError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+pub fn validators_uptime(
+ configuration: &configuration::Configuration,
+ validators_uptime_request: crate::models::ValidatorsUptimeRequest,
+) -> Result>
+{
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/statistics/validators/uptime",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&validators_uptime_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
diff --git a/libraries/gateway-client/src/apis/status_api.rs b/libraries/gateway-client/src/apis/status_api.rs
new file mode 100644
index 00000000..8fee4a44
--- /dev/null
+++ b/libraries/gateway-client/src/apis/status_api.rs
@@ -0,0 +1,101 @@
+use reqwest;
+
+use super::{configuration, Error};
+use crate::apis::ResponseContent;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum GatewayStatusError {
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum NetworkConfigurationError {
+ UnknownValue(serde_json::Value),
+}
+
+pub fn gateway_status(
+ configuration: &configuration::Configuration,
+) -> Result> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/status/gateway-status",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn network_configuration(
+ configuration: &configuration::Configuration,
+) -> Result<
+ crate::models::NetworkConfigurationResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/status/network-configuration",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
diff --git a/libraries/gateway-client/src/apis/stream_api.rs b/libraries/gateway-client/src/apis/stream_api.rs
new file mode 100644
index 00000000..dae72fda
--- /dev/null
+++ b/libraries/gateway-client/src/apis/stream_api.rs
@@ -0,0 +1,56 @@
+use reqwest;
+
+use super::{configuration, Error};
+use crate::apis::ResponseContent;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum StreamTransactionsError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+pub fn stream_transactions(
+ configuration: &configuration::Configuration,
+ stream_transactions_request: crate::models::StreamTransactionsRequest,
+) -> Result<
+ crate::models::StreamTransactionsResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str =
+ format!("{}/stream/transactions", local_var_configuration.base_path);
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&stream_transactions_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
diff --git a/libraries/gateway-client/src/apis/transaction_api.rs b/libraries/gateway-client/src/apis/transaction_api.rs
new file mode 100644
index 00000000..ed3cc3db
--- /dev/null
+++ b/libraries/gateway-client/src/apis/transaction_api.rs
@@ -0,0 +1,264 @@
+use reqwest;
+
+use super::{configuration, Error};
+use crate::apis::ResponseContent;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum TransactionCommittedDetailsError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum TransactionConstructionError {
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum TransactionPreviewError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum TransactionStatusError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum TransactionSubmitError {
+ Status4XX(crate::models::ErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+pub fn transaction_committed_details(
+ configuration: &configuration::Configuration,
+ transaction_committed_details_request: crate::models::TransactionCommittedDetailsRequest,
+) -> Result<
+ crate::models::TransactionCommittedDetailsResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/transaction/committed-details",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&transaction_committed_details_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn transaction_construction(
+ configuration: &configuration::Configuration,
+) -> Result<
+ crate::models::TransactionConstructionResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str = format!(
+ "{}/transaction/construction",
+ local_var_configuration.base_path
+ );
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn transaction_preview(
+ configuration: &configuration::Configuration,
+ transaction_preview_request: crate::models::TransactionPreviewRequest,
+) -> Result<
+ crate::models::TransactionPreviewResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str =
+ format!("{}/transaction/preview", local_var_configuration.base_path);
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&transaction_preview_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn transaction_status(
+ configuration: &configuration::Configuration,
+ transaction_status_request: crate::models::TransactionStatusRequest,
+) -> Result<
+ crate::models::TransactionStatusResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str =
+ format!("{}/transaction/status", local_var_configuration.base_path);
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&transaction_status_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
+
+pub fn transaction_submit(
+ configuration: &configuration::Configuration,
+ transaction_submit_request: crate::models::TransactionSubmitRequest,
+) -> Result<
+ crate::models::TransactionSubmitResponse,
+ Error,
+> {
+ let local_var_configuration = configuration;
+
+ let local_var_client = &local_var_configuration.client;
+
+ let local_var_uri_str =
+ format!("{}/transaction/submit", local_var_configuration.base_path);
+ let mut local_var_req_builder = local_var_client
+ .request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+ if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+ local_var_req_builder = local_var_req_builder
+ .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+ }
+ local_var_req_builder =
+ local_var_req_builder.json(&transaction_submit_request);
+
+ let local_var_req = local_var_req_builder.build()?;
+ let local_var_resp = local_var_client.execute(local_var_req)?;
+
+ let local_var_status = local_var_resp.status();
+ let local_var_content = local_var_resp.text()?;
+
+ if !local_var_status.is_client_error()
+ && !local_var_status.is_server_error()
+ {
+ serde_json::from_str(&local_var_content).map_err(Error::from)
+ } else {
+ let local_var_entity: Option =
+ serde_json::from_str(&local_var_content).ok();
+ let local_var_error = ResponseContent {
+ status: local_var_status,
+ content: local_var_content,
+ entity: local_var_entity,
+ };
+ Err(Error::ResponseError(local_var_error))
+ }
+}
diff --git a/libraries/gateway-client/src/lib.rs b/libraries/gateway-client/src/lib.rs
new file mode 100644
index 00000000..3ce6649f
--- /dev/null
+++ b/libraries/gateway-client/src/lib.rs
@@ -0,0 +1,9 @@
+#![allow(clippy::too_many_arguments)]
+
+extern crate reqwest;
+extern crate serde;
+extern crate serde_json;
+extern crate url;
+
+pub mod apis;
+pub mod models;
diff --git a/libraries/gateway-client/src/models/at_ledger_state_mixin.rs b/libraries/gateway-client/src/models/at_ledger_state_mixin.rs
new file mode 100644
index 00000000..41feda68
--- /dev/null
+++ b/libraries/gateway-client/src/models/at_ledger_state_mixin.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct AtLedgerStateMixin {
+ #[serde(
+ rename = "at_ledger_state",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub at_ledger_state:
+ Option>>,
+}
+
+impl Default for AtLedgerStateMixin {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl AtLedgerStateMixin {
+ pub fn new() -> AtLedgerStateMixin {
+ AtLedgerStateMixin {
+ at_ledger_state: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/committed_transaction_info.rs b/libraries/gateway-client/src/models/committed_transaction_info.rs
new file mode 100644
index 00000000..2c4f2281
--- /dev/null
+++ b/libraries/gateway-client/src/models/committed_transaction_info.rs
@@ -0,0 +1,85 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct CommittedTransactionInfo {
+ #[serde(rename = "state_version")]
+ pub state_version: i64,
+ #[serde(rename = "epoch")]
+ pub epoch: i64,
+ #[serde(rename = "round")]
+ pub round: i64,
+ #[serde(rename = "round_timestamp")]
+ pub round_timestamp: String,
+ #[serde(rename = "transaction_status")]
+ pub transaction_status: crate::models::TransactionStatus,
+
+ #[serde(rename = "payload_hash", skip_serializing_if = "Option::is_none")]
+ pub payload_hash: Option,
+
+ #[serde(rename = "intent_hash", skip_serializing_if = "Option::is_none")]
+ pub intent_hash: Option,
+
+ #[serde(rename = "fee_paid", skip_serializing_if = "Option::is_none")]
+ pub fee_paid: Option,
+ #[serde(
+ rename = "affected_global_entities",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub affected_global_entities: Option>,
+ #[serde(
+ rename = "confirmed_at",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub confirmed_at: Option>,
+ #[serde(
+ rename = "error_message",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub error_message: Option>,
+
+ #[serde(rename = "raw_hex", skip_serializing_if = "Option::is_none")]
+ pub raw_hex: Option,
+ #[serde(rename = "receipt", skip_serializing_if = "Option::is_none")]
+ pub receipt: Option>,
+
+ #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
+ pub message: Option,
+ #[serde(
+ rename = "balance_changes",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub balance_changes:
+ Option>>,
+}
+
+impl CommittedTransactionInfo {
+ pub fn new(
+ state_version: i64,
+ epoch: i64,
+ round: i64,
+ round_timestamp: String,
+ transaction_status: crate::models::TransactionStatus,
+ ) -> CommittedTransactionInfo {
+ CommittedTransactionInfo {
+ state_version,
+ epoch,
+ round,
+ round_timestamp,
+ transaction_status,
+ payload_hash: None,
+ intent_hash: None,
+ fee_paid: None,
+ affected_global_entities: None,
+ confirmed_at: None,
+ error_message: None,
+ raw_hex: None,
+ receipt: None,
+ message: None,
+ balance_changes: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/component_entity_role_assignment_entry.rs b/libraries/gateway-client/src/models/component_entity_role_assignment_entry.rs
new file mode 100644
index 00000000..ccbcda5d
--- /dev/null
+++ b/libraries/gateway-client/src/models/component_entity_role_assignment_entry.rs
@@ -0,0 +1,23 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ComponentEntityRoleAssignmentEntry {
+ #[serde(rename = "role_key")]
+ pub role_key: Box,
+ #[serde(rename = "assignment")]
+ pub assignment:
+ Box,
+ #[serde(rename = "updater_roles", skip_serializing_if = "Option::is_none")]
+ pub updater_roles: Option>,
+}
+
+impl ComponentEntityRoleAssignmentEntry {
+ pub fn new(
+ role_key: crate::models::RoleKey,
+ assignment: crate::models::ComponentEntityRoleAssignmentEntryAssignment,
+ ) -> ComponentEntityRoleAssignmentEntry {
+ ComponentEntityRoleAssignmentEntry {
+ role_key: Box::new(role_key),
+ assignment: Box::new(assignment),
+ updater_roles: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/component_entity_role_assignment_entry_assignment.rs b/libraries/gateway-client/src/models/component_entity_role_assignment_entry_assignment.rs
new file mode 100644
index 00000000..cb0fae03
--- /dev/null
+++ b/libraries/gateway-client/src/models/component_entity_role_assignment_entry_assignment.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ComponentEntityRoleAssignmentEntryAssignment {
+ #[serde(rename = "resolution")]
+ pub resolution: crate::models::RoleAssignmentResolution,
+
+ #[serde(rename = "explicit_rule", skip_serializing_if = "Option::is_none")]
+ pub explicit_rule: Option,
+}
+
+impl ComponentEntityRoleAssignmentEntryAssignment {
+ pub fn new(
+ resolution: crate::models::RoleAssignmentResolution,
+ ) -> ComponentEntityRoleAssignmentEntryAssignment {
+ ComponentEntityRoleAssignmentEntryAssignment {
+ resolution,
+ explicit_rule: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/component_entity_role_assignments.rs b/libraries/gateway-client/src/models/component_entity_role_assignments.rs
new file mode 100644
index 00000000..04ba0a6f
--- /dev/null
+++ b/libraries/gateway-client/src/models/component_entity_role_assignments.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ComponentEntityRoleAssignments {
+ #[serde(rename = "owner")]
+ pub owner: serde_json::Value,
+ #[serde(rename = "entries")]
+ pub entries: Vec,
+}
+
+impl ComponentEntityRoleAssignments {
+ pub fn new(
+ owner: serde_json::Value,
+ entries: Vec,
+ ) -> ComponentEntityRoleAssignments {
+ ComponentEntityRoleAssignments { owner, entries }
+ }
+}
diff --git a/libraries/gateway-client/src/models/cursor_limit_mixin.rs b/libraries/gateway-client/src/models/cursor_limit_mixin.rs
new file mode 100644
index 00000000..73a905c5
--- /dev/null
+++ b/libraries/gateway-client/src/models/cursor_limit_mixin.rs
@@ -0,0 +1,33 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct CursorLimitMixin {
+ #[serde(
+ rename = "cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub cursor: Option>,
+
+ #[serde(
+ rename = "limit_per_page",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub limit_per_page: Option>,
+}
+
+impl Default for CursorLimitMixin {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl CursorLimitMixin {
+ pub fn new() -> CursorLimitMixin {
+ CursorLimitMixin {
+ cursor: None,
+ limit_per_page: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/entity_metadata_collection.rs b/libraries/gateway-client/src/models/entity_metadata_collection.rs
new file mode 100644
index 00000000..8e178b8a
--- /dev/null
+++ b/libraries/gateway-client/src/models/entity_metadata_collection.rs
@@ -0,0 +1,32 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EntityMetadataCollection {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec,
+}
+
+impl EntityMetadataCollection {
+ pub fn new(
+ items: Vec,
+ ) -> EntityMetadataCollection {
+ EntityMetadataCollection {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/entity_metadata_item.rs b/libraries/gateway-client/src/models/entity_metadata_item.rs
new file mode 100644
index 00000000..4b3a52c9
--- /dev/null
+++ b/libraries/gateway-client/src/models/entity_metadata_item.rs
@@ -0,0 +1,28 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EntityMetadataItem {
+ #[serde(rename = "key")]
+ pub key: String,
+ #[serde(rename = "value")]
+ pub value: Box,
+ #[serde(rename = "is_locked")]
+ pub is_locked: bool,
+
+ #[serde(rename = "last_updated_at_state_version")]
+ pub last_updated_at_state_version: i64,
+}
+
+impl EntityMetadataItem {
+ pub fn new(
+ key: String,
+ value: crate::models::EntityMetadataItemValue,
+ is_locked: bool,
+ last_updated_at_state_version: i64,
+ ) -> EntityMetadataItem {
+ EntityMetadataItem {
+ key,
+ value: Box::new(value),
+ is_locked,
+ last_updated_at_state_version,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/entity_metadata_item_value.rs b/libraries/gateway-client/src/models/entity_metadata_item_value.rs
new file mode 100644
index 00000000..b078aaff
--- /dev/null
+++ b/libraries/gateway-client/src/models/entity_metadata_item_value.rs
@@ -0,0 +1,23 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EntityMetadataItemValue {
+ #[serde(rename = "raw_hex")]
+ pub raw_hex: String,
+ #[serde(rename = "programmatic_json")]
+ pub programmatic_json: Box,
+ #[serde(rename = "typed")]
+ pub typed: Box,
+}
+
+impl EntityMetadataItemValue {
+ pub fn new(
+ raw_hex: String,
+ programmatic_json: crate::models::ProgrammaticScryptoSborValue,
+ typed: crate::models::MetadataTypedValue,
+ ) -> EntityMetadataItemValue {
+ EntityMetadataItemValue {
+ raw_hex,
+ programmatic_json: Box::new(programmatic_json),
+ typed: Box::new(typed),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/entity_not_found_error.rs b/libraries/gateway-client/src/models/entity_not_found_error.rs
new file mode 100644
index 00000000..317b2335
--- /dev/null
+++ b/libraries/gateway-client/src/models/entity_not_found_error.rs
@@ -0,0 +1,14 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EntityNotFoundError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+
+ #[serde(rename = "address")]
+ pub address: String,
+}
+
+impl EntityNotFoundError {
+ pub fn new(r#type: String, address: String) -> EntityNotFoundError {
+ EntityNotFoundError { r#type, address }
+ }
+}
diff --git a/libraries/gateway-client/src/models/error_response.rs b/libraries/gateway-client/src/models/error_response.rs
new file mode 100644
index 00000000..0288265f
--- /dev/null
+++ b/libraries/gateway-client/src/models/error_response.rs
@@ -0,0 +1,24 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ErrorResponse {
+ #[serde(rename = "message")]
+ pub message: String,
+
+ #[serde(rename = "code", skip_serializing_if = "Option::is_none")]
+ pub code: Option,
+ #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
+ pub details: Option>,
+
+ #[serde(rename = "trace_id", skip_serializing_if = "Option::is_none")]
+ pub trace_id: Option,
+}
+
+impl ErrorResponse {
+ pub fn new(message: String) -> ErrorResponse {
+ ErrorResponse {
+ message,
+ code: None,
+ details: None,
+ trace_id: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/events_item.rs b/libraries/gateway-client/src/models/events_item.rs
new file mode 100644
index 00000000..cf99446b
--- /dev/null
+++ b/libraries/gateway-client/src/models/events_item.rs
@@ -0,0 +1,24 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct EventsItem {
+ #[serde(rename = "name")]
+ pub name: String,
+
+ #[serde(rename = "emitter")]
+ pub emitter: serde_json::Value,
+ #[serde(rename = "data")]
+ pub data: Box,
+}
+
+impl EventsItem {
+ pub fn new(
+ name: String,
+ emitter: serde_json::Value,
+ data: serde_json::Value,
+ ) -> EventsItem {
+ EventsItem {
+ name,
+ emitter,
+ data: Box::new(data),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/from_ledger_state_mixin.rs b/libraries/gateway-client/src/models/from_ledger_state_mixin.rs
new file mode 100644
index 00000000..67e20943
--- /dev/null
+++ b/libraries/gateway-client/src/models/from_ledger_state_mixin.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FromLedgerStateMixin {
+ #[serde(
+ rename = "from_ledger_state",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub from_ledger_state:
+ Option>>,
+}
+
+impl Default for FromLedgerStateMixin {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl FromLedgerStateMixin {
+ pub fn new() -> FromLedgerStateMixin {
+ FromLedgerStateMixin {
+ from_ledger_state: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection.rs b/libraries/gateway-client/src/models/fungible_resources_collection.rs
new file mode 100644
index 00000000..01e1470d
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection.rs
@@ -0,0 +1,32 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FungibleResourcesCollection {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec,
+}
+
+impl FungibleResourcesCollection {
+ pub fn new(
+ items: Vec,
+ ) -> FungibleResourcesCollection {
+ FungibleResourcesCollection {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection_item.rs b/libraries/gateway-client/src/models/fungible_resources_collection_item.rs
new file mode 100644
index 00000000..3267c9f4
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection_item.rs
@@ -0,0 +1,3 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "")]
+pub enum FungibleResourcesCollectionItem {}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection_item_globally_aggregated.rs b/libraries/gateway-client/src/models/fungible_resources_collection_item_globally_aggregated.rs
new file mode 100644
index 00000000..17660dc6
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection_item_globally_aggregated.rs
@@ -0,0 +1,36 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FungibleResourcesCollectionItemGloballyAggregated {
+ #[serde(rename = "aggregation_level")]
+ pub aggregation_level: crate::models::ResourceAggregationLevel,
+
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+ #[serde(
+ rename = "explicit_metadata",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub explicit_metadata: Option>,
+
+ #[serde(rename = "amount")]
+ pub amount: String,
+
+ #[serde(rename = "last_updated_at_state_version")]
+ pub last_updated_at_state_version: i64,
+}
+
+impl FungibleResourcesCollectionItemGloballyAggregated {
+ pub fn new(
+ aggregation_level: crate::models::ResourceAggregationLevel,
+ resource_address: String,
+ amount: String,
+ last_updated_at_state_version: i64,
+ ) -> FungibleResourcesCollectionItemGloballyAggregated {
+ FungibleResourcesCollectionItemGloballyAggregated {
+ aggregation_level,
+ resource_address,
+ explicit_metadata: None,
+ amount,
+ last_updated_at_state_version,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated.rs b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated.rs
new file mode 100644
index 00000000..a8fc4fe8
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated.rs
@@ -0,0 +1,31 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FungibleResourcesCollectionItemVaultAggregated {
+ #[serde(rename = "aggregation_level")]
+ pub aggregation_level: crate::models::ResourceAggregationLevel,
+
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+ #[serde(
+ rename = "explicit_metadata",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub explicit_metadata: Option>,
+ #[serde(rename = "vaults")]
+ pub vaults:
+ Box,
+}
+
+impl FungibleResourcesCollectionItemVaultAggregated {
+ pub fn new(
+ aggregation_level: crate::models::ResourceAggregationLevel,
+ resource_address: String,
+ vaults: crate::models::FungibleResourcesCollectionItemVaultAggregatedVault,
+ ) -> FungibleResourcesCollectionItemVaultAggregated {
+ FungibleResourcesCollectionItemVaultAggregated {
+ aggregation_level,
+ resource_address,
+ explicit_metadata: None,
+ vaults: Box::new(vaults),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault.rs b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault.rs
new file mode 100644
index 00000000..5e13613f
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault.rs
@@ -0,0 +1,34 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FungibleResourcesCollectionItemVaultAggregatedVault {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec<
+ crate::models::FungibleResourcesCollectionItemVaultAggregatedVaultItem,
+ >,
+}
+
+impl FungibleResourcesCollectionItemVaultAggregatedVault {
+ pub fn new(
+ items: Vec,
+ ) -> FungibleResourcesCollectionItemVaultAggregatedVault {
+ FungibleResourcesCollectionItemVaultAggregatedVault {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault_item.rs b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault_item.rs
new file mode 100644
index 00000000..583a5d2b
--- /dev/null
+++ b/libraries/gateway-client/src/models/fungible_resources_collection_item_vault_aggregated_vault_item.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ #[serde(rename = "vault_address")]
+ pub vault_address: String,
+
+ #[serde(rename = "amount")]
+ pub amount: String,
+
+ #[serde(rename = "last_updated_at_state_version")]
+ pub last_updated_at_state_version: i64,
+}
+
+impl FungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ pub fn new(
+ vault_address: String,
+ amount: String,
+ last_updated_at_state_version: i64,
+ ) -> FungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ FungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ vault_address,
+ amount,
+ last_updated_at_state_version,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/gateway_error.rs b/libraries/gateway-client/src/models/gateway_error.rs
new file mode 100644
index 00000000..1f391a20
--- /dev/null
+++ b/libraries/gateway-client/src/models/gateway_error.rs
@@ -0,0 +1,3 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "")]
+pub enum GatewayError {}
diff --git a/libraries/gateway-client/src/models/gateway_info_response_known_target.rs b/libraries/gateway-client/src/models/gateway_info_response_known_target.rs
new file mode 100644
index 00000000..a2469e25
--- /dev/null
+++ b/libraries/gateway-client/src/models/gateway_info_response_known_target.rs
@@ -0,0 +1,11 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct GatewayInfoResponseKnownTarget {
+ #[serde(rename = "state_version")]
+ pub state_version: i64,
+}
+
+impl GatewayInfoResponseKnownTarget {
+ pub fn new(state_version: i64) -> GatewayInfoResponseKnownTarget {
+ GatewayInfoResponseKnownTarget { state_version }
+ }
+}
diff --git a/libraries/gateway-client/src/models/gateway_info_response_release_info.rs b/libraries/gateway-client/src/models/gateway_info_response_release_info.rs
new file mode 100644
index 00000000..91f183f0
--- /dev/null
+++ b/libraries/gateway-client/src/models/gateway_info_response_release_info.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct GatewayInfoResponseReleaseInfo {
+ #[serde(rename = "release_version")]
+ pub release_version: String,
+
+ #[serde(rename = "open_api_schema_version")]
+ pub open_api_schema_version: String,
+
+ #[serde(rename = "image_tag")]
+ pub image_tag: String,
+}
+
+impl GatewayInfoResponseReleaseInfo {
+ pub fn new(
+ release_version: String,
+ open_api_schema_version: String,
+ image_tag: String,
+ ) -> GatewayInfoResponseReleaseInfo {
+ GatewayInfoResponseReleaseInfo {
+ release_version,
+ open_api_schema_version,
+ image_tag,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/gateway_status_response.rs b/libraries/gateway-client/src/models/gateway_status_response.rs
new file mode 100644
index 00000000..f9922fba
--- /dev/null
+++ b/libraries/gateway-client/src/models/gateway_status_response.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct GatewayStatusResponse {
+ #[serde(rename = "ledger_state")]
+ pub ledger_state: Box,
+ #[serde(rename = "release_info")]
+ pub release_info: Box,
+}
+
+impl GatewayStatusResponse {
+ pub fn new(
+ ledger_state: crate::models::LedgerState,
+ release_info: crate::models::GatewayInfoResponseReleaseInfo,
+ ) -> GatewayStatusResponse {
+ GatewayStatusResponse {
+ ledger_state: Box::new(ledger_state),
+ release_info: Box::new(release_info),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/internal_server_error.rs b/libraries/gateway-client/src/models/internal_server_error.rs
new file mode 100644
index 00000000..29a5e0bc
--- /dev/null
+++ b/libraries/gateway-client/src/models/internal_server_error.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct InternalServerError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+
+ #[serde(rename = "exception")]
+ pub exception: String,
+
+ #[serde(rename = "cause")]
+ pub cause: String,
+}
+
+impl InternalServerError {
+ pub fn new(
+ r#type: String,
+ exception: String,
+ cause: String,
+ ) -> InternalServerError {
+ InternalServerError {
+ r#type,
+ exception,
+ cause,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/invalid_entity_error.rs b/libraries/gateway-client/src/models/invalid_entity_error.rs
new file mode 100644
index 00000000..994cf367
--- /dev/null
+++ b/libraries/gateway-client/src/models/invalid_entity_error.rs
@@ -0,0 +1,14 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct InvalidEntityError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+
+ #[serde(rename = "address")]
+ pub address: String,
+}
+
+impl InvalidEntityError {
+ pub fn new(r#type: String, address: String) -> InvalidEntityError {
+ InvalidEntityError { r#type, address }
+ }
+}
diff --git a/libraries/gateway-client/src/models/invalid_request_error.rs b/libraries/gateway-client/src/models/invalid_request_error.rs
new file mode 100644
index 00000000..3d1bb659
--- /dev/null
+++ b/libraries/gateway-client/src/models/invalid_request_error.rs
@@ -0,0 +1,20 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct InvalidRequestError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+
+ #[serde(rename = "validation_errors")]
+ pub validation_errors: Vec,
+}
+
+impl InvalidRequestError {
+ pub fn new(
+ r#type: String,
+ validation_errors: Vec,
+ ) -> InvalidRequestError {
+ InvalidRequestError {
+ r#type,
+ validation_errors,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/invalid_transaction_error.rs b/libraries/gateway-client/src/models/invalid_transaction_error.rs
new file mode 100644
index 00000000..86821d9e
--- /dev/null
+++ b/libraries/gateway-client/src/models/invalid_transaction_error.rs
@@ -0,0 +1,11 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct InvalidTransactionError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+}
+
+impl InvalidTransactionError {
+ pub fn new(r#type: String) -> InvalidTransactionError {
+ InvalidTransactionError { r#type }
+ }
+}
diff --git a/libraries/gateway-client/src/models/ledger_state.rs b/libraries/gateway-client/src/models/ledger_state.rs
new file mode 100644
index 00000000..0b53c9ce
--- /dev/null
+++ b/libraries/gateway-client/src/models/ledger_state.rs
@@ -0,0 +1,35 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct LedgerState {
+ #[serde(rename = "network")]
+ pub network: String,
+
+ #[serde(rename = "state_version")]
+ pub state_version: i64,
+
+ #[serde(rename = "proposer_round_timestamp")]
+ pub proposer_round_timestamp: String,
+
+ #[serde(rename = "epoch")]
+ pub epoch: i64,
+
+ #[serde(rename = "round")]
+ pub round: i64,
+}
+
+impl LedgerState {
+ pub fn new(
+ network: String,
+ state_version: i64,
+ proposer_round_timestamp: String,
+ epoch: i64,
+ round: i64,
+ ) -> LedgerState {
+ LedgerState {
+ network,
+ state_version,
+ proposer_round_timestamp,
+ epoch,
+ round,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/ledger_state_mixin.rs b/libraries/gateway-client/src/models/ledger_state_mixin.rs
new file mode 100644
index 00000000..3de000c1
--- /dev/null
+++ b/libraries/gateway-client/src/models/ledger_state_mixin.rs
@@ -0,0 +1,13 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct LedgerStateMixin {
+ #[serde(rename = "ledger_state")]
+ pub ledger_state: Box,
+}
+
+impl LedgerStateMixin {
+ pub fn new(ledger_state: crate::models::LedgerState) -> LedgerStateMixin {
+ LedgerStateMixin {
+ ledger_state: Box::new(ledger_state),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/ledger_state_selector.rs b/libraries/gateway-client/src/models/ledger_state_selector.rs
new file mode 100644
index 00000000..c515c031
--- /dev/null
+++ b/libraries/gateway-client/src/models/ledger_state_selector.rs
@@ -0,0 +1,51 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct LedgerStateSelector {
+ #[serde(
+ rename = "state_version",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub state_version: Option>,
+
+ #[serde(
+ rename = "timestamp",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub timestamp: Option>,
+
+ #[serde(
+ rename = "epoch",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub epoch: Option>,
+
+ #[serde(
+ rename = "round",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub round: Option>,
+}
+
+impl Default for LedgerStateSelector {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl LedgerStateSelector {
+ pub fn new() -> LedgerStateSelector {
+ LedgerStateSelector {
+ state_version: None,
+ timestamp: None,
+ epoch: None,
+ round: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_bool_array_value.rs b/libraries/gateway-client/src/models/metadata_bool_array_value.rs
new file mode 100644
index 00000000..e1b2d93b
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_bool_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataBoolArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataBoolArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataBoolArrayValue {
+ MetadataBoolArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_bool_value.rs b/libraries/gateway-client/src/models/metadata_bool_value.rs
new file mode 100644
index 00000000..486e8758
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_bool_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataBoolValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: bool,
+}
+
+impl MetadataBoolValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: bool,
+ ) -> MetadataBoolValue {
+ MetadataBoolValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_decimal_array_value.rs b/libraries/gateway-client/src/models/metadata_decimal_array_value.rs
new file mode 100644
index 00000000..8c14a68c
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_decimal_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataDecimalArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataDecimalArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataDecimalArrayValue {
+ MetadataDecimalArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_decimal_value.rs b/libraries/gateway-client/src/models/metadata_decimal_value.rs
new file mode 100644
index 00000000..1ab60d6b
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_decimal_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataDecimalValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataDecimalValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataDecimalValue {
+ MetadataDecimalValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_global_address_array_value.rs b/libraries/gateway-client/src/models/metadata_global_address_array_value.rs
new file mode 100644
index 00000000..427ba5a5
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_global_address_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataGlobalAddressArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataGlobalAddressArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataGlobalAddressArrayValue {
+ MetadataGlobalAddressArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_global_address_value.rs b/libraries/gateway-client/src/models/metadata_global_address_value.rs
new file mode 100644
index 00000000..00c4c415
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_global_address_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataGlobalAddressValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataGlobalAddressValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataGlobalAddressValue {
+ MetadataGlobalAddressValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_i32_array_value.rs b/libraries/gateway-client/src/models/metadata_i32_array_value.rs
new file mode 100644
index 00000000..121c015b
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_i32_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataI32ArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataI32ArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataI32ArrayValue {
+ MetadataI32ArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_i32_value.rs b/libraries/gateway-client/src/models/metadata_i32_value.rs
new file mode 100644
index 00000000..ebf07a51
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_i32_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataI32Value {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataI32Value {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataI32Value {
+ MetadataI32Value { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_i64_array_value.rs b/libraries/gateway-client/src/models/metadata_i64_array_value.rs
new file mode 100644
index 00000000..6b2d648c
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_i64_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataI64ArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataI64ArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataI64ArrayValue {
+ MetadataI64ArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_i64_value.rs b/libraries/gateway-client/src/models/metadata_i64_value.rs
new file mode 100644
index 00000000..6926f8cb
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_i64_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataI64Value {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataI64Value {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataI64Value {
+ MetadataI64Value { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_instant_array_value.rs b/libraries/gateway-client/src/models/metadata_instant_array_value.rs
new file mode 100644
index 00000000..507ee704
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_instant_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataInstantArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataInstantArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataInstantArrayValue {
+ MetadataInstantArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_instant_value.rs b/libraries/gateway-client/src/models/metadata_instant_value.rs
new file mode 100644
index 00000000..fcbc362e
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_instant_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataInstantValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataInstantValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataInstantValue {
+ MetadataInstantValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value.rs b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value.rs
new file mode 100644
index 00000000..389b8397
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataNonFungibleGlobalIdArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values:
+ Vec,
+}
+
+impl MetadataNonFungibleGlobalIdArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec<
+ crate::models::MetadataNonFungibleGlobalIdArrayValueAllOfValues,
+ >,
+ ) -> MetadataNonFungibleGlobalIdArrayValue {
+ MetadataNonFungibleGlobalIdArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value_all_of_values.rs b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value_all_of_values.rs
new file mode 100644
index 00000000..158f2ca7
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_array_value_all_of_values.rs
@@ -0,0 +1,20 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataNonFungibleGlobalIdArrayValueAllOfValues {
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+
+ #[serde(rename = "non_fungible_id")]
+ pub non_fungible_id: String,
+}
+
+impl MetadataNonFungibleGlobalIdArrayValueAllOfValues {
+ pub fn new(
+ resource_address: String,
+ non_fungible_id: String,
+ ) -> MetadataNonFungibleGlobalIdArrayValueAllOfValues {
+ MetadataNonFungibleGlobalIdArrayValueAllOfValues {
+ resource_address,
+ non_fungible_id,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_non_fungible_global_id_value.rs b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_value.rs
new file mode 100644
index 00000000..6a5d7859
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_non_fungible_global_id_value.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataNonFungibleGlobalIdValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+
+ #[serde(rename = "non_fungible_id")]
+ pub non_fungible_id: String,
+}
+
+impl MetadataNonFungibleGlobalIdValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ resource_address: String,
+ non_fungible_id: String,
+ ) -> MetadataNonFungibleGlobalIdValue {
+ MetadataNonFungibleGlobalIdValue {
+ r#type,
+ resource_address,
+ non_fungible_id,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_non_fungible_local_id_array_value.rs b/libraries/gateway-client/src/models/metadata_non_fungible_local_id_array_value.rs
new file mode 100644
index 00000000..4a8148d3
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_non_fungible_local_id_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataNonFungibleLocalIdArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataNonFungibleLocalIdArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataNonFungibleLocalIdArrayValue {
+ MetadataNonFungibleLocalIdArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_non_fungible_local_id_value.rs b/libraries/gateway-client/src/models/metadata_non_fungible_local_id_value.rs
new file mode 100644
index 00000000..52aaf12a
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_non_fungible_local_id_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataNonFungibleLocalIdValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataNonFungibleLocalIdValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataNonFungibleLocalIdValue {
+ MetadataNonFungibleLocalIdValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_origin_array_value.rs b/libraries/gateway-client/src/models/metadata_origin_array_value.rs
new file mode 100644
index 00000000..d44650be
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_origin_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataOriginArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataOriginArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataOriginArrayValue {
+ MetadataOriginArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_origin_value.rs b/libraries/gateway-client/src/models/metadata_origin_value.rs
new file mode 100644
index 00000000..e71dbfff
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_origin_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataOriginValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataOriginValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataOriginValue {
+ MetadataOriginValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_public_key_array_value.rs b/libraries/gateway-client/src/models/metadata_public_key_array_value.rs
new file mode 100644
index 00000000..37f326fa
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_public_key_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataPublicKeyArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataPublicKeyArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataPublicKeyArrayValue {
+ MetadataPublicKeyArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_public_key_hash_array_value.rs b/libraries/gateway-client/src/models/metadata_public_key_hash_array_value.rs
new file mode 100644
index 00000000..ac5ddfbb
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_public_key_hash_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataPublicKeyHashArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataPublicKeyHashArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataPublicKeyHashArrayValue {
+ MetadataPublicKeyHashArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_public_key_hash_value.rs b/libraries/gateway-client/src/models/metadata_public_key_hash_value.rs
new file mode 100644
index 00000000..4a73928c
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_public_key_hash_value.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataPublicKeyHashValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: Box,
+}
+
+impl MetadataPublicKeyHashValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: crate::models::PublicKeyHash,
+ ) -> MetadataPublicKeyHashValue {
+ MetadataPublicKeyHashValue {
+ r#type,
+ value: Box::new(value),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_public_key_value.rs b/libraries/gateway-client/src/models/metadata_public_key_value.rs
new file mode 100644
index 00000000..954807d6
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_public_key_value.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataPublicKeyValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: Box,
+}
+
+impl MetadataPublicKeyValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: crate::models::PublicKey,
+ ) -> MetadataPublicKeyValue {
+ MetadataPublicKeyValue {
+ r#type,
+ value: Box::new(value),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_string_array_value.rs b/libraries/gateway-client/src/models/metadata_string_array_value.rs
new file mode 100644
index 00000000..abd000f2
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_string_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataStringArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataStringArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataStringArrayValue {
+ MetadataStringArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_string_value.rs b/libraries/gateway-client/src/models/metadata_string_value.rs
new file mode 100644
index 00000000..42f50f06
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_string_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataStringValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataStringValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataStringValue {
+ MetadataStringValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_typed_value.rs b/libraries/gateway-client/src/models/metadata_typed_value.rs
new file mode 100644
index 00000000..33bc133e
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_typed_value.rs
@@ -0,0 +1,3 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "")]
+pub enum MetadataTypedValue {}
diff --git a/libraries/gateway-client/src/models/metadata_u32_array_value.rs b/libraries/gateway-client/src/models/metadata_u32_array_value.rs
new file mode 100644
index 00000000..66a00446
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u32_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU32ArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataU32ArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataU32ArrayValue {
+ MetadataU32ArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_u32_value.rs b/libraries/gateway-client/src/models/metadata_u32_value.rs
new file mode 100644
index 00000000..4780010c
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u32_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU32Value {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataU32Value {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataU32Value {
+ MetadataU32Value { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_u64_array_value.rs b/libraries/gateway-client/src/models/metadata_u64_array_value.rs
new file mode 100644
index 00000000..43bd8764
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u64_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU64ArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataU64ArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataU64ArrayValue {
+ MetadataU64ArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_u64_value.rs b/libraries/gateway-client/src/models/metadata_u64_value.rs
new file mode 100644
index 00000000..5ad0d4e4
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u64_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU64Value {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataU64Value {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataU64Value {
+ MetadataU64Value { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_u8_array_value.rs b/libraries/gateway-client/src/models/metadata_u8_array_value.rs
new file mode 100644
index 00000000..01379a84
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u8_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU8ArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value_hex")]
+ pub value_hex: String,
+}
+
+impl MetadataU8ArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value_hex: String,
+ ) -> MetadataU8ArrayValue {
+ MetadataU8ArrayValue { r#type, value_hex }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_u8_value.rs b/libraries/gateway-client/src/models/metadata_u8_value.rs
new file mode 100644
index 00000000..ae0310a2
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_u8_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataU8Value {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataU8Value {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataU8Value {
+ MetadataU8Value { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_url_array_value.rs b/libraries/gateway-client/src/models/metadata_url_array_value.rs
new file mode 100644
index 00000000..b9ab6fc0
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_url_array_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataUrlArrayValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "values")]
+ pub values: Vec,
+}
+
+impl MetadataUrlArrayValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ values: Vec,
+ ) -> MetadataUrlArrayValue {
+ MetadataUrlArrayValue { r#type, values }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_url_value.rs b/libraries/gateway-client/src/models/metadata_url_value.rs
new file mode 100644
index 00000000..0596401f
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_url_value.rs
@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct MetadataUrlValue {
+ #[serde(rename = "type")]
+ pub r#type: crate::models::MetadataValueType,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl MetadataUrlValue {
+ pub fn new(
+ r#type: crate::models::MetadataValueType,
+ value: String,
+ ) -> MetadataUrlValue {
+ MetadataUrlValue { r#type, value }
+ }
+}
diff --git a/libraries/gateway-client/src/models/metadata_value_type.rs b/libraries/gateway-client/src/models/metadata_value_type.rs
new file mode 100644
index 00000000..c35e768c
--- /dev/null
+++ b/libraries/gateway-client/src/models/metadata_value_type.rs
@@ -0,0 +1,127 @@
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ PartialEq,
+ Ord,
+ PartialOrd,
+ Hash,
+ serde::Serialize,
+ serde::Deserialize,
+)]
+pub enum MetadataValueType {
+ #[serde(rename = "String")]
+ String,
+ #[serde(rename = "Bool")]
+ Bool,
+ #[serde(rename = "U8")]
+ U8,
+ #[serde(rename = "U32")]
+ U32,
+ #[serde(rename = "U64")]
+ U64,
+ #[serde(rename = "I32")]
+ I32,
+ #[serde(rename = "I64")]
+ I64,
+ #[serde(rename = "Decimal")]
+ Decimal,
+ #[serde(rename = "GlobalAddress")]
+ GlobalAddress,
+ #[serde(rename = "PublicKey")]
+ PublicKey,
+ #[serde(rename = "NonFungibleGlobalId")]
+ NonFungibleGlobalId,
+ #[serde(rename = "NonFungibleLocalId")]
+ NonFungibleLocalId,
+ #[serde(rename = "Instant")]
+ Instant,
+ #[serde(rename = "Url")]
+ Url,
+ #[serde(rename = "Origin")]
+ Origin,
+ #[serde(rename = "PublicKeyHash")]
+ PublicKeyHash,
+ #[serde(rename = "StringArray")]
+ StringArray,
+ #[serde(rename = "BoolArray")]
+ BoolArray,
+ #[serde(rename = "U8Array")]
+ U8Array,
+ #[serde(rename = "U32Array")]
+ U32Array,
+ #[serde(rename = "U64Array")]
+ U64Array,
+ #[serde(rename = "I32Array")]
+ I32Array,
+ #[serde(rename = "I64Array")]
+ I64Array,
+ #[serde(rename = "DecimalArray")]
+ DecimalArray,
+ #[serde(rename = "GlobalAddressArray")]
+ GlobalAddressArray,
+ #[serde(rename = "PublicKeyArray")]
+ PublicKeyArray,
+ #[serde(rename = "NonFungibleGlobalIdArray")]
+ NonFungibleGlobalIdArray,
+ #[serde(rename = "NonFungibleLocalIdArray")]
+ NonFungibleLocalIdArray,
+ #[serde(rename = "InstantArray")]
+ InstantArray,
+ #[serde(rename = "UrlArray")]
+ UrlArray,
+ #[serde(rename = "OriginArray")]
+ OriginArray,
+ #[serde(rename = "PublicKeyHashArray")]
+ PublicKeyHashArray,
+}
+
+impl ToString for MetadataValueType {
+ fn to_string(&self) -> String {
+ match self {
+ Self::String => String::from("String"),
+ Self::Bool => String::from("Bool"),
+ Self::U8 => String::from("U8"),
+ Self::U32 => String::from("U32"),
+ Self::U64 => String::from("U64"),
+ Self::I32 => String::from("I32"),
+ Self::I64 => String::from("I64"),
+ Self::Decimal => String::from("Decimal"),
+ Self::GlobalAddress => String::from("GlobalAddress"),
+ Self::PublicKey => String::from("PublicKey"),
+ Self::NonFungibleGlobalId => String::from("NonFungibleGlobalId"),
+ Self::NonFungibleLocalId => String::from("NonFungibleLocalId"),
+ Self::Instant => String::from("Instant"),
+ Self::Url => String::from("Url"),
+ Self::Origin => String::from("Origin"),
+ Self::PublicKeyHash => String::from("PublicKeyHash"),
+ Self::StringArray => String::from("StringArray"),
+ Self::BoolArray => String::from("BoolArray"),
+ Self::U8Array => String::from("U8Array"),
+ Self::U32Array => String::from("U32Array"),
+ Self::U64Array => String::from("U64Array"),
+ Self::I32Array => String::from("I32Array"),
+ Self::I64Array => String::from("I64Array"),
+ Self::DecimalArray => String::from("DecimalArray"),
+ Self::GlobalAddressArray => String::from("GlobalAddressArray"),
+ Self::PublicKeyArray => String::from("PublicKeyArray"),
+ Self::NonFungibleGlobalIdArray => {
+ String::from("NonFungibleGlobalIdArray")
+ }
+ Self::NonFungibleLocalIdArray => {
+ String::from("NonFungibleLocalIdArray")
+ }
+ Self::InstantArray => String::from("InstantArray"),
+ Self::UrlArray => String::from("UrlArray"),
+ Self::OriginArray => String::from("OriginArray"),
+ Self::PublicKeyHashArray => String::from("PublicKeyHashArray"),
+ }
+ }
+}
+
+impl Default for MetadataValueType {
+ fn default() -> MetadataValueType {
+ Self::String
+ }
+}
diff --git a/libraries/gateway-client/src/models/mod.rs b/libraries/gateway-client/src/models/mod.rs
new file mode 100644
index 00000000..759d34fc
--- /dev/null
+++ b/libraries/gateway-client/src/models/mod.rs
@@ -0,0 +1,404 @@
+pub mod at_ledger_state_mixin;
+pub use self::at_ledger_state_mixin::AtLedgerStateMixin;
+pub mod committed_transaction_info;
+pub use self::committed_transaction_info::CommittedTransactionInfo;
+pub mod component_entity_role_assignment_entry;
+pub use self::component_entity_role_assignment_entry::ComponentEntityRoleAssignmentEntry;
+pub mod component_entity_role_assignment_entry_assignment;
+pub use self::component_entity_role_assignment_entry_assignment::ComponentEntityRoleAssignmentEntryAssignment;
+pub mod component_entity_role_assignments;
+pub use self::component_entity_role_assignments::ComponentEntityRoleAssignments;
+pub mod cursor_limit_mixin;
+pub use self::cursor_limit_mixin::CursorLimitMixin;
+pub mod entity_metadata_collection;
+pub use self::entity_metadata_collection::EntityMetadataCollection;
+pub mod entity_metadata_item;
+pub use self::entity_metadata_item::EntityMetadataItem;
+pub mod entity_metadata_item_value;
+pub use self::entity_metadata_item_value::EntityMetadataItemValue;
+pub mod entity_not_found_error;
+pub use self::entity_not_found_error::EntityNotFoundError;
+pub mod error_response;
+pub use self::error_response::ErrorResponse;
+pub mod events_item;
+pub use self::events_item::EventsItem;
+pub mod from_ledger_state_mixin;
+pub use self::from_ledger_state_mixin::FromLedgerStateMixin;
+pub mod fungible_resources_collection;
+pub use self::fungible_resources_collection::FungibleResourcesCollection;
+pub mod fungible_resources_collection_item;
+pub use self::fungible_resources_collection_item::FungibleResourcesCollectionItem;
+pub mod fungible_resources_collection_item_globally_aggregated;
+pub use self::fungible_resources_collection_item_globally_aggregated::FungibleResourcesCollectionItemGloballyAggregated;
+pub mod fungible_resources_collection_item_vault_aggregated;
+pub use self::fungible_resources_collection_item_vault_aggregated::FungibleResourcesCollectionItemVaultAggregated;
+pub mod fungible_resources_collection_item_vault_aggregated_vault;
+pub use self::fungible_resources_collection_item_vault_aggregated_vault::FungibleResourcesCollectionItemVaultAggregatedVault;
+pub mod fungible_resources_collection_item_vault_aggregated_vault_item;
+pub use self::fungible_resources_collection_item_vault_aggregated_vault_item::FungibleResourcesCollectionItemVaultAggregatedVaultItem;
+pub mod gateway_error;
+pub use self::gateway_error::GatewayError;
+pub mod gateway_info_response_known_target;
+pub use self::gateway_info_response_known_target::GatewayInfoResponseKnownTarget;
+pub mod gateway_info_response_release_info;
+pub use self::gateway_info_response_release_info::GatewayInfoResponseReleaseInfo;
+pub mod gateway_status_response;
+pub use self::gateway_status_response::GatewayStatusResponse;
+pub mod internal_server_error;
+pub use self::internal_server_error::InternalServerError;
+pub mod invalid_entity_error;
+pub use self::invalid_entity_error::InvalidEntityError;
+pub mod invalid_request_error;
+pub use self::invalid_request_error::InvalidRequestError;
+pub mod invalid_transaction_error;
+pub use self::invalid_transaction_error::InvalidTransactionError;
+pub mod ledger_state;
+pub use self::ledger_state::LedgerState;
+pub mod ledger_state_mixin;
+pub use self::ledger_state_mixin::LedgerStateMixin;
+pub mod ledger_state_selector;
+pub use self::ledger_state_selector::LedgerStateSelector;
+pub mod metadata_bool_array_value;
+pub use self::metadata_bool_array_value::MetadataBoolArrayValue;
+pub mod metadata_bool_value;
+pub use self::metadata_bool_value::MetadataBoolValue;
+pub mod metadata_decimal_array_value;
+pub use self::metadata_decimal_array_value::MetadataDecimalArrayValue;
+pub mod metadata_decimal_value;
+pub use self::metadata_decimal_value::MetadataDecimalValue;
+pub mod metadata_global_address_array_value;
+pub use self::metadata_global_address_array_value::MetadataGlobalAddressArrayValue;
+pub mod metadata_global_address_value;
+pub use self::metadata_global_address_value::MetadataGlobalAddressValue;
+pub mod metadata_i32_array_value;
+pub use self::metadata_i32_array_value::MetadataI32ArrayValue;
+pub mod metadata_i32_value;
+pub use self::metadata_i32_value::MetadataI32Value;
+pub mod metadata_i64_array_value;
+pub use self::metadata_i64_array_value::MetadataI64ArrayValue;
+pub mod metadata_i64_value;
+pub use self::metadata_i64_value::MetadataI64Value;
+pub mod metadata_instant_array_value;
+pub use self::metadata_instant_array_value::MetadataInstantArrayValue;
+pub mod metadata_instant_value;
+pub use self::metadata_instant_value::MetadataInstantValue;
+pub mod metadata_non_fungible_global_id_array_value;
+pub use self::metadata_non_fungible_global_id_array_value::MetadataNonFungibleGlobalIdArrayValue;
+pub mod metadata_non_fungible_global_id_array_value_all_of_values;
+pub use self::metadata_non_fungible_global_id_array_value_all_of_values::MetadataNonFungibleGlobalIdArrayValueAllOfValues;
+pub mod metadata_non_fungible_global_id_value;
+pub use self::metadata_non_fungible_global_id_value::MetadataNonFungibleGlobalIdValue;
+pub mod metadata_non_fungible_local_id_array_value;
+pub use self::metadata_non_fungible_local_id_array_value::MetadataNonFungibleLocalIdArrayValue;
+pub mod metadata_non_fungible_local_id_value;
+pub use self::metadata_non_fungible_local_id_value::MetadataNonFungibleLocalIdValue;
+pub mod metadata_origin_array_value;
+pub use self::metadata_origin_array_value::MetadataOriginArrayValue;
+pub mod metadata_origin_value;
+pub use self::metadata_origin_value::MetadataOriginValue;
+pub mod metadata_public_key_array_value;
+pub use self::metadata_public_key_array_value::MetadataPublicKeyArrayValue;
+pub mod metadata_public_key_hash_array_value;
+pub use self::metadata_public_key_hash_array_value::MetadataPublicKeyHashArrayValue;
+pub mod metadata_public_key_hash_value;
+pub use self::metadata_public_key_hash_value::MetadataPublicKeyHashValue;
+pub mod metadata_public_key_value;
+pub use self::metadata_public_key_value::MetadataPublicKeyValue;
+pub mod metadata_string_array_value;
+pub use self::metadata_string_array_value::MetadataStringArrayValue;
+pub mod metadata_string_value;
+pub use self::metadata_string_value::MetadataStringValue;
+pub mod metadata_typed_value;
+pub use self::metadata_typed_value::MetadataTypedValue;
+pub mod metadata_u32_array_value;
+pub use self::metadata_u32_array_value::MetadataU32ArrayValue;
+pub mod metadata_u32_value;
+pub use self::metadata_u32_value::MetadataU32Value;
+pub mod metadata_u64_array_value;
+pub use self::metadata_u64_array_value::MetadataU64ArrayValue;
+pub mod metadata_u64_value;
+pub use self::metadata_u64_value::MetadataU64Value;
+pub mod metadata_u8_array_value;
+pub use self::metadata_u8_array_value::MetadataU8ArrayValue;
+pub mod metadata_u8_value;
+pub use self::metadata_u8_value::MetadataU8Value;
+pub mod metadata_url_array_value;
+pub use self::metadata_url_array_value::MetadataUrlArrayValue;
+pub mod metadata_url_value;
+pub use self::metadata_url_value::MetadataUrlValue;
+pub mod metadata_value_type;
+pub use self::metadata_value_type::MetadataValueType;
+pub mod network_configuration_response;
+pub use self::network_configuration_response::NetworkConfigurationResponse;
+pub mod network_configuration_response_well_known_addresses;
+pub use self::network_configuration_response_well_known_addresses::NetworkConfigurationResponseWellKnownAddresses;
+pub mod non_fungible_id_type;
+pub use self::non_fungible_id_type::NonFungibleIdType;
+pub mod non_fungible_ids_collection;
+pub use self::non_fungible_ids_collection::NonFungibleIdsCollection;
+pub mod non_fungible_resources_collection;
+pub use self::non_fungible_resources_collection::NonFungibleResourcesCollection;
+pub mod non_fungible_resources_collection_item;
+pub use self::non_fungible_resources_collection_item::NonFungibleResourcesCollectionItem;
+pub mod non_fungible_resources_collection_item_globally_aggregated;
+pub use self::non_fungible_resources_collection_item_globally_aggregated::NonFungibleResourcesCollectionItemGloballyAggregated;
+pub mod non_fungible_resources_collection_item_vault_aggregated;
+pub use self::non_fungible_resources_collection_item_vault_aggregated::NonFungibleResourcesCollectionItemVaultAggregated;
+pub mod non_fungible_resources_collection_item_vault_aggregated_vault;
+pub use self::non_fungible_resources_collection_item_vault_aggregated_vault::NonFungibleResourcesCollectionItemVaultAggregatedVault;
+pub mod non_fungible_resources_collection_item_vault_aggregated_vault_item;
+pub use self::non_fungible_resources_collection_item_vault_aggregated_vault_item::NonFungibleResourcesCollectionItemVaultAggregatedVaultItem;
+pub mod not_synced_up_error;
+pub use self::not_synced_up_error::NotSyncedUpError;
+pub mod object_module_id;
+pub use self::object_module_id::ObjectModuleId;
+pub mod optional_non_fungible_ids_collection;
+pub use self::optional_non_fungible_ids_collection::OptionalNonFungibleIdsCollection;
+pub mod package_vm_type;
+pub use self::package_vm_type::PackageVmType;
+pub mod programmatic_scrypto_sbor_value;
+pub use self::programmatic_scrypto_sbor_value::ProgrammaticScryptoSborValue;
+pub mod programmatic_scrypto_sbor_value_array;
+pub use self::programmatic_scrypto_sbor_value_array::ProgrammaticScryptoSborValueArray;
+pub mod programmatic_scrypto_sbor_value_bool;
+pub use self::programmatic_scrypto_sbor_value_bool::ProgrammaticScryptoSborValueBool;
+pub mod programmatic_scrypto_sbor_value_bytes;
+pub use self::programmatic_scrypto_sbor_value_bytes::ProgrammaticScryptoSborValueBytes;
+pub mod programmatic_scrypto_sbor_value_decimal;
+pub use self::programmatic_scrypto_sbor_value_decimal::ProgrammaticScryptoSborValueDecimal;
+pub mod programmatic_scrypto_sbor_value_enum;
+pub use self::programmatic_scrypto_sbor_value_enum::ProgrammaticScryptoSborValueEnum;
+pub mod programmatic_scrypto_sbor_value_i128;
+pub use self::programmatic_scrypto_sbor_value_i128::ProgrammaticScryptoSborValueI128;
+pub mod programmatic_scrypto_sbor_value_i16;
+pub use self::programmatic_scrypto_sbor_value_i16::ProgrammaticScryptoSborValueI16;
+pub mod programmatic_scrypto_sbor_value_i32;
+pub use self::programmatic_scrypto_sbor_value_i32::ProgrammaticScryptoSborValueI32;
+pub mod programmatic_scrypto_sbor_value_i64;
+pub use self::programmatic_scrypto_sbor_value_i64::ProgrammaticScryptoSborValueI64;
+pub mod programmatic_scrypto_sbor_value_i8;
+pub use self::programmatic_scrypto_sbor_value_i8::ProgrammaticScryptoSborValueI8;
+pub mod programmatic_scrypto_sbor_value_kind;
+pub use self::programmatic_scrypto_sbor_value_kind::ProgrammaticScryptoSborValueKind;
+pub mod programmatic_scrypto_sbor_value_map;
+pub use self::programmatic_scrypto_sbor_value_map::ProgrammaticScryptoSborValueMap;
+pub mod programmatic_scrypto_sbor_value_map_entry;
+pub use self::programmatic_scrypto_sbor_value_map_entry::ProgrammaticScryptoSborValueMapEntry;
+pub mod programmatic_scrypto_sbor_value_non_fungible_local_id;
+pub use self::programmatic_scrypto_sbor_value_non_fungible_local_id::ProgrammaticScryptoSborValueNonFungibleLocalId;
+pub mod programmatic_scrypto_sbor_value_own;
+pub use self::programmatic_scrypto_sbor_value_own::ProgrammaticScryptoSborValueOwn;
+pub mod programmatic_scrypto_sbor_value_precise_decimal;
+pub use self::programmatic_scrypto_sbor_value_precise_decimal::ProgrammaticScryptoSborValuePreciseDecimal;
+pub mod programmatic_scrypto_sbor_value_reference;
+pub use self::programmatic_scrypto_sbor_value_reference::ProgrammaticScryptoSborValueReference;
+pub mod programmatic_scrypto_sbor_value_string;
+pub use self::programmatic_scrypto_sbor_value_string::ProgrammaticScryptoSborValueString;
+pub mod programmatic_scrypto_sbor_value_tuple;
+pub use self::programmatic_scrypto_sbor_value_tuple::ProgrammaticScryptoSborValueTuple;
+pub mod programmatic_scrypto_sbor_value_u128;
+pub use self::programmatic_scrypto_sbor_value_u128::ProgrammaticScryptoSborValueU128;
+pub mod programmatic_scrypto_sbor_value_u16;
+pub use self::programmatic_scrypto_sbor_value_u16::ProgrammaticScryptoSborValueU16;
+pub mod programmatic_scrypto_sbor_value_u32;
+pub use self::programmatic_scrypto_sbor_value_u32::ProgrammaticScryptoSborValueU32;
+pub mod programmatic_scrypto_sbor_value_u64;
+pub use self::programmatic_scrypto_sbor_value_u64::ProgrammaticScryptoSborValueU64;
+pub mod programmatic_scrypto_sbor_value_u8;
+pub use self::programmatic_scrypto_sbor_value_u8::ProgrammaticScryptoSborValueU8;
+pub mod public_key;
+pub use self::public_key::PublicKey;
+pub mod public_key_ecdsa_secp256k1;
+pub use self::public_key_ecdsa_secp256k1::PublicKeyEcdsaSecp256k1;
+pub mod public_key_eddsa_ed25519;
+pub use self::public_key_eddsa_ed25519::PublicKeyEddsaEd25519;
+pub mod public_key_hash;
+pub use self::public_key_hash::PublicKeyHash;
+pub mod public_key_hash_ecdsa_secp256k1;
+pub use self::public_key_hash_ecdsa_secp256k1::PublicKeyHashEcdsaSecp256k1;
+pub mod public_key_hash_eddsa_ed25519;
+pub use self::public_key_hash_eddsa_ed25519::PublicKeyHashEddsaEd25519;
+pub mod public_key_hash_type;
+pub use self::public_key_hash_type::PublicKeyHashType;
+pub mod public_key_type;
+pub use self::public_key_type::PublicKeyType;
+pub mod resource_aggregation_level;
+pub use self::resource_aggregation_level::ResourceAggregationLevel;
+pub mod result_set_cursor_mixin;
+pub use self::result_set_cursor_mixin::ResultSetCursorMixin;
+pub mod role_assignment_resolution;
+pub use self::role_assignment_resolution::RoleAssignmentResolution;
+pub mod role_key;
+pub use self::role_key::RoleKey;
+pub mod scrypto_sbor_value;
+pub use self::scrypto_sbor_value::ScryptoSborValue;
+pub mod state_entity_details_opt_ins;
+pub use self::state_entity_details_opt_ins::StateEntityDetailsOptIns;
+pub mod state_entity_details_request;
+pub use self::state_entity_details_request::StateEntityDetailsRequest;
+pub mod state_entity_details_response;
+pub use self::state_entity_details_response::StateEntityDetailsResponse;
+pub mod state_entity_details_response_component_details;
+pub use self::state_entity_details_response_component_details::StateEntityDetailsResponseComponentDetails;
+pub mod state_entity_details_response_fungible_resource_details;
+pub use self::state_entity_details_response_fungible_resource_details::StateEntityDetailsResponseFungibleResourceDetails;
+pub mod state_entity_details_response_fungible_vault_details;
+pub use self::state_entity_details_response_fungible_vault_details::StateEntityDetailsResponseFungibleVaultDetails;
+pub mod state_entity_details_response_item;
+pub use self::state_entity_details_response_item::StateEntityDetailsResponseItem;
+pub mod state_entity_details_response_item_ancestor_identities;
+pub use self::state_entity_details_response_item_ancestor_identities::StateEntityDetailsResponseItemAncestorIdentities;
+pub mod state_entity_details_response_item_details;
+pub use self::state_entity_details_response_item_details::StateEntityDetailsResponseItemDetails;
+pub mod state_entity_details_response_item_details_type;
+pub use self::state_entity_details_response_item_details_type::StateEntityDetailsResponseItemDetailsType;
+pub mod state_entity_details_response_non_fungible_resource_details;
+pub use self::state_entity_details_response_non_fungible_resource_details::StateEntityDetailsResponseNonFungibleResourceDetails;
+pub mod state_entity_details_response_non_fungible_vault_details;
+pub use self::state_entity_details_response_non_fungible_vault_details::StateEntityDetailsResponseNonFungibleVaultDetails;
+pub mod state_entity_details_response_package_details;
+pub use self::state_entity_details_response_package_details::StateEntityDetailsResponsePackageDetails;
+pub mod state_entity_details_response_package_details_blueprint_collection;
+pub use self::state_entity_details_response_package_details_blueprint_collection::StateEntityDetailsResponsePackageDetailsBlueprintCollection;
+pub mod state_entity_details_response_package_details_blueprint_item;
+pub use self::state_entity_details_response_package_details_blueprint_item::StateEntityDetailsResponsePackageDetailsBlueprintItem;
+pub mod state_entity_details_response_package_details_schema_collection;
+pub use self::state_entity_details_response_package_details_schema_collection::StateEntityDetailsResponsePackageDetailsSchemaCollection;
+pub mod state_entity_details_response_package_details_schema_item;
+pub use self::state_entity_details_response_package_details_schema_item::StateEntityDetailsResponsePackageDetailsSchemaItem;
+pub mod state_entity_fungible_resource_vaults_page_request;
+pub use self::state_entity_fungible_resource_vaults_page_request::StateEntityFungibleResourceVaultsPageRequest;
+pub mod state_entity_fungible_resource_vaults_page_response;
+pub use self::state_entity_fungible_resource_vaults_page_response::StateEntityFungibleResourceVaultsPageResponse;
+pub mod state_entity_fungibles_page_request;
+pub use self::state_entity_fungibles_page_request::StateEntityFungiblesPageRequest;
+pub mod state_entity_fungibles_page_request_opt_ins;
+pub use self::state_entity_fungibles_page_request_opt_ins::StateEntityFungiblesPageRequestOptIns;
+pub mod state_entity_fungibles_page_response;
+pub use self::state_entity_fungibles_page_response::StateEntityFungiblesPageResponse;
+pub mod state_entity_metadata_page_request;
+pub use self::state_entity_metadata_page_request::StateEntityMetadataPageRequest;
+pub mod state_entity_metadata_page_response;
+pub use self::state_entity_metadata_page_response::StateEntityMetadataPageResponse;
+pub mod state_entity_non_fungible_ids_page_request;
+pub use self::state_entity_non_fungible_ids_page_request::StateEntityNonFungibleIdsPageRequest;
+pub mod state_entity_non_fungible_ids_page_response;
+pub use self::state_entity_non_fungible_ids_page_response::StateEntityNonFungibleIdsPageResponse;
+pub mod state_entity_non_fungible_resource_vaults_page_opt_ins;
+pub use self::state_entity_non_fungible_resource_vaults_page_opt_ins::StateEntityNonFungibleResourceVaultsPageOptIns;
+pub mod state_entity_non_fungible_resource_vaults_page_request;
+pub use self::state_entity_non_fungible_resource_vaults_page_request::StateEntityNonFungibleResourceVaultsPageRequest;
+pub mod state_entity_non_fungible_resource_vaults_page_response;
+pub use self::state_entity_non_fungible_resource_vaults_page_response::StateEntityNonFungibleResourceVaultsPageResponse;
+pub mod state_entity_non_fungibles_page_request;
+pub use self::state_entity_non_fungibles_page_request::StateEntityNonFungiblesPageRequest;
+pub mod state_entity_non_fungibles_page_request_opt_ins;
+pub use self::state_entity_non_fungibles_page_request_opt_ins::StateEntityNonFungiblesPageRequestOptIns;
+pub mod state_entity_non_fungibles_page_response;
+pub use self::state_entity_non_fungibles_page_response::StateEntityNonFungiblesPageResponse;
+pub mod state_key_value_store_data_request;
+pub use self::state_key_value_store_data_request::StateKeyValueStoreDataRequest;
+pub mod state_key_value_store_data_request_key_item;
+pub use self::state_key_value_store_data_request_key_item::StateKeyValueStoreDataRequestKeyItem;
+pub mod state_key_value_store_data_response;
+pub use self::state_key_value_store_data_response::StateKeyValueStoreDataResponse;
+pub mod state_key_value_store_data_response_item;
+pub use self::state_key_value_store_data_response_item::StateKeyValueStoreDataResponseItem;
+pub mod state_non_fungible_data_request;
+pub use self::state_non_fungible_data_request::StateNonFungibleDataRequest;
+pub mod state_non_fungible_data_response;
+pub use self::state_non_fungible_data_response::StateNonFungibleDataResponse;
+pub mod state_non_fungible_details_response_item;
+pub use self::state_non_fungible_details_response_item::StateNonFungibleDetailsResponseItem;
+pub mod state_non_fungible_ids_request;
+pub use self::state_non_fungible_ids_request::StateNonFungibleIdsRequest;
+pub mod state_non_fungible_ids_response;
+pub use self::state_non_fungible_ids_response::StateNonFungibleIdsResponse;
+pub mod state_non_fungible_location_request;
+pub use self::state_non_fungible_location_request::StateNonFungibleLocationRequest;
+pub mod state_non_fungible_location_response;
+pub use self::state_non_fungible_location_response::StateNonFungibleLocationResponse;
+pub mod state_non_fungible_location_response_item;
+pub use self::state_non_fungible_location_response_item::StateNonFungibleLocationResponseItem;
+pub mod state_validators_list_request;
+pub use self::state_validators_list_request::StateValidatorsListRequest;
+pub mod state_validators_list_response;
+pub use self::state_validators_list_response::StateValidatorsListResponse;
+pub mod stream_transactions_request;
+pub use self::stream_transactions_request::StreamTransactionsRequest;
+pub mod stream_transactions_request_event_filter_item;
+pub use self::stream_transactions_request_event_filter_item::StreamTransactionsRequestEventFilterItem;
+pub mod stream_transactions_response;
+pub use self::stream_transactions_response::StreamTransactionsResponse;
+pub mod transaction_balance_changes;
+pub use self::transaction_balance_changes::TransactionBalanceChanges;
+pub mod transaction_committed_details_request;
+pub use self::transaction_committed_details_request::TransactionCommittedDetailsRequest;
+pub mod transaction_committed_details_response;
+pub use self::transaction_committed_details_response::TransactionCommittedDetailsResponse;
+pub mod transaction_construction_response;
+pub use self::transaction_construction_response::TransactionConstructionResponse;
+pub mod transaction_details_opt_ins;
+pub use self::transaction_details_opt_ins::TransactionDetailsOptIns;
+pub mod transaction_fungible_balance_changes;
+pub use self::transaction_fungible_balance_changes::TransactionFungibleBalanceChanges;
+pub mod transaction_fungible_fee_balance_change_type;
+pub use self::transaction_fungible_fee_balance_change_type::TransactionFungibleFeeBalanceChangeType;
+pub mod transaction_fungible_fee_balance_changes;
+pub use self::transaction_fungible_fee_balance_changes::TransactionFungibleFeeBalanceChanges;
+pub mod transaction_intent_status;
+pub use self::transaction_intent_status::TransactionIntentStatus;
+pub mod transaction_non_fungible_balance_changes;
+pub use self::transaction_non_fungible_balance_changes::TransactionNonFungibleBalanceChanges;
+pub mod transaction_not_found_error;
+pub use self::transaction_not_found_error::TransactionNotFoundError;
+pub mod transaction_payload_gateway_handling_status;
+pub use self::transaction_payload_gateway_handling_status::TransactionPayloadGatewayHandlingStatus;
+pub mod transaction_payload_status;
+pub use self::transaction_payload_status::TransactionPayloadStatus;
+pub mod transaction_preview_request;
+pub use self::transaction_preview_request::TransactionPreviewRequest;
+pub mod transaction_preview_request_flags;
+pub use self::transaction_preview_request_flags::TransactionPreviewRequestFlags;
+pub mod transaction_preview_response;
+pub use self::transaction_preview_response::TransactionPreviewResponse;
+pub mod transaction_preview_response_logs_inner;
+pub use self::transaction_preview_response_logs_inner::TransactionPreviewResponseLogsInner;
+pub mod transaction_receipt;
+pub use self::transaction_receipt::{Entity, StateUpdates, TransactionReceipt};
+pub mod transaction_status;
+pub use self::transaction_status::TransactionStatus;
+pub mod transaction_status_request;
+pub use self::transaction_status_request::TransactionStatusRequest;
+pub mod transaction_status_response;
+pub use self::transaction_status_response::TransactionStatusResponse;
+pub mod transaction_status_response_known_payload_item;
+pub use self::transaction_status_response_known_payload_item::TransactionStatusResponseKnownPayloadItem;
+pub mod transaction_submit_request;
+pub use self::transaction_submit_request::TransactionSubmitRequest;
+pub mod transaction_submit_response;
+pub use self::transaction_submit_response::TransactionSubmitResponse;
+pub mod validation_errors_at_path;
+pub use self::validation_errors_at_path::ValidationErrorsAtPath;
+pub mod validator_collection;
+pub use self::validator_collection::ValidatorCollection;
+pub mod validator_collection_item;
+pub use self::validator_collection_item::ValidatorCollectionItem;
+pub mod validator_collection_item_active_in_epoch;
+pub use self::validator_collection_item_active_in_epoch::ValidatorCollectionItemActiveInEpoch;
+pub mod validator_collection_item_effective_fee_factor;
+pub use self::validator_collection_item_effective_fee_factor::ValidatorCollectionItemEffectiveFeeFactor;
+pub mod validator_collection_item_effective_fee_factor_current;
+pub use self::validator_collection_item_effective_fee_factor_current::ValidatorCollectionItemEffectiveFeeFactorCurrent;
+pub mod validator_collection_item_effective_fee_factor_pending;
+pub use self::validator_collection_item_effective_fee_factor_pending::ValidatorCollectionItemEffectiveFeeFactorPending;
+pub mod validator_uptime_collection;
+pub use self::validator_uptime_collection::ValidatorUptimeCollection;
+pub mod validator_uptime_collection_item;
+pub use self::validator_uptime_collection_item::ValidatorUptimeCollectionItem;
+pub mod validator_vault_item;
+pub use self::validator_vault_item::ValidatorVaultItem;
+pub mod validators_uptime_request;
+pub use self::validators_uptime_request::ValidatorsUptimeRequest;
+pub mod validators_uptime_response;
+pub use self::validators_uptime_response::ValidatorsUptimeResponse;
diff --git a/libraries/gateway-client/src/models/network_configuration_response.rs b/libraries/gateway-client/src/models/network_configuration_response.rs
new file mode 100644
index 00000000..3e646c61
--- /dev/null
+++ b/libraries/gateway-client/src/models/network_configuration_response.rs
@@ -0,0 +1,25 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NetworkConfigurationResponse {
+ #[serde(rename = "network_id")]
+ pub network_id: i32,
+
+ #[serde(rename = "network_name")]
+ pub network_name: String,
+ #[serde(rename = "well_known_addresses")]
+ pub well_known_addresses:
+ Box,
+}
+
+impl NetworkConfigurationResponse {
+ pub fn new(
+ network_id: i32,
+ network_name: String,
+ well_known_addresses: crate::models::NetworkConfigurationResponseWellKnownAddresses,
+ ) -> NetworkConfigurationResponse {
+ NetworkConfigurationResponse {
+ network_id,
+ network_name,
+ well_known_addresses: Box::new(well_known_addresses),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/network_configuration_response_well_known_addresses.rs b/libraries/gateway-client/src/models/network_configuration_response_well_known_addresses.rs
new file mode 100644
index 00000000..7e59d87a
--- /dev/null
+++ b/libraries/gateway-client/src/models/network_configuration_response_well_known_addresses.rs
@@ -0,0 +1,140 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NetworkConfigurationResponseWellKnownAddresses {
+ #[serde(rename = "xrd")]
+ pub xrd: String,
+
+ #[serde(rename = "secp256k1_signature_virtual_badge")]
+ pub secp256k1_signature_virtual_badge: String,
+
+ #[serde(rename = "ed25519_signature_virtual_badge")]
+ pub ed25519_signature_virtual_badge: String,
+
+ #[serde(rename = "package_of_direct_caller_virtual_badge")]
+ pub package_of_direct_caller_virtual_badge: String,
+
+ #[serde(rename = "global_caller_virtual_badge")]
+ pub global_caller_virtual_badge: String,
+
+ #[serde(rename = "system_transaction_badge")]
+ pub system_transaction_badge: String,
+
+ #[serde(rename = "package_owner_badge")]
+ pub package_owner_badge: String,
+
+ #[serde(rename = "validator_owner_badge")]
+ pub validator_owner_badge: String,
+
+ #[serde(rename = "account_owner_badge")]
+ pub account_owner_badge: String,
+
+ #[serde(rename = "identity_owner_badge")]
+ pub identity_owner_badge: String,
+
+ #[serde(rename = "package_package")]
+ pub package_package: String,
+
+ #[serde(rename = "resource_package")]
+ pub resource_package: String,
+
+ #[serde(rename = "account_package")]
+ pub account_package: String,
+
+ #[serde(rename = "identity_package")]
+ pub identity_package: String,
+
+ #[serde(rename = "consensus_manager_package")]
+ pub consensus_manager_package: String,
+
+ #[serde(rename = "access_controller_package")]
+ pub access_controller_package: String,
+
+ #[serde(rename = "transaction_processor_package")]
+ pub transaction_processor_package: String,
+
+ #[serde(rename = "metadata_module_package")]
+ pub metadata_module_package: String,
+
+ #[serde(rename = "royalty_module_package")]
+ pub royalty_module_package: String,
+
+ #[serde(rename = "access_rules_package")]
+ pub access_rules_package: String,
+
+ #[serde(rename = "genesis_helper_package")]
+ pub genesis_helper_package: String,
+
+ #[serde(rename = "faucet_package")]
+ pub faucet_package: String,
+
+ #[serde(rename = "consensus_manager")]
+ pub consensus_manager: String,
+
+ #[serde(rename = "genesis_helper")]
+ pub genesis_helper: String,
+
+ #[serde(rename = "faucet")]
+ pub faucet: String,
+
+ #[serde(rename = "pool_package")]
+ pub pool_package: String,
+}
+
+impl NetworkConfigurationResponseWellKnownAddresses {
+ pub fn new(
+ xrd: String,
+ secp256k1_signature_virtual_badge: String,
+ ed25519_signature_virtual_badge: String,
+ package_of_direct_caller_virtual_badge: String,
+ global_caller_virtual_badge: String,
+ system_transaction_badge: String,
+ package_owner_badge: String,
+ validator_owner_badge: String,
+ account_owner_badge: String,
+ identity_owner_badge: String,
+ package_package: String,
+ resource_package: String,
+ account_package: String,
+ identity_package: String,
+ consensus_manager_package: String,
+ access_controller_package: String,
+ transaction_processor_package: String,
+ metadata_module_package: String,
+ royalty_module_package: String,
+ access_rules_package: String,
+ genesis_helper_package: String,
+ faucet_package: String,
+ consensus_manager: String,
+ genesis_helper: String,
+ faucet: String,
+ pool_package: String,
+ ) -> NetworkConfigurationResponseWellKnownAddresses {
+ NetworkConfigurationResponseWellKnownAddresses {
+ xrd,
+ secp256k1_signature_virtual_badge,
+ ed25519_signature_virtual_badge,
+ package_of_direct_caller_virtual_badge,
+ global_caller_virtual_badge,
+ system_transaction_badge,
+ package_owner_badge,
+ validator_owner_badge,
+ account_owner_badge,
+ identity_owner_badge,
+ package_package,
+ resource_package,
+ account_package,
+ identity_package,
+ consensus_manager_package,
+ access_controller_package,
+ transaction_processor_package,
+ metadata_module_package,
+ royalty_module_package,
+ access_rules_package,
+ genesis_helper_package,
+ faucet_package,
+ consensus_manager,
+ genesis_helper,
+ faucet,
+ pool_package,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_id_type.rs b/libraries/gateway-client/src/models/non_fungible_id_type.rs
new file mode 100644
index 00000000..ca9bd66e
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_id_type.rs
@@ -0,0 +1,39 @@
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ PartialEq,
+ Ord,
+ PartialOrd,
+ Hash,
+ serde::Serialize,
+ serde::Deserialize,
+)]
+pub enum NonFungibleIdType {
+ #[serde(rename = "String")]
+ String,
+ #[serde(rename = "Integer")]
+ Integer,
+ #[serde(rename = "Bytes")]
+ Bytes,
+ #[serde(rename = "Ruid")]
+ Ruid,
+}
+
+impl ToString for NonFungibleIdType {
+ fn to_string(&self) -> String {
+ match self {
+ Self::String => String::from("String"),
+ Self::Integer => String::from("Integer"),
+ Self::Bytes => String::from("Bytes"),
+ Self::Ruid => String::from("Ruid"),
+ }
+ }
+}
+
+impl Default for NonFungibleIdType {
+ fn default() -> NonFungibleIdType {
+ Self::String
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_ids_collection.rs b/libraries/gateway-client/src/models/non_fungible_ids_collection.rs
new file mode 100644
index 00000000..6a4730b0
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_ids_collection.rs
@@ -0,0 +1,30 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleIdsCollection {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec,
+}
+
+impl NonFungibleIdsCollection {
+ pub fn new(items: Vec) -> NonFungibleIdsCollection {
+ NonFungibleIdsCollection {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection.rs
new file mode 100644
index 00000000..60e0460f
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection.rs
@@ -0,0 +1,32 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleResourcesCollection {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec,
+}
+
+impl NonFungibleResourcesCollection {
+ pub fn new(
+ items: Vec,
+ ) -> NonFungibleResourcesCollection {
+ NonFungibleResourcesCollection {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection_item.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection_item.rs
new file mode 100644
index 00000000..9139f899
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection_item.rs
@@ -0,0 +1,3 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "")]
+pub enum NonFungibleResourcesCollectionItem {}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection_item_globally_aggregated.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_globally_aggregated.rs
new file mode 100644
index 00000000..6f552ec8
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_globally_aggregated.rs
@@ -0,0 +1,36 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleResourcesCollectionItemGloballyAggregated {
+ #[serde(rename = "aggregation_level")]
+ pub aggregation_level: crate::models::ResourceAggregationLevel,
+
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+ #[serde(
+ rename = "explicit_metadata",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub explicit_metadata: Option>,
+
+ #[serde(rename = "amount")]
+ pub amount: i64,
+
+ #[serde(rename = "last_updated_at_state_version")]
+ pub last_updated_at_state_version: i64,
+}
+
+impl NonFungibleResourcesCollectionItemGloballyAggregated {
+ pub fn new(
+ aggregation_level: crate::models::ResourceAggregationLevel,
+ resource_address: String,
+ amount: i64,
+ last_updated_at_state_version: i64,
+ ) -> NonFungibleResourcesCollectionItemGloballyAggregated {
+ NonFungibleResourcesCollectionItemGloballyAggregated {
+ aggregation_level,
+ resource_address,
+ explicit_metadata: None,
+ amount,
+ last_updated_at_state_version,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated.rs
new file mode 100644
index 00000000..93b95973
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated.rs
@@ -0,0 +1,32 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleResourcesCollectionItemVaultAggregated {
+ #[serde(rename = "aggregation_level")]
+ pub aggregation_level: crate::models::ResourceAggregationLevel,
+
+ #[serde(rename = "resource_address")]
+ pub resource_address: String,
+ #[serde(
+ rename = "explicit_metadata",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub explicit_metadata: Option>,
+ #[serde(rename = "vaults")]
+ pub vaults: Box<
+ crate::models::NonFungibleResourcesCollectionItemVaultAggregatedVault,
+ >,
+}
+
+impl NonFungibleResourcesCollectionItemVaultAggregated {
+ pub fn new(
+ aggregation_level: crate::models::ResourceAggregationLevel,
+ resource_address: String,
+ vaults: crate::models::NonFungibleResourcesCollectionItemVaultAggregatedVault,
+ ) -> NonFungibleResourcesCollectionItemVaultAggregated {
+ NonFungibleResourcesCollectionItemVaultAggregated {
+ aggregation_level,
+ resource_address,
+ explicit_metadata: None,
+ vaults: Box::new(vaults),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault.rs
new file mode 100644
index 00000000..913b84f1
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault.rs
@@ -0,0 +1,23 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleResourcesCollectionItemVaultAggregatedVault {
+
+ #[serde(rename = "total_count", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
+ pub total_count: Option>,
+
+ #[serde(rename = "next_cursor", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
+ pub next_cursor: Option>,
+ #[serde(rename = "items")]
+ pub items: Vec,
+}
+
+impl NonFungibleResourcesCollectionItemVaultAggregatedVault {
+ pub fn new(
+ items: Vec,
+ ) -> NonFungibleResourcesCollectionItemVaultAggregatedVault {
+ NonFungibleResourcesCollectionItemVaultAggregatedVault {
+ total_count: None,
+ next_cursor: None,
+ items,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault_item.rs b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault_item.rs
new file mode 100644
index 00000000..be0c743e
--- /dev/null
+++ b/libraries/gateway-client/src/models/non_fungible_resources_collection_item_vault_aggregated_vault_item.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NonFungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ #[serde(rename = "total_count")]
+ pub total_count: i64,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items", skip_serializing_if = "Option::is_none")]
+ pub items: Option>,
+
+ #[serde(rename = "vault_address")]
+ pub vault_address: String,
+
+ #[serde(rename = "last_updated_at_state_version")]
+ pub last_updated_at_state_version: i64,
+}
+
+impl NonFungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ pub fn new(
+ total_count: i64,
+ vault_address: String,
+ last_updated_at_state_version: i64,
+ ) -> NonFungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ NonFungibleResourcesCollectionItemVaultAggregatedVaultItem {
+ total_count,
+ next_cursor: None,
+ items: None,
+ vault_address,
+ last_updated_at_state_version,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/not_synced_up_error.rs b/libraries/gateway-client/src/models/not_synced_up_error.rs
new file mode 100644
index 00000000..93e5d5bf
--- /dev/null
+++ b/libraries/gateway-client/src/models/not_synced_up_error.rs
@@ -0,0 +1,30 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct NotSyncedUpError {
+ #[serde(rename = "type")]
+ pub r#type: String,
+
+ #[serde(rename = "request_type")]
+ pub request_type: String,
+
+ #[serde(rename = "current_sync_delay_seconds")]
+ pub current_sync_delay_seconds: i64,
+
+ #[serde(rename = "max_allowed_sync_delay_seconds")]
+ pub max_allowed_sync_delay_seconds: i64,
+}
+
+impl NotSyncedUpError {
+ pub fn new(
+ r#type: String,
+ request_type: String,
+ current_sync_delay_seconds: i64,
+ max_allowed_sync_delay_seconds: i64,
+ ) -> NotSyncedUpError {
+ NotSyncedUpError {
+ r#type,
+ request_type,
+ current_sync_delay_seconds,
+ max_allowed_sync_delay_seconds,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/object_module_id.rs b/libraries/gateway-client/src/models/object_module_id.rs
new file mode 100644
index 00000000..d940c433
--- /dev/null
+++ b/libraries/gateway-client/src/models/object_module_id.rs
@@ -0,0 +1,39 @@
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ PartialEq,
+ Ord,
+ PartialOrd,
+ Hash,
+ serde::Serialize,
+ serde::Deserialize,
+)]
+pub enum ObjectModuleId {
+ #[serde(rename = "Main")]
+ Main,
+ #[serde(rename = "Metadata")]
+ Metadata,
+ #[serde(rename = "Royalty")]
+ Royalty,
+ #[serde(rename = "RoleAssignment")]
+ RoleAssignment,
+}
+
+impl ToString for ObjectModuleId {
+ fn to_string(&self) -> String {
+ match self {
+ Self::Main => String::from("Main"),
+ Self::Metadata => String::from("Metadata"),
+ Self::Royalty => String::from("Royalty"),
+ Self::RoleAssignment => String::from("RoleAssignment"),
+ }
+ }
+}
+
+impl Default for ObjectModuleId {
+ fn default() -> ObjectModuleId {
+ Self::Main
+ }
+}
diff --git a/libraries/gateway-client/src/models/optional_non_fungible_ids_collection.rs b/libraries/gateway-client/src/models/optional_non_fungible_ids_collection.rs
new file mode 100644
index 00000000..36906743
--- /dev/null
+++ b/libraries/gateway-client/src/models/optional_non_fungible_ids_collection.rs
@@ -0,0 +1,36 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct OptionalNonFungibleIdsCollection {
+ #[serde(
+ rename = "total_count",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub total_count: Option>,
+
+ #[serde(
+ rename = "next_cursor",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub next_cursor: Option>,
+ #[serde(rename = "items", skip_serializing_if = "Option::is_none")]
+ pub items: Option>,
+}
+
+impl Default for OptionalNonFungibleIdsCollection {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl OptionalNonFungibleIdsCollection {
+ pub fn new() -> OptionalNonFungibleIdsCollection {
+ OptionalNonFungibleIdsCollection {
+ total_count: None,
+ next_cursor: None,
+ items: None,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/package_vm_type.rs b/libraries/gateway-client/src/models/package_vm_type.rs
new file mode 100644
index 00000000..bb990329
--- /dev/null
+++ b/libraries/gateway-client/src/models/package_vm_type.rs
@@ -0,0 +1,33 @@
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ PartialEq,
+ Ord,
+ PartialOrd,
+ Hash,
+ serde::Serialize,
+ serde::Deserialize,
+)]
+pub enum PackageVmType {
+ #[serde(rename = "Native")]
+ Native,
+ #[serde(rename = "ScryptoV1")]
+ ScryptoV1,
+}
+
+impl ToString for PackageVmType {
+ fn to_string(&self) -> String {
+ match self {
+ Self::Native => String::from("Native"),
+ Self::ScryptoV1 => String::from("ScryptoV1"),
+ }
+ }
+}
+
+impl Default for PackageVmType {
+ fn default() -> PackageVmType {
+ Self::Native
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value.rs
new file mode 100644
index 00000000..260cf8bc
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value.rs
@@ -0,0 +1,3 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "")]
+pub enum ProgrammaticScryptoSborValue {}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_array.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_array.rs
new file mode 100644
index 00000000..a42b3e7e
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_array.rs
@@ -0,0 +1,47 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueArray {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "element_kind")]
+ pub element_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ #[serde(
+ rename = "element_type_name",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub element_type_name: Option,
+ #[serde(rename = "elements")]
+ pub elements: Vec,
+}
+
+impl ProgrammaticScryptoSborValueArray {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ element_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ elements: Vec,
+ ) -> ProgrammaticScryptoSborValueArray {
+ ProgrammaticScryptoSborValueArray {
+ kind,
+ type_name: None,
+ field_name: None,
+ element_kind,
+ element_type_name: None,
+ elements,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bool.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bool.rs
new file mode 100644
index 00000000..e8c9adf6
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bool.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueBool {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: bool,
+}
+
+impl ProgrammaticScryptoSborValueBool {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: bool,
+ ) -> ProgrammaticScryptoSborValueBool {
+ ProgrammaticScryptoSborValueBool {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bytes.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bytes.rs
new file mode 100644
index 00000000..1afc7c36
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_bytes.rs
@@ -0,0 +1,48 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueBytes {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "element_kind")]
+ pub element_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ #[serde(
+ rename = "element_type_name",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub element_type_name: Option,
+
+ #[serde(rename = "hex")]
+ pub hex: String,
+}
+
+impl ProgrammaticScryptoSborValueBytes {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ element_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ hex: String,
+ ) -> ProgrammaticScryptoSborValueBytes {
+ ProgrammaticScryptoSborValueBytes {
+ kind,
+ type_name: None,
+ field_name: None,
+ element_kind,
+ element_type_name: None,
+ hex,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_decimal.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_decimal.rs
new file mode 100644
index 00000000..a813f189
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_decimal.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueDecimal {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueDecimal {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueDecimal {
+ ProgrammaticScryptoSborValueDecimal {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_enum.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_enum.rs
new file mode 100644
index 00000000..1fa9a290
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_enum.rs
@@ -0,0 +1,44 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueEnum {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "variant_id")]
+ pub variant_id: i32,
+ #[serde(rename = "variant_name", skip_serializing_if = "Option::is_none")]
+ pub variant_name: Option,
+ #[serde(rename = "fields")]
+ pub fields: Vec,
+}
+
+impl ProgrammaticScryptoSborValueEnum {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ variant_id: i32,
+ fields: Vec,
+ ) -> ProgrammaticScryptoSborValueEnum {
+ ProgrammaticScryptoSborValueEnum {
+ kind,
+ type_name: None,
+ field_name: None,
+ variant_id,
+ variant_name: None,
+ fields,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i128.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i128.rs
new file mode 100644
index 00000000..8e29f78f
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i128.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueI128 {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueI128 {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueI128 {
+ ProgrammaticScryptoSborValueI128 {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i16.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i16.rs
new file mode 100644
index 00000000..0f75087b
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i16.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueI16 {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueI16 {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueI16 {
+ ProgrammaticScryptoSborValueI16 {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i32.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i32.rs
new file mode 100644
index 00000000..0865863e
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i32.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueI32 {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueI32 {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueI32 {
+ ProgrammaticScryptoSborValueI32 {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i64.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i64.rs
new file mode 100644
index 00000000..2e7c934f
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i64.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueI64 {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueI64 {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueI64 {
+ ProgrammaticScryptoSborValueI64 {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i8.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i8.rs
new file mode 100644
index 00000000..fa56cc58
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_i8.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueI8 {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueI8 {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueI8 {
+ ProgrammaticScryptoSborValueI8 {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_kind.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_kind.rs
new file mode 100644
index 00000000..4d19b7e0
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_kind.rs
@@ -0,0 +1,93 @@
+#[derive(
+ Clone,
+ Copy,
+ Debug,
+ Eq,
+ PartialEq,
+ Ord,
+ PartialOrd,
+ Hash,
+ serde::Serialize,
+ serde::Deserialize,
+)]
+pub enum ProgrammaticScryptoSborValueKind {
+ #[serde(rename = "Bool")]
+ Bool,
+ #[serde(rename = "I8")]
+ I8,
+ #[serde(rename = "I16")]
+ I16,
+ #[serde(rename = "I32")]
+ I32,
+ #[serde(rename = "I64")]
+ I64,
+ #[serde(rename = "I128")]
+ I128,
+ #[serde(rename = "U8")]
+ U8,
+ #[serde(rename = "U16")]
+ U16,
+ #[serde(rename = "U32")]
+ U32,
+ #[serde(rename = "U64")]
+ U64,
+ #[serde(rename = "U128")]
+ U128,
+ #[serde(rename = "String")]
+ String,
+ #[serde(rename = "Enum")]
+ Enum,
+ #[serde(rename = "Array")]
+ Array,
+ #[serde(rename = "Bytes")]
+ Bytes,
+ #[serde(rename = "Map")]
+ Map,
+ #[serde(rename = "Tuple")]
+ Tuple,
+ #[serde(rename = "Reference")]
+ Reference,
+ #[serde(rename = "Own")]
+ Own,
+ #[serde(rename = "Decimal")]
+ Decimal,
+ #[serde(rename = "PreciseDecimal")]
+ PreciseDecimal,
+ #[serde(rename = "NonFungibleLocalId")]
+ NonFungibleLocalId,
+}
+
+impl ToString for ProgrammaticScryptoSborValueKind {
+ fn to_string(&self) -> String {
+ match self {
+ Self::Bool => String::from("Bool"),
+ Self::I8 => String::from("I8"),
+ Self::I16 => String::from("I16"),
+ Self::I32 => String::from("I32"),
+ Self::I64 => String::from("I64"),
+ Self::I128 => String::from("I128"),
+ Self::U8 => String::from("U8"),
+ Self::U16 => String::from("U16"),
+ Self::U32 => String::from("U32"),
+ Self::U64 => String::from("U64"),
+ Self::U128 => String::from("U128"),
+ Self::String => String::from("String"),
+ Self::Enum => String::from("Enum"),
+ Self::Array => String::from("Array"),
+ Self::Bytes => String::from("Bytes"),
+ Self::Map => String::from("Map"),
+ Self::Tuple => String::from("Tuple"),
+ Self::Reference => String::from("Reference"),
+ Self::Own => String::from("Own"),
+ Self::Decimal => String::from("Decimal"),
+ Self::PreciseDecimal => String::from("PreciseDecimal"),
+ Self::NonFungibleLocalId => String::from("NonFungibleLocalId"),
+ }
+ }
+}
+
+impl Default for ProgrammaticScryptoSborValueKind {
+ fn default() -> ProgrammaticScryptoSborValueKind {
+ Self::Bool
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map.rs
new file mode 100644
index 00000000..2da55594
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map.rs
@@ -0,0 +1,54 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueMap {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "key_kind")]
+ pub key_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ #[serde(rename = "key_type_name", skip_serializing_if = "Option::is_none")]
+ pub key_type_name: Option,
+ #[serde(rename = "value_kind")]
+ pub value_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ #[serde(
+ rename = "value_type_name",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub value_type_name: Option,
+ #[serde(rename = "entries")]
+ pub entries: Vec,
+}
+
+impl ProgrammaticScryptoSborValueMap {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ key_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value_kind: crate::models::ProgrammaticScryptoSborValueKind,
+ entries: Vec,
+ ) -> ProgrammaticScryptoSborValueMap {
+ ProgrammaticScryptoSborValueMap {
+ kind,
+ type_name: None,
+ field_name: None,
+ key_kind,
+ key_type_name: None,
+ value_kind,
+ value_type_name: None,
+ entries,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map_entry.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map_entry.rs
new file mode 100644
index 00000000..b37dfaa3
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_map_entry.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueMapEntry {
+ #[serde(rename = "key")]
+ pub key: Box,
+ #[serde(rename = "value")]
+ pub value: Box,
+}
+
+impl ProgrammaticScryptoSborValueMapEntry {
+ pub fn new(
+ key: crate::models::ProgrammaticScryptoSborValue,
+ value: crate::models::ProgrammaticScryptoSborValue,
+ ) -> ProgrammaticScryptoSborValueMapEntry {
+ ProgrammaticScryptoSborValueMapEntry {
+ key: Box::new(key),
+ value: Box::new(value),
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_non_fungible_local_id.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_non_fungible_local_id.rs
new file mode 100644
index 00000000..50daa711
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_non_fungible_local_id.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueNonFungibleLocalId {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueNonFungibleLocalId {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueNonFungibleLocalId {
+ ProgrammaticScryptoSborValueNonFungibleLocalId {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_own.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_own.rs
new file mode 100644
index 00000000..3a944eb7
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_own.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueOwn {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueOwn {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueOwn {
+ ProgrammaticScryptoSborValueOwn {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_precise_decimal.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_precise_decimal.rs
new file mode 100644
index 00000000..9823e998
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_precise_decimal.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValuePreciseDecimal {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValuePreciseDecimal {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValuePreciseDecimal {
+ ProgrammaticScryptoSborValuePreciseDecimal {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_reference.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_reference.rs
new file mode 100644
index 00000000..44078bc5
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_reference.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueReference {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueReference {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueReference {
+ ProgrammaticScryptoSborValueReference {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_string.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_string.rs
new file mode 100644
index 00000000..277848ef
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_string.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueString {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "value")]
+ pub value: String,
+}
+
+impl ProgrammaticScryptoSborValueString {
+ pub fn new(
+ kind: crate::models::ProgrammaticScryptoSborValueKind,
+ value: String,
+ ) -> ProgrammaticScryptoSborValueString {
+ ProgrammaticScryptoSborValueString {
+ kind,
+ type_name: None,
+ field_name: None,
+ value,
+ }
+ }
+}
diff --git a/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_tuple.rs b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_tuple.rs
new file mode 100644
index 00000000..8c154c07
--- /dev/null
+++ b/libraries/gateway-client/src/models/programmatic_scrypto_sbor_value_tuple.rs
@@ -0,0 +1,37 @@
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ProgrammaticScryptoSborValueTuple {
+ #[serde(rename = "kind")]
+ pub kind: crate::models::ProgrammaticScryptoSborValueKind,
+
+ #[serde(
+ rename = "type_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub type_name: Option>,
+
+ #[serde(
+ rename = "field_name",
+ default,
+ with = "::serde_with::rust::double_option",
+ skip_serializing_if = "Option::is_none"
+ )]
+ pub field_name: Option>,
+ #[serde(rename = "fields")]
+ pub fields: Vec