@typus/typus-sdk 1.4.3-c → 1.4.3-e

package/src/_dependencies/source/0x2/group-ops/structs.ts

@@ -0,0 +1,70 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr, Vector, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Element =============================== */
+
+export function isElement(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::group_ops::Element<"); }
+
+export interface ElementFields<T extends PhantomTypeArgument> { bytes: ToField<Vector<"u8">> }
+
+export type ElementReified<T extends PhantomTypeArgument> = Reified< Element<T>, ElementFields<T> >;
+
+export class Element<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x2::group_ops::Element"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = Element.$typeName;
+
+ readonly $fullTypeName: `0x2::group_ops::Element<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly bytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: ElementFields<T>, ) { this.$fullTypeName = composeSuiType( Element.$typeName, ...typeArgs ) as `0x2::group_ops::Element<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.bytes = fields.bytes; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): ElementReified<ToPhantomTypeArgument<T>> { return { typeName: Element.$typeName, fullTypeName: composeSuiType( Element.$typeName, ...[extractType(T)] ) as `0x2::group_ops::Element<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => Element.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Element.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => Element.fromBcs( T, data, ), bcs: Element.bcs, fromJSONField: (field: any) => Element.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => Element.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => Element.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => Element.fetch( client, T, id, ), new: ( fields: ElementFields<ToPhantomTypeArgument<T>>, ) => { return new Element( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Element.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<Element<ToPhantomTypeArgument<T>>>> { return phantom(Element.reified( T )); } static get p() { return Element.phantom }
+
+ static get bcs() { return bcs.struct("Element", {
+
+ bytes: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): Element<ToPhantomTypeArgument<T>> { return Element.reified( typeArg, ).new( { bytes: decodeFromFields(reified.vector("u8"), fields.bytes) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): Element<ToPhantomTypeArgument<T>> { if (!isElement(item.type)) { throw new Error("not a Element type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return Element.reified( typeArg, ).new( { bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): Element<ToPhantomTypeArgument<T>> { return Element.fromFields( typeArg, Element.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ bytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.bytes),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): Element<ToPhantomTypeArgument<T>> { return Element.reified( typeArg, ).new( { bytes: decodeFromJSONField(reified.vector("u8"), field.bytes) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): Element<ToPhantomTypeArgument<T>> { if (json.$typeName !== Element.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Element.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return Element.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): Element<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isElement(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Element object`); } return Element.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<Element<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Element object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isElement(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Element object`); }
+ return Element.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x2/index.ts

@@ -0,0 +1 @@
+export const PACKAGE_ID = "0x2"; export const PUBLISHED_AT = "0x2";

package/src/_dependencies/source/0x2/init.ts

@@ -0,0 +1,125 @@
+import * as authenticatorState from "./authenticator-state/structs";
+import * as bag from "./bag/structs";
+import * as balance from "./balance/structs";
+import * as bcs from "./bcs/structs";
+import * as bls12381 from "./bls12381/structs";
+import * as borrow from "./borrow/structs";
+import * as clock from "./clock/structs";
+import * as coin from "./coin/structs";
+import * as denyList from "./deny-list/structs";
+import * as display from "./display/structs";
+import * as dynamicField from "./dynamic-field/structs";
+import * as dynamicObjectField from "./dynamic-object-field/structs";
+import * as groth16 from "./groth16/structs";
+import * as groupOps from "./group-ops/structs";
+import * as kioskExtension from "./kiosk-extension/structs";
+import * as kiosk from "./kiosk/structs";
+import * as linkedTable from "./linked-table/structs";
+import * as objectBag from "./object-bag/structs";
+import * as objectTable from "./object-table/structs";
+import * as object from "./object/structs";
+import * as package_ from "./package/structs";
+import * as priorityQueue from "./priority-queue/structs";
+import * as random from "./random/structs";
+import * as sui from "./sui/structs";
+import * as tableVec from "./table-vec/structs";
+import * as table from "./table/structs";
+import * as token from "./token/structs";
+import * as transferPolicy from "./transfer-policy/structs";
+import * as transfer from "./transfer/structs";
+import * as txContext from "./tx-context/structs";
+import * as url from "./url/structs";
+import * as vecMap from "./vec-map/structs";
+import * as vecSet from "./vec-set/structs";
+import * as versioned from "./versioned/structs";
+import * as zkloginVerifiedId from "./zklogin-verified-id/structs";
+import * as zkloginVerifiedIssuer from "./zklogin-verified-issuer/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(groth16.Curve);
+loader.register(groth16.PreparedVerifyingKey);
+loader.register(groth16.ProofPoints);
+loader.register(groth16.PublicProofInputs);
+loader.register(txContext.TxContext);
+loader.register(object.ID);
+loader.register(object.UID);
+loader.register(transfer.Receiving);
+loader.register(dynamicField.Field);
+loader.register(authenticatorState.ActiveJwk);
+loader.register(authenticatorState.AuthenticatorState);
+loader.register(authenticatorState.AuthenticatorStateInner);
+loader.register(authenticatorState.JWK);
+loader.register(authenticatorState.JwkId);
+loader.register(bag.Bag);
+loader.register(balance.Balance);
+loader.register(balance.Supply);
+loader.register(bcs.BCS);
+loader.register(groupOps.Element);
+loader.register(bls12381.G1);
+loader.register(bls12381.G2);
+loader.register(bls12381.GT);
+loader.register(bls12381.Scalar);
+loader.register(borrow.Borrow);
+loader.register(borrow.Referent);
+loader.register(clock.Clock);
+loader.register(url.Url);
+loader.register(vecSet.VecSet);
+loader.register(table.Table);
+loader.register(denyList.DenyList);
+loader.register(denyList.PerTypeList);
+loader.register(coin.Coin);
+loader.register(coin.CoinMetadata);
+loader.register(coin.CurrencyCreated);
+loader.register(coin.DenyCap);
+loader.register(coin.RegulatedCoinMetadata);
+loader.register(coin.TreasuryCap);
+loader.register(vecMap.Entry);
+loader.register(vecMap.VecMap);
+loader.register(package_.Publisher);
+loader.register(package_.UpgradeCap);
+loader.register(package_.UpgradeReceipt);
+loader.register(package_.UpgradeTicket);
+loader.register(display.Display);
+loader.register(display.DisplayCreated);
+loader.register(display.VersionUpdated);
+loader.register(dynamicObjectField.Wrapper);
+loader.register(sui.SUI);
+loader.register(transferPolicy.RuleKey);
+loader.register(transferPolicy.TransferPolicy);
+loader.register(transferPolicy.TransferPolicyCap);
+loader.register(transferPolicy.TransferPolicyCreated);
+loader.register(transferPolicy.TransferPolicyDestroyed);
+loader.register(transferPolicy.TransferRequest);
+loader.register(kiosk.Borrow);
+loader.register(kiosk.Item);
+loader.register(kiosk.ItemDelisted);
+loader.register(kiosk.ItemListed);
+loader.register(kiosk.ItemPurchased);
+loader.register(kiosk.Kiosk);
+loader.register(kiosk.KioskOwnerCap);
+loader.register(kiosk.Listing);
+loader.register(kiosk.Lock);
+loader.register(kiosk.PurchaseCap);
+loader.register(kioskExtension.Extension);
+loader.register(kioskExtension.ExtensionKey);
+loader.register(linkedTable.LinkedTable);
+loader.register(linkedTable.Node);
+loader.register(objectBag.ObjectBag);
+loader.register(objectTable.ObjectTable);
+loader.register(priorityQueue.Entry);
+loader.register(priorityQueue.PriorityQueue);
+loader.register(versioned.VersionChangeCap);
+loader.register(versioned.Versioned);
+loader.register(random.Random);
+loader.register(random.RandomGenerator);
+loader.register(random.RandomInner);
+loader.register(tableVec.TableVec);
+loader.register(token.RuleKey);
+loader.register(token.ActionRequest);
+loader.register(token.Token);
+loader.register(token.TokenPolicy);
+loader.register(token.TokenPolicyCap);
+loader.register(token.TokenPolicyCreated);
+loader.register(zkloginVerifiedId.VerifiedID);
+loader.register(zkloginVerifiedIssuer.VerifiedIssuer);
+ }