@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/_framework/reified.js

@@ -1,43 +1,50 @@
-import { bcs } from "@mysten/sui/bcs";
-import { fromHex, toHex } from "@mysten/sui/utils";
-import { compressSuiType, parseTypeName } from "./util.js";
+import { bcs } from '@mysten/sui/bcs';
+import { fromHex, toHex } from '@mysten/sui/utils';
+import { compressSuiType, parseTypeName } from './util.js';
 // for backwards compatibility
-export { vector } from "./vector.js";
+export { vector } from './vector.js';
 export function phantom(type) {
-    if (typeof type === "string") {
+    if (typeof type === 'string') {
         return {
             phantomType: type,
-            kind: "PhantomReified",
+            kind: 'PhantomReified',
         };
     }
     else {
+        // Reified handle case: read `fullTypeName` lazily so phantom handles created
+        // before `setActiveEnv(...)` still reflect the current env on each access.
+        // Without this getter, `phantomType` would freeze the typeName at phantom-call time
+        // and leak the wrong address into vector/option type-arg strings produced via
+        // `extractType(...)`.
         return {
-            phantomType: type.fullTypeName,
-            kind: "PhantomReified",
+            get phantomType() {
+                return type.fullTypeName;
+            },
+            kind: 'PhantomReified',
         };
     }
 }
 const Address = bcs.bytes(32).transform({
     input: (val) => fromHex(val),
-    output: (val) => toHex(val),
+    output: val => toHex(val),
 });
 export function toBcs(arg) {
     switch (arg) {
-        case "bool":
+        case 'bool':
             return bcs.bool();
-        case "u8":
+        case 'u8':
             return bcs.u8();
-        case "u16":
+        case 'u16':
             return bcs.u16();
-        case "u32":
+        case 'u32':
             return bcs.u32();
-        case "u64":
+        case 'u64':
             return bcs.u64();
-        case "u128":
+        case 'u128':
             return bcs.u128();
-        case "u256":
+        case 'u256':
             return bcs.u256();
-        case "address":
+        case 'address':
             return Address;
         default:
             return arg.bcs;
@@ -45,56 +52,58 @@ export function toBcs(arg) {
 }
 export function extractType(reified) {
     switch (reified) {
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "bool":
-        case "address":
+        case 'u8':
+        case 'u16':
+        case 'u32':
+        case 'u64':
+        case 'u128':
+        case 'u256':
+        case 'bool':
+        case 'address':
             return reified;
     }
     switch (reified.kind) {
-        case "PhantomReified":
+        case 'PhantomReified':
             return reified.phantomType;
-        case "StructClassReified":
+        case 'StructClassReified':
             return reified.fullTypeName;
-        case "VectorClassReified":
+        case 'VectorClassReified':
+            return reified.fullTypeName;
+        case 'EnumClassReified':
             return reified.fullTypeName;
     }
-    throw new Error("unreachable");
+    throw new Error('unreachable');
 }
 export function decodeFromFields(reified, field) {
     switch (reified) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
+        case 'bool':
+        case 'u8':
+        case 'u16':
+        case 'u32':
             return field;
-        case "u64":
-        case "u128":
-        case "u256":
+        case 'u64':
+        case 'u128':
+        case 'u256':
             return BigInt(field);
-        case "address":
+        case 'address':
             return `0x${field}`;
     }
-    if (reified.kind === "VectorClassReified") {
+    if (reified.kind === 'VectorClassReified') {
         return reified.fromFields(field).elements;
     }
     switch (reified.typeName) {
-        case "0x1::string::String":
-        case "0x1::ascii::String":
+        case '0x1::string::String':
+        case '0x1::ascii::String':
             return new TextDecoder().decode(Uint8Array.from(field.bytes)).toString();
-        case "0x2::url::Url":
-            return new TextDecoder()
-                .decode(Uint8Array.from(field.url.bytes))
-                .toString();
-        case "0x2::object::ID":
+        case '0x2::url::Url':
+            return new TextDecoder().decode(Uint8Array.from(field.url.bytes)).toString();
+        case '0x2::object::ID':
             return `0x${field.bytes}`;
-        case "0x2::object::UID":
+        case '0x2::object::UID':
             return `0x${field.id.bytes}`;
-        case "0x1::option::Option": {
+        case '0x1::type_name::TypeName':
+            return new TextDecoder().decode(Uint8Array.from(field.name.bytes)).toString();
+        case '0x1::option::Option': {
             if (field.vec.length === 0) {
                 return null;
             }
@@ -106,32 +115,34 @@ export function decodeFromFields(reified, field) {
 }
 export function decodeFromFieldsWithTypes(reified, item) {
     switch (reified) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
+        case 'bool':
+        case 'u8':
+        case 'u16':
+        case 'u32':
             return item;
-        case "u64":
-        case "u128":
-        case "u256":
+        case 'u64':
+        case 'u128':
+        case 'u256':
             return BigInt(item);
-        case "address":
+        case 'address':
             return item;
     }
-    if (reified.kind === "VectorClassReified") {
+    if (reified.kind === 'VectorClassReified') {
         return reified.fromFieldsWithTypes(item).elements;
     }
     switch (reified.typeName) {
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::url::Url":
-        case "0x2::object::ID":
+        case '0x1::string::String':
+        case '0x1::ascii::String':
+        case '0x2::url::Url':
+        case '0x2::object::ID':
             return item;
-        case "0x2::object::UID":
+        case '0x2::object::UID':
             return item.id;
-        case "0x2::balance::Balance":
+        case '0x1::type_name::TypeName':
+            return item.fields.name;
+        case '0x2::balance::Balance':
             return reified.fromFields({ value: BigInt(item) });
-        case "0x1::option::Option": {
+        case '0x1::option::Option': {
             if (item === null) {
                 return null;
             }
@@ -143,12 +154,11 @@ export function decodeFromFieldsWithTypes(reified, item) {
 }
 export function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
     if (reifiedTypeArgs.length !== typeArgs.length) {
-        throw new Error(`provided item has mismatching number of type arguments ${fullType} (expected ${reifiedTypeArgs.length}, got ${typeArgs.length}))`);
+        throw new Error(`provided item has mismatching number of type argments ${fullType} (expected ${reifiedTypeArgs.length}, got ${typeArgs.length}))`);
     }
     for (let i = 0; i < typeArgs.length; i++) {
-        if (compressSuiType(typeArgs[i]) !==
-            compressSuiType(extractType(reifiedTypeArgs[i]))) {
-            throw new Error(`provided item has mismatching type arguments ${fullType} (expected ${extractType(reifiedTypeArgs[i])}, got ${typeArgs[i]}))`);
+        if (compressSuiType(typeArgs[i]) !== compressSuiType(extractType(reifiedTypeArgs[i]))) {
+            throw new Error(`provided item has mismatching type argments ${fullType} (expected ${extractType(reifiedTypeArgs[i])}, got ${typeArgs[i]}))`);
         }
     }
 }
@@ -159,29 +169,30 @@ export function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
 export function fieldToJSON(type, field) {
     const { typeName, typeArgs } = parseTypeName(type);
     switch (typeName) {
-        case "bool":
+        case 'bool':
             return field;
-        case "u8":
-        case "u16":
-        case "u32":
+        case 'u8':
+        case 'u16':
+        case 'u32':
             return field;
-        case "u64":
-        case "u128":
-        case "u256":
+        case 'u64':
+        case 'u128':
+        case 'u256':
             return field.toString();
-        case "address":
-        case "signer":
+        case 'address':
+        case 'signer':
             return field;
-        case "vector":
+        case 'vector':
             return field.map((item) => fieldToJSON(typeArgs[0], item));
         // handle special types
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::url::Url":
-        case "0x2::object::ID":
-        case "0x2::object::UID":
+        case '0x1::string::String':
+        case '0x1::ascii::String':
+        case '0x2::url::Url':
+        case '0x2::object::ID':
+        case '0x2::object::UID':
+        case '0x1::type_name::TypeName':
             return field;
-        case "0x1::option::Option": {
+        case '0x1::option::Option': {
             if (field === null) {
                 return null;
             }
@@ -193,29 +204,30 @@ export function fieldToJSON(type, field) {
 }
 export function decodeFromJSONField(typeArg, field) {
     switch (typeArg) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
+        case 'bool':
+        case 'u8':
+        case 'u16':
+        case 'u32':
             return field;
-        case "u64":
-        case "u128":
-        case "u256":
+        case 'u64':
+        case 'u128':
+        case 'u256':
             return BigInt(field);
-        case "address":
+        case 'address':
             return field;
     }
-    if (typeArg.kind === "VectorClassReified") {
+    if (typeArg.kind === 'VectorClassReified') {
         return typeArg.fromJSONField(field).elements;
     }
     switch (typeArg.typeName) {
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::url::Url":
-        case "0x2::object::ID":
-        case "0x2::object::UID":
+        case '0x1::string::String':
+        case '0x1::ascii::String':
+        case '0x2::url::Url':
+        case '0x2::object::ID':
+        case '0x2::object::UID':
+        case '0x1::type_name::TypeName':
             return field;
-        case "0x1::option::Option": {
+        case '0x1::option::Option': {
             if (field === null) {
                 return null;
             }

package/_generated/_framework/util.d.ts

@@ -1,4 +1,4 @@
-import { Transaction, TransactionArgument, TransactionObjectArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument, TransactionObjectInput } from '@mysten/sui/transactions';
 export interface FieldsWithTypes {
     fields: Record<string, any>;
     type: string;
@@ -12,10 +12,10 @@ export declare function parseTypeName(name: string): {
     typeArgs: string[];
 };
 export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
-export declare function obj(tx: Transaction, arg: TransactionObjectInput): TransactionObjectArgument;
+export declare function obj(tx: Transaction, arg: TransactionObjectInput): TransactionArgument;
 export declare function pure(tx: Transaction, arg: PureArg, type: string): TransactionArgument;
-export declare function option(tx: Transaction, type: string, arg: GenericArg | null): TransactionObjectArgument | TransactionArgument;
-export declare function generic(tx: Transaction, type: string, arg: GenericArg): TransactionObjectArgument | TransactionArgument;
+export declare function option(tx: Transaction, type: string, arg: GenericArg | null): TransactionArgument;
+export declare function generic(tx: Transaction, type: string, arg: GenericArg): TransactionArgument;
 export declare function vector(tx: Transaction, itemType: string, items: Array<GenericArg> | TransactionArgument): TransactionArgument;
 export declare function typeArgIsPure(type: string): boolean;
 export declare function compressSuiAddress(addr: string): string;