diff --git a/src/integrationTest/java/io/sui/SuiClientImplIntTests.java b/src/integrationTest/java/io/sui/SuiClientImplIntTests.java index a54698a..f4cb25f 100644 --- a/src/integrationTest/java/io/sui/SuiClientImplIntTests.java +++ b/src/integrationTest/java/io/sui/SuiClientImplIntTests.java @@ -28,9 +28,11 @@ import io.sui.models.events.EventQuery.TransactionEventQuery; import io.sui.models.events.PaginatedEvents; import io.sui.models.objects.GetObjectResponse; +import io.sui.models.objects.MoveNormalizedModule; import io.sui.models.objects.SuiObjectInfo; import io.sui.models.transactions.TransactionResponse; import java.util.List; +import java.util.Map; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import org.junit.jupiter.api.BeforeAll; @@ -51,6 +53,7 @@ class SuiClientImplIntTests { private static SuiClient client; + /** Before all. */ @BeforeAll static void beforeAll() { JsonRpcClientProvider jsonRpcClientProvider = @@ -316,6 +319,20 @@ void getEvents() throws ExecutionException, InterruptedException { System.out.println(res.get()); } + /** + * Gets normalized move modules by package. + * + * @throws ExecutionException the execution exception + * @throws InterruptedException the interrupted exception + */ + @Test + @DisplayName("Test getNormalizedMoveModulesByPackage.") + void getNormalizedMoveModulesByPackage() throws ExecutionException, InterruptedException { + CompletableFuture> res = + client.getNormalizedMoveModulesByPackage("0x0000000000000000000000000000000000000002"); + System.out.println(res.get()); + } + /** * Gets committee info. * diff --git a/src/main/java/io/sui/SuiClient.java b/src/main/java/io/sui/SuiClient.java index bf17c97..253b3bc 100644 --- a/src/main/java/io/sui/SuiClient.java +++ b/src/main/java/io/sui/SuiClient.java @@ -22,9 +22,11 @@ import io.sui.models.events.EventQuery; import io.sui.models.events.PaginatedEvents; import io.sui.models.objects.GetObjectResponse; +import io.sui.models.objects.MoveNormalizedModule; import io.sui.models.objects.SuiObjectInfo; import io.sui.models.transactions.TransactionResponse; import java.util.List; +import java.util.Map; import java.util.concurrent.CompletableFuture; /** @@ -103,6 +105,15 @@ public interface SuiClient { CompletableFuture getEvents( EventQuery query, EventId cursor, int limit, boolean isDescOrder); + /** + * Gets normalized move modules by package. + * + * @param packageId the package id + * @return the normalized move modules by package + */ + CompletableFuture> getNormalizedMoveModulesByPackage( + String packageId); + /** * Gets committee info. * diff --git a/src/main/java/io/sui/SuiClientImpl.java b/src/main/java/io/sui/SuiClientImpl.java index f520a48..40df4ba 100644 --- a/src/main/java/io/sui/SuiClientImpl.java +++ b/src/main/java/io/sui/SuiClientImpl.java @@ -27,10 +27,12 @@ import io.sui.models.events.EventQuery; import io.sui.models.events.PaginatedEvents; import io.sui.models.objects.GetObjectResponse; +import io.sui.models.objects.MoveNormalizedModule; import io.sui.models.objects.SuiObjectInfo; import io.sui.models.transactions.TransactionResponse; import java.lang.reflect.Type; import java.util.List; +import java.util.Map; import java.util.concurrent.CompletableFuture; /** @@ -114,6 +116,18 @@ public CompletableFuture getEvents( return call("/sui_getEvents", request, new TypeToken() {}.getType()); } + @Override + public CompletableFuture> getNormalizedMoveModulesByPackage( + String packageId) { + final JsonRpc20Request request = + createJsonRpc20Request( + "sui_getNormalizedMoveModulesByPackage", Lists.newArrayList(packageId)); + return call( + "/sui_getNormalizedMoveModulesByPackage", + request, + new TypeToken>() {}.getType()); + } + @Override public CompletableFuture getCommitteeInfo(Long epoch) { final JsonRpc20Request request = diff --git a/src/main/java/io/sui/jsonrpc/GsonJsonHandler.java b/src/main/java/io/sui/jsonrpc/GsonJsonHandler.java index c184a2d..7871b14 100644 --- a/src/main/java/io/sui/jsonrpc/GsonJsonHandler.java +++ b/src/main/java/io/sui/jsonrpc/GsonJsonHandler.java @@ -36,6 +36,13 @@ import io.sui.models.events.EventQuery.AllQuery; import io.sui.models.events.MoveModule; import io.sui.models.objects.GetObjectResponse; +import io.sui.models.objects.MoveNormalizedType; +import io.sui.models.objects.MoveNormalizedType.MoveNormalizedStructType; +import io.sui.models.objects.MoveNormalizedType.MoveNormalizedTypeParameterType; +import io.sui.models.objects.MoveNormalizedType.MutableReferenceMoveNormalizedType; +import io.sui.models.objects.MoveNormalizedType.ReferenceMoveNormalizedType; +import io.sui.models.objects.MoveNormalizedType.TypeMoveNormalizedType; +import io.sui.models.objects.MoveNormalizedType.VectorReferenceMoveNormalizedType; import io.sui.models.objects.SuiData; import io.sui.models.objects.SuiObject; import io.sui.models.objects.SuiObjectOwner; @@ -375,6 +382,42 @@ public CommitteeInfo deserialize( } } + /** The type Move normalized type deserializer. */ + public class MoveNormalizedTypeDeserializer implements JsonDeserializer { + + @Override + public MoveNormalizedType deserialize( + JsonElement json, Type typeOfT, JsonDeserializationContext context) + throws JsonParseException { + if (json.isJsonPrimitive()) { + return TypeMoveNormalizedType.valueOf(json.getAsString()); + } + if (json.isJsonObject()) { + if (json.getAsJsonObject().get("TypeParameter") != null + && !json.getAsJsonObject().get("TypeParameter").isJsonNull()) { + return gson.fromJson(json, MoveNormalizedTypeParameterType.class); + } + if (json.getAsJsonObject().get("Reference") != null + && !json.getAsJsonObject().get("Reference").isJsonNull()) { + return gson.fromJson(json, ReferenceMoveNormalizedType.class); + } + if (json.getAsJsonObject().get("MutableReference") != null + && !json.getAsJsonObject().get("MutableReference").isJsonNull()) { + return gson.fromJson(json, MutableReferenceMoveNormalizedType.class); + } + if (json.getAsJsonObject().get("Vector") != null + && !json.getAsJsonObject().get("Vector").isJsonNull()) { + return gson.fromJson(json, VectorReferenceMoveNormalizedType.class); + } + if (json.getAsJsonObject().get("Struct") != null + && !json.getAsJsonObject().get("Struct").isJsonNull()) { + return gson.fromJson(json, MoveNormalizedStructType.class); + } + } + return null; + } + } + private final Gson gson; /** Instantiates a new Gson json handler. */ @@ -402,6 +445,7 @@ ParsedPublishResponse.class, new ParsedPublishResponseDeserializer()) AuthorityQuorumSignInfo.class, new AuthorityQuorumSignInfoDeserializer()) .registerTypeAdapter(MoveModule.class, new MoveModuleSerializer()) .registerTypeAdapter(EventQuery.class, new EventQuerySerializer()) + .registerTypeAdapter(MoveNormalizedType.class, new MoveNormalizedTypeDeserializer()) .registerTypeAdapter(CommitteeInfo.class, new CommitteeInfoDeserializer()) .create(); } diff --git a/src/main/java/io/sui/models/objects/MoveAbilitySet.java b/src/main/java/io/sui/models/objects/MoveAbilitySet.java new file mode 100644 index 0000000..68c6dd1 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveAbilitySet.java @@ -0,0 +1,72 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.List; +import java.util.Objects; + +/** + * The type Move ability set. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveAbilitySet { + + private List abilities; + + /** + * Gets abilities. + * + * @return the abilities + */ + public List getAbilities() { + return abilities; + } + + /** + * Sets abilities. + * + * @param abilities the abilities + */ + public void setAbilities(List abilities) { + this.abilities = abilities; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveAbilitySet)) { + return false; + } + MoveAbilitySet that = (MoveAbilitySet) o; + return abilities.equals(that.abilities); + } + + @Override + public int hashCode() { + return Objects.hash(abilities); + } + + @Override + public String toString() { + return "MoveAbilitySet{" + "abilities=" + abilities + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveModuleId.java b/src/main/java/io/sui/models/objects/MoveModuleId.java new file mode 100644 index 0000000..99fba12 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveModuleId.java @@ -0,0 +1,91 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.Objects; + +/** + * The type Move module id. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveModuleId { + + private String address; + + private String name; + + /** + * Gets address. + * + * @return the address + */ + public String getAddress() { + return address; + } + + /** + * Sets address. + * + * @param address the address + */ + public void setAddress(String address) { + this.address = address; + } + + /** + * Gets name. + * + * @return the name + */ + public String getName() { + return name; + } + + /** + * Sets name. + * + * @param name the name + */ + public void setName(String name) { + this.name = name; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveModuleId)) { + return false; + } + MoveModuleId that = (MoveModuleId) o; + return address.equals(that.address) && name.equals(that.name); + } + + @Override + public int hashCode() { + return Objects.hash(address, name); + } + + @Override + public String toString() { + return "MoveModuleId{" + "address='" + address + '\'' + ", name='" + name + '\'' + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveNormalizedField.java b/src/main/java/io/sui/models/objects/MoveNormalizedField.java new file mode 100644 index 0000000..259d991 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveNormalizedField.java @@ -0,0 +1,93 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.Objects; + +/** + * The type Move normalized field. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveNormalizedField { + + private String name; + + @SuppressWarnings("checkstyle:MemberName") + private MoveNormalizedType type_; + + /** + * Gets name. + * + * @return the name + */ + public String getName() { + return name; + } + + /** + * Sets name. + * + * @param name the name + */ + public void setName(String name) { + this.name = name; + } + + /** + * Gets type. + * + * @return the type + */ + public MoveNormalizedType getType_() { + return type_; + } + + /** + * Sets type. + * + * @param type_ the type + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setType_(MoveNormalizedType type_) { + this.type_ = type_; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedField)) { + return false; + } + MoveNormalizedField that = (MoveNormalizedField) o; + return name.equals(that.name) && type_.equals(that.type_); + } + + @Override + public int hashCode() { + return Objects.hash(name, type_); + } + + @Override + public String toString() { + return "MoveNormalizedField{" + "name='" + name + '\'' + ", type_=" + type_ + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveNormalizedFunction.java b/src/main/java/io/sui/models/objects/MoveNormalizedFunction.java new file mode 100644 index 0000000..3c6bbb3 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveNormalizedFunction.java @@ -0,0 +1,173 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.List; +import java.util.Objects; + +/** + * The type Move normalized function. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveNormalizedFunction { + + private MoveVisibility visibility; + + @SuppressWarnings("checkstyle:MemberName") + private boolean is_entry; + + @SuppressWarnings("checkstyle:MemberName") + private List type_parameters; + + private List parameters; + + @SuppressWarnings("checkstyle:MemberName") + private List return_; + + /** + * Gets visibility. + * + * @return the visibility + */ + public MoveVisibility getVisibility() { + return visibility; + } + + /** + * Sets visibility. + * + * @param visibility the visibility + */ + public void setVisibility(MoveVisibility visibility) { + this.visibility = visibility; + } + + /** + * Is is entry boolean. + * + * @return the boolean + */ + public boolean isIs_entry() { + return is_entry; + } + + /** + * Sets is entry. + * + * @param is_entry the is entry + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setIs_entry(boolean is_entry) { + this.is_entry = is_entry; + } + + /** + * Gets type parameters. + * + * @return the type parameters + */ + public List getType_parameters() { + return type_parameters; + } + + /** + * Sets type parameters. + * + * @param type_parameters the type parameters + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setType_parameters(List type_parameters) { + this.type_parameters = type_parameters; + } + + /** + * Gets parameters. + * + * @return the parameters + */ + public List getParameters() { + return parameters; + } + + /** + * Sets parameters. + * + * @param parameters the parameters + */ + public void setParameters(List parameters) { + this.parameters = parameters; + } + + /** + * Gets return. + * + * @return the return + */ + public List getReturn_() { + return return_; + } + + /** + * Sets return. + * + * @param return_ the return + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setReturn_(List return_) { + this.return_ = return_; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedFunction)) { + return false; + } + MoveNormalizedFunction that = (MoveNormalizedFunction) o; + return is_entry == that.is_entry + && visibility == that.visibility + && type_parameters.equals(that.type_parameters) + && parameters.equals(that.parameters) + && return_.equals(that.return_); + } + + @Override + public int hashCode() { + return Objects.hash(visibility, is_entry, type_parameters, parameters, return_); + } + + @Override + public String toString() { + return "MoveNormalizedFunction{" + + "visibility=" + + visibility + + ", is_entry=" + + is_entry + + ", type_parameters=" + + type_parameters + + ", parameters=" + + parameters + + ", return_=" + + return_ + + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveNormalizedModule.java b/src/main/java/io/sui/models/objects/MoveNormalizedModule.java new file mode 100644 index 0000000..31ed710 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveNormalizedModule.java @@ -0,0 +1,197 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** + * The type Move normalized module. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveNormalizedModule { + + @SuppressWarnings("checkstyle:MemberName") + private Integer file_format_version; + + private String address; + + private String name; + + private List friends; + + private Map structs; + + @SuppressWarnings("checkstyle:MemberName") + private Map exposed_functions; + + /** + * Gets file format version. + * + * @return the file format version + */ + public Integer getFile_format_version() { + return file_format_version; + } + + /** + * Sets file format version. + * + * @param file_format_version the file format version + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setFile_format_version(Integer file_format_version) { + this.file_format_version = file_format_version; + } + + /** + * Gets address. + * + * @return the address + */ + public String getAddress() { + return address; + } + + /** + * Sets address. + * + * @param address the address + */ + public void setAddress(String address) { + this.address = address; + } + + /** + * Gets name. + * + * @return the name + */ + public String getName() { + return name; + } + + /** + * Sets name. + * + * @param name the name + */ + public void setName(String name) { + this.name = name; + } + + /** + * Gets friends. + * + * @return the friends + */ + public List getFriends() { + return friends; + } + + /** + * Sets friends. + * + * @param friends the friends + */ + public void setFriends(List friends) { + this.friends = friends; + } + + /** + * Gets structs. + * + * @return the structs + */ + public Map getStructs() { + return structs; + } + + /** + * Sets structs. + * + * @param structs the structs + */ + public void setStructs(Map structs) { + this.structs = structs; + } + + /** + * Gets exposed functions. + * + * @return the exposed functions + */ + public Map getExposed_functions() { + return exposed_functions; + } + + /** + * Sets exposed functions. + * + * @param exposed_functions the exposed functions + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setExposed_functions(Map exposed_functions) { + this.exposed_functions = exposed_functions; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedModule)) { + return false; + } + MoveNormalizedModule that = (MoveNormalizedModule) o; + return file_format_version.equals(that.file_format_version) + && address.equals(that.address) + && name.equals(that.name) + && friends.equals(that.friends) + && structs.equals(that.structs) + && exposed_functions.equals(that.exposed_functions); + } + + @Override + public int hashCode() { + return Objects.hash(file_format_version, address, name, friends, structs, exposed_functions); + } + + @Override + public String toString() { + return "MoveNormalizedModule{" + + "file_format_version=" + + file_format_version + + ", address='" + + address + + '\'' + + ", name='" + + name + + '\'' + + ", friends=" + + friends + + ", structs=" + + structs + + ", exposed_functions=" + + exposed_functions + + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveNormalizedStruct.java b/src/main/java/io/sui/models/objects/MoveNormalizedStruct.java new file mode 100644 index 0000000..9d1e923 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveNormalizedStruct.java @@ -0,0 +1,123 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.List; +import java.util.Objects; + +/** + * The type Move normalized struct. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveNormalizedStruct { + + private MoveAbilitySet abilities; + + @SuppressWarnings("checkstyle:MemberName") + private List type_parameters; + + private List fields; + + /** + * Gets abilities. + * + * @return the abilities + */ + public MoveAbilitySet getAbilities() { + return abilities; + } + + /** + * Sets abilities. + * + * @param abilities the abilities + */ + public void setAbilities(MoveAbilitySet abilities) { + this.abilities = abilities; + } + + /** + * Gets type parameters. + * + * @return the type parameters + */ + public List getType_parameters() { + return type_parameters; + } + + /** + * Sets type parameters. + * + * @param type_parameters the type parameters + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setType_parameters(List type_parameters) { + this.type_parameters = type_parameters; + } + + /** + * Gets fields. + * + * @return the fields + */ + public List getFields() { + return fields; + } + + /** + * Sets fields. + * + * @param fields the fields + */ + public void setFields(List fields) { + this.fields = fields; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedStruct)) { + return false; + } + MoveNormalizedStruct that = (MoveNormalizedStruct) o; + return abilities.equals(that.abilities) + && type_parameters.equals(that.type_parameters) + && fields.equals(that.fields); + } + + @Override + public int hashCode() { + return Objects.hash(abilities, type_parameters, fields); + } + + @Override + public String toString() { + return "MoveNormalizedStruct{" + + "abilities=" + + abilities + + ", type_parameters=" + + type_parameters + + ", fields=" + + fields + + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveNormalizedType.java b/src/main/java/io/sui/models/objects/MoveNormalizedType.java new file mode 100644 index 0000000..6d3d759 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveNormalizedType.java @@ -0,0 +1,410 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.List; +import java.util.Objects; + +/** + * The interface Move normalized type. + * + * @author grapebaba + * @since 2022.11 + */ +public interface MoveNormalizedType { + + /** The enum Type move normalized type. */ + enum TypeMoveNormalizedType implements MoveNormalizedType { + /** Bool type move normalized type. */ + Bool, + /** U 8 type move normalized type. */ + U8, + /** U 16 type move normalized type. */ + U16, + /** U 32 type move normalized type. */ + U32, + /** U 64 type move normalized type. */ + U64, + /** U 128 type move normalized type. */ + U128, + /** U 256 type move normalized type. */ + U256, + /** Address type move normalized type. */ + Address, + /** Signer type move normalized type. */ + Signer + } + + /** The type Reference move normalized type. */ + class ReferenceMoveNormalizedType implements MoveNormalizedType { + + @SuppressWarnings("checkstyle:MemberName") + private MoveNormalizedType Reference; + + /** + * Gets reference. + * + * @return the reference + */ + public MoveNormalizedType getReference() { + return Reference; + } + + /** + * Sets reference. + * + * @param reference the reference + */ + public void setReference(MoveNormalizedType reference) { + Reference = reference; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ReferenceMoveNormalizedType)) { + return false; + } + ReferenceMoveNormalizedType that = (ReferenceMoveNormalizedType) o; + return Reference.equals(that.Reference); + } + + @Override + public int hashCode() { + return Objects.hash(Reference); + } + + @Override + public String toString() { + return "ReferenceMoveNormalizedType{" + "Reference=" + Reference + '}'; + } + } + + /** The type Mutable reference move normalized type. */ + class MutableReferenceMoveNormalizedType implements MoveNormalizedType { + + @SuppressWarnings("checkstyle:MemberName") + private MoveNormalizedType MutableReference; + + /** + * Gets mutable reference. + * + * @return the mutable reference + */ + public MoveNormalizedType getMutableReference() { + return MutableReference; + } + + /** + * Sets mutable reference. + * + * @param mutableReference the mutable reference + */ + public void setMutableReference(MoveNormalizedType mutableReference) { + MutableReference = mutableReference; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MutableReferenceMoveNormalizedType)) { + return false; + } + MutableReferenceMoveNormalizedType that = (MutableReferenceMoveNormalizedType) o; + return MutableReference.equals(that.MutableReference); + } + + @Override + public int hashCode() { + return Objects.hash(MutableReference); + } + + @Override + public String toString() { + return "MutableReferenceMoveNormalizedType{" + "MutableReference=" + MutableReference + '}'; + } + } + + /** The type Vector reference move normalized type. */ + class VectorReferenceMoveNormalizedType implements MoveNormalizedType { + + @SuppressWarnings("checkstyle:MemberName") + private MoveNormalizedType Vector; + + /** + * Gets vector. + * + * @return the vector + */ + public MoveNormalizedType getVector() { + return Vector; + } + + /** + * Sets vector. + * + * @param vector the vector + */ + public void setVector(MoveNormalizedType vector) { + Vector = vector; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof VectorReferenceMoveNormalizedType)) { + return false; + } + VectorReferenceMoveNormalizedType that = (VectorReferenceMoveNormalizedType) o; + return Vector.equals(that.Vector); + } + + @Override + public int hashCode() { + return Objects.hash(Vector); + } + + @Override + public String toString() { + return "VectorReferenceMoveNormalizedType{" + "Vector=" + Vector + '}'; + } + } + + /** The type Move normalized type parameter type. */ + class MoveNormalizedTypeParameterType implements MoveNormalizedType { + + @SuppressWarnings("checkstyle:MemberName") + private Integer TypeParameter; + + /** + * Gets type parameter. + * + * @return the type parameter + */ + public Integer getTypeParameter() { + return TypeParameter; + } + + /** + * Sets type parameter. + * + * @param typeParameter the type parameter + */ + public void setTypeParameter(Integer typeParameter) { + TypeParameter = typeParameter; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedTypeParameterType)) { + return false; + } + MoveNormalizedTypeParameterType that = (MoveNormalizedTypeParameterType) o; + return TypeParameter.equals(that.TypeParameter); + } + + @Override + public int hashCode() { + return Objects.hash(TypeParameter); + } + + @Override + public String toString() { + return "MoveNormalizedTypeParameterType{" + "TypeParameter=" + TypeParameter + '}'; + } + } + + /** The type Move normalized struct type. */ + class MoveNormalizedStructType implements MoveNormalizedType { + + /** The type Struct. */ + public static class Struct { + + private String address; + + private String module; + + private String name; + + @SuppressWarnings("checkstyle:MemberName") + private List type_arguments; + + /** + * Gets address. + * + * @return the address + */ + public String getAddress() { + return address; + } + + /** + * Sets address. + * + * @param address the address + */ + public void setAddress(String address) { + this.address = address; + } + + /** + * Gets module. + * + * @return the module + */ + public String getModule() { + return module; + } + + /** + * Sets module. + * + * @param module the module + */ + public void setModule(String module) { + this.module = module; + } + + /** + * Gets name. + * + * @return the name + */ + public String getName() { + return name; + } + + /** + * Sets name. + * + * @param name the name + */ + public void setName(String name) { + this.name = name; + } + + /** + * Gets type arguments. + * + * @return the type arguments + */ + public List getType_arguments() { + return type_arguments; + } + + /** + * Sets type arguments. + * + * @param type_arguments the type arguments + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setType_arguments(List type_arguments) { + this.type_arguments = type_arguments; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof Struct)) { + return false; + } + Struct struct = (Struct) o; + return address.equals(struct.address) + && module.equals(struct.module) + && name.equals(struct.name) + && type_arguments.equals(struct.type_arguments); + } + + @Override + public int hashCode() { + return Objects.hash(address, module, name, type_arguments); + } + + @Override + public String toString() { + return "Struct{" + + "address='" + + address + + '\'' + + ", module='" + + module + + '\'' + + ", name='" + + name + + '\'' + + ", type_arguments=" + + type_arguments + + '}'; + } + } + + @SuppressWarnings("checkstyle:MemberName") + private Struct Struct; + + /** + * Gets struct. + * + * @return the struct + */ + public MoveNormalizedStructType.Struct getStruct() { + return Struct; + } + + /** + * Sets struct. + * + * @param struct the struct + */ + public void setStruct(MoveNormalizedStructType.Struct struct) { + Struct = struct; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveNormalizedStructType)) { + return false; + } + MoveNormalizedStructType that = (MoveNormalizedStructType) o; + return Struct.equals(that.Struct); + } + + @Override + public int hashCode() { + return Objects.hash(Struct); + } + + @Override + public String toString() { + return "MoveNormalizedStructType{" + "Struct=" + Struct + '}'; + } + } +} diff --git a/src/main/java/io/sui/models/objects/MoveStructTypeParameter.java b/src/main/java/io/sui/models/objects/MoveStructTypeParameter.java new file mode 100644 index 0000000..64d46c0 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveStructTypeParameter.java @@ -0,0 +1,98 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + + +import java.util.Objects; + +/** + * The type Move struct type parameter. + * + * @author grapebaba + * @since 2022.11 + */ +public class MoveStructTypeParameter { + + private MoveAbilitySet constraints; + + @SuppressWarnings("checkstyle:MemberName") + private boolean is_phantom; + + /** + * Gets constraints. + * + * @return the constraints + */ + public MoveAbilitySet getConstraints() { + return constraints; + } + + /** + * Sets constraints. + * + * @param constraints the constraints + */ + public void setConstraints(MoveAbilitySet constraints) { + this.constraints = constraints; + } + + /** + * Is is phantom boolean. + * + * @return the boolean + */ + public boolean isIs_phantom() { + return is_phantom; + } + + /** + * Sets is phantom. + * + * @param is_phantom the is phantom + */ + @SuppressWarnings("checkstyle:ParameterName") + public void setIs_phantom(boolean is_phantom) { + this.is_phantom = is_phantom; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MoveStructTypeParameter)) { + return false; + } + MoveStructTypeParameter that = (MoveStructTypeParameter) o; + return is_phantom == that.is_phantom && constraints.equals(that.constraints); + } + + @Override + public int hashCode() { + return Objects.hash(constraints, is_phantom); + } + + @Override + public String toString() { + return "MoveStructTypeParameter{" + + "constraints=" + + constraints + + ", is_phantom=" + + is_phantom + + '}'; + } +} diff --git a/src/main/java/io/sui/models/objects/MoveVisibility.java b/src/main/java/io/sui/models/objects/MoveVisibility.java new file mode 100644 index 0000000..b32cb96 --- /dev/null +++ b/src/main/java/io/sui/models/objects/MoveVisibility.java @@ -0,0 +1,32 @@ +/* + * Copyright 2022 281165273grape@gmail.com + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package io.sui.models.objects; + +/** + * The enum Move visibility. + * + * @author grapebaba + * @since 2022.11 + */ +public enum MoveVisibility { + /** Private move visibility. */ + Private, + /** Public move visibility. */ + Public, + /** Friend move visibility. */ + Friend +} diff --git a/src/test/java/io/sui/SuiClientImplTests.java b/src/test/java/io/sui/SuiClientImplTests.java index f074db7..5a5d05b 100644 --- a/src/test/java/io/sui/SuiClientImplTests.java +++ b/src/test/java/io/sui/SuiClientImplTests.java @@ -17,6 +17,7 @@ package io.sui; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import com.google.common.io.Resources; @@ -31,11 +32,14 @@ import io.sui.models.events.CoinBalanceChangeEvent; import io.sui.models.events.CoinBalanceChangeEvent.BalanceChangeType; import io.sui.models.events.EventKind; +import io.sui.models.events.EventKind.CoinBalanceChangeEventKind; import io.sui.models.events.EventQuery.TransactionEventQuery; import io.sui.models.events.MoveEvent; import io.sui.models.events.PaginatedEvents; import io.sui.models.objects.GetObjectResponse; import io.sui.models.objects.GetObjectResponse.ObjectIdResponseDetails; +import io.sui.models.objects.MoveNormalizedModule; +import io.sui.models.objects.MoveVisibility; import io.sui.models.objects.ObjectStatus; import io.sui.models.objects.SuiData; import io.sui.models.objects.SuiObject; @@ -48,9 +52,11 @@ import io.sui.models.transactions.TransactionKind; import io.sui.models.transactions.TransactionResponse; import java.io.IOException; +import java.math.BigInteger; import java.net.URL; import java.nio.charset.StandardCharsets; import java.util.List; +import java.util.Map; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import okhttp3.mockwebserver.Dispatcher; @@ -168,6 +174,10 @@ public MockResponse dispatch(RecordedRequest request) { return getMockResponse("mockdata/getEvents.json"); } + if ("/sui_getNormalizedMoveModulesByPackage".equals(request.getPath())) { + return getMockResponse("mockdata/getNormalizedMoveModulesByPackage.json"); + } + if ("/sui_getCommitteeInfo".equals(request.getPath())) { return getMockResponse("mockdata/getCommitteeInfo.json"); } @@ -451,6 +461,38 @@ void getEvents() throws ExecutionException, InterruptedException { query.setTransaction("ov1tDrhdOqRW2uFweTbSSTaQbBbnjHWmrsh675lwb0Q="); CompletableFuture res = client.getEvents(query, null, 1, false); System.out.println(res.get()); + assertEquals(1, res.get().getData().size()); + assertEquals(0, res.get().getNextCursor().getTxSeq()); + assertEquals(1, res.get().getNextCursor().getEventSeq()); + assertEquals( + BigInteger.valueOf(-1062L), + ((CoinBalanceChangeEventKind) res.get().getData().get(0).getEvent()) + .getCoinBalanceChange() + .getAmount()); + } + + /** + * Gets normalized move modules by package. + * + * @throws ExecutionException the execution exception + * @throws InterruptedException the interrupted exception + */ + @Test + @DisplayName("Test getNormalizedMoveModulesByPackage.") + void getNormalizedMoveModulesByPackage() throws ExecutionException, InterruptedException { + CompletableFuture> res = + client.getNormalizedMoveModulesByPackage("0x0000000000000000000000000000000000000002"); + System.out.println(res.get()); + assertEquals(6, res.get().get("bag").getFile_format_version()); + assertEquals( + "Store", res.get().get("bag").getStructs().get("Bag").getAbilities().getAbilities().get(0)); + + assertEquals("0x2", res.get().get("validator_set").getFriends().get(0).getAddress()); + assertEquals( + MoveVisibility.Friend, + res.get().get("validator_set").getExposed_functions().get("advance_epoch").getVisibility()); + assertFalse( + res.get().get("validator_set").getExposed_functions().get("advance_epoch").isIs_entry()); } /** diff --git a/src/test/resources/mockdata/getNormalizedMoveModulesByPackage.json b/src/test/resources/mockdata/getNormalizedMoveModulesByPackage.json new file mode 100644 index 0000000..acdbef2 --- /dev/null +++ b/src/test/resources/mockdata/getNormalizedMoveModulesByPackage.json @@ -0,0 +1,12896 @@ +{ + "jsonrpc": "2.0", + "result": { + "bag": { + "file_format_version": 6, + "address": "0x2", + "name": "bag", + "friends": [], + "structs": { + "Bag": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "size", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "contains_with_type": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "destroy_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "length": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bag", + "name": "Bag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + } + } + }, + "balance": { + "file_format_version": 6, + "address": "0x2", + "name": "balance", + "friends": [], + "structs": { + "Balance": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "value", + "type_": "U64" + } + ] + }, + "Supply": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "value", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "create_supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "decrease_supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + "U64" + ] + }, + "destroy_zero": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "increase_supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "join": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + "U64" + ] + }, + "split": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "supply_value": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "value": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "zero": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + } + } + }, + "bcs": { + "file_format_version": 6, + "address": "0x2", + "name": "bcs", + "friends": [], + "structs": { + "BCS": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "bytes", + "type_": { + "Vector": "U8" + } + } + ] + } + }, + "exposed_functions": { + "into_remainder_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + ] + }, + "peel_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "peel_bool": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "peel_option_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "Address" + ] + } + } + ] + }, + "peel_option_bool": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "Bool" + ] + } + } + ] + }, + "peel_option_u128": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "U128" + ] + } + } + ] + }, + "peel_option_u64": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "U64" + ] + } + } + ] + }, + "peel_option_u8": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "U8" + ] + } + } + ] + }, + "peel_u128": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U128" + ] + }, + "peel_u64": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "peel_u8": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U8" + ] + }, + "peel_vec_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "Address" + } + ] + }, + "peel_vec_bool": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "Bool" + } + ] + }, + "peel_vec_length": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "peel_vec_u128": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U128" + } + ] + }, + "peel_vec_u64": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U64" + } + ] + }, + "peel_vec_u8": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "peel_vec_vec_u8": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "bcs", + "name": "BCS", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": { + "Vector": "U8" + } + } + ] + }, + "to_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + } + } + }, + "bls12381": { + "file_format_version": 6, + "address": "0x2", + "name": "bls12381", + "friends": [ + { + "address": "0x2", + "name": "validator" + } + ], + "structs": {}, + "exposed_functions": { + "bls12381_min_pk_verify": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + "Bool" + ] + }, + "bls12381_min_sig_verify": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + "Bool" + ] + }, + "bls12381_min_sig_verify_with_domain": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + } + ], + "return_": [ + "Bool" + ] + } + } + }, + "bulletproofs": { + "file_format_version": 6, + "address": "0x2", + "name": "bulletproofs", + "friends": [], + "structs": {}, + "exposed_functions": { + "verify_full_range_proof": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + }, + "U64" + ], + "return_": [] + } + } + }, + "coin": { + "file_format_version": 6, + "address": "0x2", + "name": "coin", + "friends": [], + "structs": { + "Coin": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "balance", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "CurrencyCreated": { + "abilities": { + "abilities": [ + "Copy", + "Drop" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "decimals", + "type_": "U8" + } + ] + }, + "TreasuryCap": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "total_supply", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + } + }, + "exposed_functions": { + "balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "balance_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "burn": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + "U64" + ] + }, + "burn_": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "create_currency": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + }, + "U8", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "destroy_zero": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "divide_into_n": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "from_balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "into_balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "join": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "mint": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "mint_and_transfer": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "mint_balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "put": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "split": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "supply_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "take": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "total_supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "treasury_into_supply": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "TreasuryCap", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "value": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "zero": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + } + } + }, + "devnet_nft": { + "file_format_version": 6, + "address": "0x2", + "name": "devnet_nft", + "friends": [], + "structs": { + "DevNetNFT": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "name", + "type_": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + }, + { + "name": "description", + "type_": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + }, + { + "name": "url", + "type_": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + } + ] + }, + "MintNFTEvent": { + "abilities": { + "abilities": [ + "Copy", + "Drop" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "object_id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + }, + { + "name": "creator", + "type_": "Address" + }, + { + "name": "name", + "type_": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "burn": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "devnet_nft", + "name": "DevNetNFT", + "type_arguments": [] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "description": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "devnet_nft", + "name": "DevNetNFT", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + } + ] + }, + "mint": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "name": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "devnet_nft", + "name": "DevNetNFT", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + } + ] + }, + "update_description": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "devnet_nft", + "name": "DevNetNFT", + "type_arguments": [] + } + } + }, + { + "Vector": "U8" + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "url": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "devnet_nft", + "name": "DevNetNFT", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + } + ] + } + } + }, + "digest": { + "file_format_version": 6, + "address": "0x2", + "name": "digest", + "friends": [], + "structs": { + "Sha3256Digest": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "digest", + "type_": { + "Vector": "U8" + } + } + ] + } + }, + "exposed_functions": { + "sha3_256_digest_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + ] + }, + "sha3_256_digest_to_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + } + } + }, + "dynamic_field": { + "file_format_version": 6, + "address": "0x2", + "name": "dynamic_field", + "friends": [ + { + "address": "0x2", + "name": "dynamic_object_field" + } + ], + "structs": { + "Field": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "is_phantom": false + }, + { + "constraints": { + "abilities": [ + "Store" + ] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "name", + "type_": { + "TypeParameter": 0 + } + }, + { + "name": "value", + "type_": { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "TypeParameter": 1 + } + ] + } + } + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "add_child_object": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + "Address", + { + "TypeParameter": 0 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_child_object": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + "Address", + "Address" + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 0 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "exists_with_type": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "field_ids": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Address", + "Address" + ] + }, + "has_child_object": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address", + "Address" + ], + "return_": [ + "Bool" + ] + }, + "has_child_object_with_ty": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + "Address", + "Address" + ], + "return_": [ + "Bool" + ] + }, + "hash_type_and_key": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + "Address", + { + "TypeParameter": 0 + } + ], + "return_": [ + "Address" + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + }, + "remove_child_object": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + "Address", + "Address" + ], + "return_": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "dynamic_object_field": { + "file_format_version": 6, + "address": "0x2", + "name": "dynamic_object_field", + "friends": [], + "structs": { + "Wrapper": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "name", + "type_": { + "TypeParameter": 0 + } + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "exists_": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "exists_with_type": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + } + } + }, + "ecdsa": { + "file_format_version": 6, + "address": "0x2", + "name": "ecdsa", + "friends": [], + "structs": {}, + "exposed_functions": { + "decompress_pubkey": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "ecrecover": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "keccak256": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "secp256k1_verify": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + "Bool" + ] + } + } + }, + "ed25519": { + "file_format_version": 6, + "address": "0x2", + "name": "ed25519", + "friends": [ + { + "address": "0x2", + "name": "validator" + } + ], + "structs": {}, + "exposed_functions": { + "ed25519_verify": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + "Bool" + ] + }, + "ed25519_verify_with_domain": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + } + ], + "return_": [ + "Bool" + ] + } + } + }, + "elliptic_curve": { + "file_format_version": 6, + "address": "0x2", + "name": "elliptic_curve", + "friends": [], + "structs": { + "RistrettoPoint": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "value", + "type_": { + "Vector": "U8" + } + } + ] + }, + "Scalar": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "value", + "type_": { + "Vector": "U8" + } + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + ] + }, + "bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "create_pedersen_commitment": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "Scalar", + "type_arguments": [] + } + }, + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "Scalar", + "type_arguments": [] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + ] + }, + "new_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + ] + }, + "new_scalar_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "Scalar", + "type_arguments": [] + } + } + ] + }, + "new_scalar_from_u64": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "Scalar", + "type_arguments": [] + } + } + ] + }, + "scalar_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "Scalar", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "subtract": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "elliptic_curve", + "name": "RistrettoPoint", + "type_arguments": [] + } + } + ] + } + } + }, + "epoch_time_lock": { + "file_format_version": 6, + "address": "0x2", + "name": "epoch_time_lock", + "friends": [], + "structs": { + "EpochTimeLock": { + "abilities": { + "abilities": [ + "Copy", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "epoch", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "destroy": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "epoch": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + } + }, + "erc721_metadata": { + "file_format_version": 6, + "address": "0x2", + "name": "erc721_metadata", + "friends": [], + "structs": { + "ERC721Metadata": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "token_id", + "type_": { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "TokenID", + "type_arguments": [] + } + } + }, + { + "name": "name", + "type_": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + }, + { + "name": "token_uri", + "type_": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + } + ] + }, + "TokenID": { + "abilities": { + "abilities": [ + "Copy", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "name": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "ERC721Metadata", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x1", + "module": "string", + "name": "String", + "type_arguments": [] + } + } + } + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "TokenID", + "type_arguments": [] + } + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "ERC721Metadata", + "type_arguments": [] + } + } + ] + }, + "new_token_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "TokenID", + "type_arguments": [] + } + } + ] + }, + "token_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "ERC721Metadata", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "TokenID", + "type_arguments": [] + } + } + } + ] + }, + "token_uri": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "erc721_metadata", + "name": "ERC721Metadata", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + } + ] + } + } + }, + "event": { + "file_format_version": 6, + "address": "0x2", + "name": "event", + "friends": [], + "structs": {}, + "exposed_functions": { + "emit": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + } + ], + "return_": [] + } + } + }, + "genesis": { + "file_format_version": 6, + "address": "0x2", + "name": "genesis", + "friends": [], + "structs": {}, + "exposed_functions": {} + }, + "hmac": { + "file_format_version": 6, + "address": "0x2", + "name": "hmac", + "friends": [], + "structs": {}, + "exposed_functions": { + "hmac_sha3_256": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Vector": "U8" + } + }, + { + "Reference": { + "Vector": "U8" + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + ] + } + } + }, + "immutable_external_resource": { + "file_format_version": 6, + "address": "0x2", + "name": "immutable_external_resource", + "friends": [], + "structs": { + "ImmutableExternalResource": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "url", + "type_": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + }, + { + "name": "digest", + "type_": { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "digest": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "immutable_external_resource", + "name": "ImmutableExternalResource", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + }, + { + "Struct": { + "address": "0x2", + "module": "digest", + "name": "Sha3256Digest", + "type_arguments": [] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "immutable_external_resource", + "name": "ImmutableExternalResource", + "type_arguments": [] + } + } + ] + }, + "update": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "immutable_external_resource", + "name": "ImmutableExternalResource", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "url": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "immutable_external_resource", + "name": "ImmutableExternalResource", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + ] + } + } + }, + "locked_coin": { + "file_format_version": 6, + "address": "0x2", + "name": "locked_coin", + "friends": [ + { + "address": "0x2", + "name": "sui_system" + } + ], + "structs": { + "LockedCoin": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "balance", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "name": "locked_until_epoch", + "type_": { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "into_balance": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "locked_coin", + "name": "LockedCoin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + }, + "lock_coin": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + "Address", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "new_from_balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "unlock_coin": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "locked_coin", + "name": "LockedCoin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "value": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "locked_coin", + "name": "LockedCoin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + } + } + }, + "math": { + "file_format_version": 6, + "address": "0x2", + "name": "math", + "friends": [], + "structs": {}, + "exposed_functions": { + "max": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64", + "U64" + ], + "return_": [ + "U64" + ] + }, + "min": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64", + "U64" + ], + "return_": [ + "U64" + ] + }, + "pow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64", + "U8" + ], + "return_": [ + "U64" + ] + }, + "sqrt": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U64" + ], + "return_": [ + "U64" + ] + }, + "sqrt_u128": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "U128" + ], + "return_": [ + "U128" + ] + } + } + }, + "object": { + "file_format_version": 6, + "address": "0x2", + "name": "object", + "friends": [ + { + "address": "0x2", + "name": "dynamic_field" + }, + { + "address": "0x2", + "name": "dynamic_object_field" + }, + { + "address": "0x2", + "name": "sui_system" + }, + { + "address": "0x2", + "name": "transfer" + } + ], + "structs": { + "ID": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "bytes", + "type_": "Address" + } + ] + }, + "UID": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "address_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + "Address" + ] + }, + "borrow_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + }, + "delete": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + }, + "id_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "Address" + ] + }, + "id_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "id_from_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + }, + "id_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + }, + "id_to_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "id_to_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + ] + }, + "new_uid_from_hash": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + ] + }, + "sui_system_state": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + ] + }, + "uid_as_inner": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + }, + "uid_to_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "uid_to_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "U8" + } + ] + }, + "uid_to_inner": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + }, + "object_bag": { + "file_format_version": 6, + "address": "0x2", + "name": "object_bag", + "friends": [], + "structs": { + "ObjectBag": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "size", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "contains": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "contains_with_type": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "destroy_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "length": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + }, + "value_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_bag", + "name": "ObjectBag", + "type_arguments": [] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + ] + } + } + }, + "object_table": { + "file_format_version": 6, + "address": "0x2", + "name": "object_table", + "friends": [], + "structs": { + "ObjectTable": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "is_phantom": true + }, + { + "constraints": { + "abilities": [ + "Store", + "Key" + ] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "size", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "contains": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "destroy_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ], + "return_": [] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "length": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + }, + "value_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store", + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object_table", + "name": "ObjectTable", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + ] + } + } + }, + "pay": { + "file_format_version": 6, + "address": "0x2", + "name": "pay", + "friends": [], + "structs": {}, + "exposed_functions": { + "divide_and_keep": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "join": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "join_vec": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [] + }, + "join_vec_and_transfer": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "Address" + ], + "return_": [] + }, + "keep": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "split": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "split_and_transfer": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "split_vec": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Vector": "U64" + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + } + } + }, + "priority_queue": { + "file_format_version": 6, + "address": "0x2", + "name": "priority_queue", + "friends": [], + "structs": { + "Entry": { + "abilities": { + "abilities": [ + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Drop" + ] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "priority", + "type_": "U64" + }, + { + "name": "value", + "type_": { + "TypeParameter": 0 + } + } + ] + }, + "PriorityQueue": { + "abilities": { + "abilities": [ + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Drop" + ] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "entries", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "Entry", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + } + ] + } + }, + "exposed_functions": { + "create_entries": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "Vector": "U64" + }, + { + "Vector": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "Entry", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "insert": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "PriorityQueue", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "TypeParameter": 0 + } + ], + "return_": [] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "Entry", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "PriorityQueue", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "new_entry": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + "U64", + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "Entry", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "pop_max": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "priority_queue", + "name": "PriorityQueue", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64", + { + "TypeParameter": 0 + } + ] + } + } + }, + "safe": { + "file_format_version": 6, + "address": "0x2", + "name": "safe", + "friends": [], + "structs": { + "OwnerCapability": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "safe_id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + }, + "Safe": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "balance", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "name": "allowed_safes", + "type_": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + } + ] + }, + "TransferCapability": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "safe_id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + }, + { + "name": "amount", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ] + }, + "create": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "create_": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "OwnerCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "create_empty": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "create_transfer_capability": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "OwnerCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "TransferCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "debit": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "TransferCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "deposit": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "deposit_": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [] + }, + "revoke_transfer_capability": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "OwnerCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "self_revoke_transfer_capability": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "TransferCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [] + }, + "withdraw": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "OwnerCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "withdraw_": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "Safe", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "safe", + "name": "OwnerCapability", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + } + } + }, + "stake": { + "file_format_version": 6, + "address": "0x2", + "name": "stake", + "friends": [ + { + "address": "0x2", + "name": "sui_system" + }, + { + "address": "0x2", + "name": "validator" + } + ], + "structs": { + "Stake": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "balance", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "locked_until_epoch", + "type_": { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + } + } + ] + } + }, + "exposed_functions": { + "burn": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "create": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "Address", + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "value": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "withdraw_stake": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + } + } + }, + "staking_pool": { + "file_format_version": 6, + "address": "0x2", + "name": "staking_pool", + "friends": [ + { + "address": "0x2", + "name": "validator" + }, + { + "address": "0x2", + "name": "validator_set" + } + ], + "structs": { + "Delegation": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "validator_address", + "type_": "Address" + }, + { + "name": "pool_starting_epoch", + "type_": "U64" + }, + { + "name": "pool_tokens", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "DelegationToken", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "principal_sui_amount", + "type_": "U64" + } + ] + }, + "DelegationToken": { + "abilities": { + "abilities": [ + "Drop" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "dummy_field", + "type_": "Bool" + } + ] + }, + "InactiveStakingPool": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "pool", + "type_": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + } + ] + }, + "PendingDelegationEntry": { + "abilities": { + "abilities": [ + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "delegator", + "type_": "Address" + }, + { + "name": "sui_amount", + "type_": "U64" + } + ] + }, + "PendingWithdrawEntry": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "delegator", + "type_": "Address" + }, + { + "name": "principal_withdraw_amount", + "type_": "U64" + }, + { + "name": "withdrawn_pool_tokens", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "DelegationToken", + "type_arguments": [] + } + } + ] + } + } + } + ] + }, + "StakedSui": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "principal", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "sui_token_lock", + "type_": { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + } + } + ] + }, + "StakingPool": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "validator_address", + "type_": "Address" + }, + { + "name": "starting_epoch", + "type_": "U64" + }, + { + "name": "sui_balance", + "type_": "U64" + }, + { + "name": "rewards_pool", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "delegation_token_supply", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "DelegationToken", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "pending_delegations", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "PendingDelegationEntry", + "type_arguments": [] + } + } + } + }, + { + "name": "pending_withdraws", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "PendingWithdrawEntry", + "type_arguments": [] + } + } + } + } + ] + } + }, + "exposed_functions": { + "batch_withdraw_rewards_and_burn_pool_tokens": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "PendingWithdrawEntry", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Vector": "Address" + }, + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + "U64" + ] + }, + "deactivate_staking_pool": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "delegation_token_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "deposit_rewards": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + ], + "return_": [] + }, + "destroy_empty_delegation": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "destroy_empty_staked_sui": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "new": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address", + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + ] + }, + "new_pending_withdraw_entry": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address", + "U64", + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "DelegationToken", + "type_arguments": [] + } + } + ] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "PendingWithdrawEntry", + "type_arguments": [] + } + } + ] + }, + "process_pending_delegation_withdraws": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "process_pending_delegations": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "staked_sui_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "sui_balance": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "validator_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "withdraw_from_inactive_pool": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "InactiveStakingPool", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "withdraw_from_principal": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "U64" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "DelegationToken", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + } + ] + } + } + }, + "sui": { + "file_format_version": 6, + "address": "0x2", + "name": "sui", + "friends": [ + { + "address": "0x2", + "name": "genesis" + } + ], + "structs": { + "SUI": { + "abilities": { + "abilities": [ + "Drop" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "dummy_field", + "type_": "Bool" + } + ] + } + }, + "exposed_functions": { + "new": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + ] + }, + "transfer": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "Address" + ], + "return_": [] + } + } + }, + "sui_system": { + "file_format_version": 6, + "address": "0x2", + "name": "sui_system", + "friends": [ + { + "address": "0x2", + "name": "genesis" + } + ], + "structs": { + "SuiSystemState": { + "abilities": { + "abilities": [ + "Key" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "epoch", + "type_": "U64" + }, + { + "name": "validators", + "type_": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "name": "sui_supply", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "storage_fund", + "type_": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "name": "parameters", + "type_": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SystemParameters", + "type_arguments": [] + } + } + }, + { + "name": "reference_gas_price", + "type_": "U64" + }, + { + "name": "validator_report_records", + "type_": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + "Address", + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + "Address" + ] + } + } + ] + } + } + } + ] + }, + "SystemParameters": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "min_validator_stake", + "type_": "U64" + }, + { + "name": "max_validator_candidate_count", + "type_": "U64" + }, + { + "name": "storage_gas_price", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "advance_epoch": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "U64", + "U64", + "U64", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "create": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Supply", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "U64", + "U64", + "U64" + ], + "return_": [] + }, + "epoch": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "get_reporters_of": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + "Address" + ] + } + } + ] + }, + "report_validator": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_delegation": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_delegation_with_locked_coin": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "locked_coin", + "name": "LockedCoin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_stake": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_stake_with_locked_coin": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "locked_coin", + "name": "LockedCoin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_validator": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Struct": { + "address": "0x2", + "module": "coin", + "name": "Coin", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + "U64", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_remove_validator": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_set_commission_rate": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_set_gas_price": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_switch_delegation": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "Address", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_delegation": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_stake": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "undo_report_validator": { + "visibility": "Public", + "is_entry": true, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "validator_delegate_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + "U64" + ] + }, + "validator_stake_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "sui_system", + "name": "SuiSystemState", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + "U64" + ] + } + } + }, + "table": { + "file_format_version": 6, + "address": "0x2", + "name": "table", + "friends": [], + "structs": { + "Table": { + "abilities": { + "abilities": [ + "Store", + "Key" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "is_phantom": true + }, + { + "constraints": { + "abilities": [ + "Store" + ] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "UID", + "type_arguments": [] + } + } + }, + { + "name": "size", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "add": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "borrow": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "borrow_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "contains": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + "Bool" + ] + }, + "destroy_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ], + "return_": [] + }, + "drop": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Drop", + "Store" + ] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ], + "return_": [] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "length": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + { + "abilities": [ + "Store" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "table", + "name": "Table", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "TypeParameter": 1 + } + ] + } + } + }, + "transfer": { + "file_format_version": 6, + "address": "0x2", + "name": "transfer", + "friends": [], + "structs": {}, + "exposed_functions": { + "freeze_object": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + } + ], + "return_": [] + }, + "share_object": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + } + ], + "return_": [] + }, + "transfer": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + }, + "Address" + ], + "return_": [] + } + } + }, + "tx_context": { + "file_format_version": 6, + "address": "0x2", + "name": "tx_context", + "friends": [ + { + "address": "0x2", + "name": "object" + } + ], + "structs": { + "TxContext": { + "abilities": { + "abilities": [ + "Drop" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "signer", + "type_": "Signer" + }, + { + "name": "tx_hash", + "type_": { + "Vector": "U8" + } + }, + { + "name": "epoch", + "type_": "U64" + }, + { + "name": "ids_created", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "epoch": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "new_object": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "sender": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + }, + "signer_": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": "Signer" + } + ] + } + } + }, + "typed_id": { + "file_format_version": 6, + "address": "0x2", + "name": "typed_id", + "friends": [], + "structs": { + "TypedID": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Key" + ] + }, + "is_phantom": true + } + ], + "fields": [ + { + "name": "id", + "type_": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "as_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "typed_id", + "name": "TypedID", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + } + ] + }, + "equals_object": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "typed_id", + "name": "TypedID", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "Bool" + ] + }, + "new": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "typed_id", + "name": "TypedID", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "to_id": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Key" + ] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "typed_id", + "name": "TypedID", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "object", + "name": "ID", + "type_arguments": [] + } + } + ] + } + } + }, + "types": { + "file_format_version": 6, + "address": "0x2", + "name": "types", + "friends": [], + "structs": {}, + "exposed_functions": { + "is_one_time_witness": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Drop" + ] + } + ], + "parameters": [ + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "Bool" + ] + } + } + }, + "url": { + "file_format_version": 6, + "address": "0x2", + "name": "url", + "friends": [], + "structs": { + "Url": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "url", + "type_": { + "Struct": { + "address": "0x1", + "module": "ascii", + "name": "String", + "type_arguments": [] + } + } + } + ] + } + }, + "exposed_functions": { + "inner_url": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "ascii", + "name": "String", + "type_arguments": [] + } + } + ] + }, + "new_unsafe": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x1", + "module": "ascii", + "name": "String", + "type_arguments": [] + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + ] + }, + "new_unsafe_from_bytes": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": "U8" + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + ] + }, + "update": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "url", + "name": "Url", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x1", + "module": "ascii", + "name": "String", + "type_arguments": [] + } + } + ], + "return_": [] + } + } + }, + "validator": { + "file_format_version": 6, + "address": "0x2", + "name": "validator", + "friends": [ + { + "address": "0x2", + "name": "genesis" + }, + { + "address": "0x2", + "name": "sui_system" + }, + { + "address": "0x2", + "name": "validator_set" + } + ], + "structs": { + "Validator": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "metadata", + "type_": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "ValidatorMetadata", + "type_arguments": [] + } + } + }, + { + "name": "stake_amount", + "type_": "U64" + }, + { + "name": "pending_stake", + "type_": "U64" + }, + { + "name": "pending_withdraw", + "type_": "U64" + }, + { + "name": "gas_price", + "type_": "U64" + }, + { + "name": "delegation_staking_pool", + "type_": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + }, + { + "name": "commission_rate", + "type_": "U64" + } + ] + }, + "ValidatorMetadata": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "sui_address", + "type_": "Address" + }, + { + "name": "pubkey_bytes", + "type_": { + "Vector": "U8" + } + }, + { + "name": "network_pubkey_bytes", + "type_": { + "Vector": "U8" + } + }, + { + "name": "proof_of_possession", + "type_": { + "Vector": "U8" + } + }, + { + "name": "name", + "type_": { + "Vector": "U8" + } + }, + { + "name": "net_address", + "type_": { + "Vector": "U8" + } + }, + { + "name": "next_epoch_stake", + "type_": "U64" + }, + { + "name": "next_epoch_delegation", + "type_": "U64" + }, + { + "name": "next_epoch_gas_price", + "type_": "U64" + }, + { + "name": "next_epoch_commission_rate", + "type_": "U64" + } + ] + } + }, + "exposed_functions": { + "adjust_stake_and_gas_price": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "commission_rate": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "decrease_next_epoch_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + "U64" + ], + "return_": [] + }, + "delegate_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "deposit_delegation_rewards": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + ], + "return_": [] + }, + "destroy": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "gas_price": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "get_staking_pool_mut_ref": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakingPool", + "type_arguments": [] + } + } + } + ] + }, + "is_duplicate": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "metadata": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "ValidatorMetadata", + "type_arguments": [] + } + } + } + ] + }, + "new": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + "Address", + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Vector": "U8" + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + "U64", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + ] + }, + "pending_stake_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "pending_withdraw": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "process_pending_delegations_and_withdraws": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + "Address", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_stake": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_set_commission_rate": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + "U64" + ], + "return_": [] + }, + "request_set_gas_price": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + "U64" + ], + "return_": [] + }, + "request_withdraw_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_stake": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + } + }, + "U64", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "stake_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "sui_address": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + "Address" + ] + } + } + }, + "validator_set": { + "file_format_version": 6, + "address": "0x2", + "name": "validator_set", + "friends": [ + { + "address": "0x2", + "name": "sui_system" + } + ], + "structs": { + "ValidatorPair": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "from", + "type_": "Address" + }, + { + "name": "to", + "type_": "Address" + } + ] + }, + "ValidatorSet": { + "abilities": { + "abilities": [ + "Store" + ] + }, + "type_parameters": [], + "fields": [ + { + "name": "total_validator_stake", + "type_": "U64" + }, + { + "name": "total_delegation_stake", + "type_": "U64" + }, + { + "name": "quorum_stake_threshold", + "type_": "U64" + }, + { + "name": "active_validators", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + }, + { + "name": "pending_validators", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + }, + { + "name": "pending_removals", + "type_": { + "Vector": "U64" + } + }, + { + "name": "next_epoch_validators", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "ValidatorMetadata", + "type_arguments": [] + } + } + } + }, + { + "name": "pending_delegation_switches", + "type_": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorPair", + "type_arguments": [] + } + }, + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "PendingWithdrawEntry", + "type_arguments": [] + } + } + } + ] + } + } + } + ] + } + }, + "exposed_functions": { + "advance_epoch": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + "Address", + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + "Address" + ] + } + } + ] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "derive_reference_gas_price": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "is_active_validator": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + "Bool" + ] + }, + "new": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Vector": { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + ] + }, + "next_epoch_validator_count": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "request_add_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "Address", + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_stake": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "balance", + "name": "Balance", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "sui", + "name": "SUI", + "type_arguments": [] + } + } + ] + } + }, + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + { + "Struct": { + "address": "0x2", + "module": "epoch_time_lock", + "name": "EpochTimeLock", + "type_arguments": [] + } + } + ] + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_add_validator": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "Struct": { + "address": "0x2", + "module": "validator", + "name": "Validator", + "type_arguments": [] + } + } + ], + "return_": [] + }, + "request_remove_validator": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_set_commission_rate": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_set_gas_price": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_switch_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "Address", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_delegation": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "Delegation", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "staking_pool", + "name": "StakedSui", + "type_arguments": [] + } + } + }, + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "request_withdraw_stake": { + "visibility": "Friend", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "stake", + "name": "Stake", + "type_arguments": [] + } + } + }, + "U64", + "U64", + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "tx_context", + "name": "TxContext", + "type_arguments": [] + } + } + } + ], + "return_": [] + }, + "total_delegation_stake": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "total_validator_stake": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + } + ], + "return_": [ + "U64" + ] + }, + "validator_delegate_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + "U64" + ] + }, + "validator_stake_amount": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "validator_set", + "name": "ValidatorSet", + "type_arguments": [] + } + } + }, + "Address" + ], + "return_": [ + "U64" + ] + } + } + }, + "vec_map": { + "file_format_version": 6, + "address": "0x2", + "name": "vec_map", + "friends": [], + "structs": { + "Entry": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy" + ] + }, + "is_phantom": false + }, + { + "constraints": { + "abilities": [] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "key", + "type_": { + "TypeParameter": 0 + } + }, + { + "name": "value", + "type_": { + "TypeParameter": 1 + } + } + ] + }, + "VecMap": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy" + ] + }, + "is_phantom": false + }, + { + "constraints": { + "abilities": [] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "contents", + "type_": { + "Vector": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "Entry", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + } + ] + } + }, + "exposed_functions": { + "contains": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "Bool" + ] + }, + "destroy_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ], + "return_": [] + }, + "empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ] + }, + "get": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "get_entry_by_idx": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Reference": { + "TypeParameter": 0 + } + }, + { + "Reference": { + "TypeParameter": 1 + } + } + ] + }, + "get_entry_by_idx_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "Reference": { + "TypeParameter": 0 + } + }, + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "get_idx": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "U64" + ] + }, + "get_idx_opt": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "Struct": { + "address": "0x1", + "module": "option", + "name": "Option", + "type_arguments": [ + "U64" + ] + } + } + ] + }, + "get_mut": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "MutableReference": { + "TypeParameter": 1 + } + } + ] + }, + "insert": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ], + "return_": [] + }, + "into_keys_values": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + ], + "return_": [ + { + "Vector": { + "TypeParameter": 0 + } + }, + { + "Vector": { + "TypeParameter": 1 + } + } + ] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "pop": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + }, + "remove_entry_by_idx": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + }, + "U64" + ], + "return_": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + }, + "size": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy" + ] + }, + { + "abilities": [] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_map", + "name": "VecMap", + "type_arguments": [ + { + "TypeParameter": 0 + }, + { + "TypeParameter": 1 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + } + } + }, + "vec_set": { + "file_format_version": 6, + "address": "0x2", + "name": "vec_set", + "friends": [], + "structs": { + "VecSet": { + "abilities": { + "abilities": [ + "Copy", + "Drop", + "Store" + ] + }, + "type_parameters": [ + { + "constraints": { + "abilities": [ + "Copy", + "Drop" + ] + }, + "is_phantom": false + } + ], + "fields": [ + { + "name": "contents", + "type_": { + "Vector": { + "TypeParameter": 0 + } + } + } + ] + } + }, + "exposed_functions": { + "contains": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [ + "Bool" + ] + }, + "empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "insert": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "TypeParameter": 0 + } + ], + "return_": [] + }, + "into_keys": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ], + "return_": [ + { + "Vector": { + "TypeParameter": 0 + } + } + ] + }, + "is_empty": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "Bool" + ] + }, + "remove": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "MutableReference": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + }, + { + "Reference": { + "TypeParameter": 0 + } + } + ], + "return_": [] + }, + "singleton": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "TypeParameter": 0 + } + ], + "return_": [ + { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + ] + }, + "size": { + "visibility": "Public", + "is_entry": false, + "type_parameters": [ + { + "abilities": [ + "Copy", + "Drop" + ] + } + ], + "parameters": [ + { + "Reference": { + "Struct": { + "address": "0x2", + "module": "vec_set", + "name": "VecSet", + "type_arguments": [ + { + "TypeParameter": 0 + } + ] + } + } + } + ], + "return_": [ + "U64" + ] + } + } + } + }, + "id": 1 +} \ No newline at end of file