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

package/dist/src/_framework/reified.js

@@ -1,263 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vector = void 0;
-exports.phantom = phantom;
-exports.vector = vector;
-exports.toBcs = toBcs;
-exports.extractType = extractType;
-exports.decodeFromFields = decodeFromFields;
-exports.decodeFromFieldsWithTypes = decodeFromFieldsWithTypes;
-exports.assertReifiedTypeArgsMatch = assertReifiedTypeArgsMatch;
-exports.assertFieldsWithTypesArgsMatch = assertFieldsWithTypesArgsMatch;
-exports.fieldToJSON = fieldToJSON;
-exports.decodeFromJSONField = decodeFromJSONField;
-var bcs_1 = require("@mysten/bcs");
-var util_1 = require("./util");
-var Vector = /** @class */ (function () {
-    function Vector(fullTypeName, vec) {
-        this.kind = "VectorClass";
-        this.$fullTypeName = fullTypeName;
-        this.vec = vec;
-    }
-    Vector.prototype.toJSONField = function () {
-        return null;
-    };
-    return Vector;
-}());
-exports.Vector = Vector;
-function phantom(type) {
-    if (typeof type === "string") {
-        return {
-            phantomType: type,
-            kind: "PhantomReified",
-        };
-    }
-    else {
-        return {
-            phantomType: type.fullTypeName,
-            kind: "PhantomReified",
-        };
-    }
-}
-function vector(T) {
-    var fullTypeName = "vector<".concat(extractType(T), ">");
-    return {
-        fullTypeName: fullTypeName,
-        bcs: bcs_1.bcs.vector(toBcs(T)),
-        fromFieldsWithTypes: function (item) {
-            return new Vector(fullTypeName, item.map(function (field) { return decodeFromFieldsWithTypes(T, field); }));
-        },
-        fromFields: function (fields) {
-            return new Vector(fullTypeName, fields.map(function (field) { return decodeFromFields(T, field); }));
-        },
-        fromJSONField: function (field) {
-            return new Vector(fullTypeName, field.map(function (field) { return decodeFromJSONField(T, field); }));
-        },
-        kind: "VectorClassReified",
-    };
-}
-var Address = bcs_1.bcs.bytes(32).transform({
-    input: function (val) { return (0, bcs_1.fromHEX)(val); },
-    output: function (val) { return (0, bcs_1.toHEX)(val); },
-});
-function toBcs(arg) {
-    switch (arg) {
-        case "bool":
-            return bcs_1.bcs.bool();
-        case "u8":
-            return bcs_1.bcs.u8();
-        case "u16":
-            return bcs_1.bcs.u16();
-        case "u32":
-            return bcs_1.bcs.u32();
-        case "u64":
-            return bcs_1.bcs.u64();
-        case "u128":
-            return bcs_1.bcs.u128();
-        case "u256":
-            return bcs_1.bcs.u256();
-        case "address":
-            return Address;
-        default:
-            return arg.bcs;
-    }
-}
-function extractType(reified) {
-    switch (reified) {
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "bool":
-        case "address":
-            return reified;
-    }
-    switch (reified.kind) {
-        case "PhantomReified":
-            return reified.phantomType;
-        case "StructClassReified":
-            return reified.fullTypeName;
-        case "VectorClassReified":
-            return reified.fullTypeName;
-    }
-    throw new Error("unreachable");
-}
-function decodeFromFields(reified, field) {
-    switch (reified) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-            return field;
-        case "u64":
-        case "u128":
-        case "u256":
-            return BigInt(field);
-        case "address":
-            return "0x".concat(field);
-    }
-    if (reified.kind === "VectorClassReified") {
-        return reified.fromFields(field).vec;
-    }
-    switch (reified.typeName) {
-        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":
-            return "0x".concat(field.bytes);
-        case "0x2::object::UID":
-            return "0x".concat(field.id.bytes);
-        case "0x1::option::Option": {
-            if (field.vec.length === 0) {
-                return null;
-            }
-            return reified.fromFields(field).vec[0];
-        }
-        default:
-            return reified.fromFields(field);
-    }
-}
-function decodeFromFieldsWithTypes(reified, item) {
-    switch (reified) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-            return item;
-        case "u64":
-        case "u128":
-        case "u256":
-            return BigInt(item);
-        case "address":
-            return item;
-    }
-    if (reified.kind === "VectorClassReified") {
-        return reified.fromFieldsWithTypes(item).vec;
-    }
-    switch (reified.typeName) {
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::url::Url":
-        case "0x2::object::ID":
-            return item;
-        case "0x2::object::UID":
-            return item.id;
-        case "0x2::balance::Balance":
-            return reified.fromFields({ value: BigInt(item) });
-        case "0x1::option::Option": {
-            if (item === null) {
-                return null;
-            }
-            return decodeFromFieldsWithTypes(reified.reifiedTypeArgs[0], item);
-        }
-        default:
-            return reified.fromFieldsWithTypes(item);
-    }
-}
-function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
-    if (reifiedTypeArgs.length !== typeArgs.length) {
-        throw new Error("provided item has mismatching number of type argments ".concat(fullType, " (expected ").concat(reifiedTypeArgs.length, ", got ").concat(typeArgs.length, "))"));
-    }
-    for (var i = 0; i < typeArgs.length; i++) {
-        if ((0, util_1.compressSuiType)(typeArgs[i]) !== (0, util_1.compressSuiType)(extractType(reifiedTypeArgs[i]))) {
-            throw new Error("provided item has mismatching type argments ".concat(fullType, " (expected ").concat(extractType(reifiedTypeArgs[i]), ", got ").concat(typeArgs[i], "))"));
-        }
-    }
-}
-function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
-    var itemTypeArgs = (0, util_1.parseTypeName)(item.type).typeArgs;
-    assertReifiedTypeArgsMatch(item.type, itemTypeArgs, reifiedTypeArgs);
-}
-function fieldToJSON(type, field) {
-    var _a = (0, util_1.parseTypeName)(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-    switch (typeName) {
-        case "bool":
-            return field;
-        case "u8":
-        case "u16":
-        case "u32":
-            return field;
-        case "u64":
-        case "u128":
-        case "u256":
-            return field.toString();
-        case "address":
-        case "signer":
-            return field;
-        case "vector":
-            return field.map(function (item) { return 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":
-            return field;
-        case "0x1::option::Option": {
-            if (field === null) {
-                return null;
-            }
-            return fieldToJSON(typeArgs[0], field);
-        }
-        default:
-            return field.toJSONField();
-    }
-}
-function decodeFromJSONField(typeArg, field) {
-    switch (typeArg) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-            return field;
-        case "u64":
-        case "u128":
-        case "u256":
-            return BigInt(field);
-        case "address":
-            return field;
-    }
-    if (typeArg.kind === "VectorClassReified") {
-        return typeArg.fromJSONField(field).vec;
-    }
-    switch (typeArg.typeName) {
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::url::Url":
-        case "0x2::object::ID":
-        case "0x2::object::UID":
-            return field;
-        case "0x1::option::Option": {
-            if (field === null) {
-                return null;
-            }
-            return decodeFromJSONField(typeArg.reifiedTypeArgs[0], field);
-        }
-        default:
-            return typeArg.fromJSONField(field);
-    }
-}

package/dist/src/_framework/util.d.ts

@@ -1,53 +0,0 @@
-import { TransactionArgument, TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
-import { ObjectArg as SuiObjectArg } from "@mysten/sui.js/bcs";
-export interface FieldsWithTypes {
-    fields: Record<string, any>;
-    type: string;
-}
-export type ObjectId = string;
-export type ObjectCallArg = {
-    Object: SuiObjectArg;
-};
-export type ObjectArg = string | ObjectCallArg | TransactionArgument;
-export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
-export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>;
-export declare function parseTypeName(name: string): {
-    typeName: string;
-    typeArgs: string[];
-};
-export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
-export declare function isTransactionObjectArgument(arg: GenericArg): arg is TransactionObjectArgument;
-export declare function obj(txb: TransactionBlock, arg: ObjectArg): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function pure(txb: TransactionBlock, arg: PureArg, type: string): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function option(txb: TransactionBlock, type: string, arg: GenericArg | null): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function generic(txb: TransactionBlock, type: string, arg: GenericArg): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function vector(txb: TransactionBlock, itemType: string, items: Array<GenericArg> | TransactionArgument): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function typeArgIsPure(type: string): boolean;
-export declare function compressSuiAddress(addr: string): string;
-export declare function compressSuiType(type: string): string;
-export declare function composeSuiType(typeName: string, ...typeArgs: string[]): string;

package/dist/src/_framework/util.js

@@ -1,251 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTypeName = parseTypeName;
-exports.isTransactionArgument = isTransactionArgument;
-exports.isTransactionObjectArgument = isTransactionObjectArgument;
-exports.obj = obj;
-exports.pure = pure;
-exports.option = option;
-exports.generic = generic;
-exports.vector = vector;
-exports.typeArgIsPure = typeArgIsPure;
-exports.compressSuiAddress = compressSuiAddress;
-exports.compressSuiType = compressSuiType;
-exports.composeSuiType = composeSuiType;
-var bcs_1 = require("@mysten/sui.js/bcs");
-function parseTypeName(name) {
-    var parsed = bcs_1.bcs.parseTypeName(name);
-    return { typeName: parsed.name, typeArgs: parsed.params };
-}
-function isTransactionArgument(arg) {
-    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
-        return false;
-    }
-    return "kind" in arg;
-}
-function isTransactionObjectArgument(arg) {
-    if (!isTransactionArgument(arg)) {
-        return false;
-    }
-    if (arg.kind === "Input" && arg.type === "pure") {
-        return false;
-    }
-    return true;
-}
-function obj(txb, arg) {
-    return isTransactionArgument(arg) ? arg : txb.object(arg);
-}
-function pure(txb, arg, type) {
-    if (isTransactionArgument(arg)) {
-        return obj(txb, arg);
-    }
-    function getBcsForType(type) {
-        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-        switch (typeName) {
-            case "bool":
-                return bcs_1.bcs.Bool;
-            case "u8":
-                return bcs_1.bcs.U8;
-            case "u16":
-                return bcs_1.bcs.U16;
-            case "u32":
-                return bcs_1.bcs.U32;
-            case "u64":
-                return bcs_1.bcs.U64;
-            case "u128":
-                return bcs_1.bcs.U128;
-            case "u256":
-                return bcs_1.bcs.U256;
-            case "address":
-                return bcs_1.bcs.Address;
-            case "0x1::string::String":
-            case "0x1::ascii::String":
-                return bcs_1.bcs.String;
-            case "0x2::object::ID":
-                return bcs_1.bcs.Address;
-            case "0x1::option::Option":
-                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
-            case "vector":
-                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
-            default:
-                throw new Error("invalid primitive type ".concat(type));
-        }
-    }
-    function isOrHasNestedTransactionArgument(arg) {
-        if (Array.isArray(arg)) {
-            return arg.some(function (item) { return isOrHasNestedTransactionArgument(item); });
-        }
-        return isTransactionArgument(arg);
-    }
-    // handle some cases when TransactionArgument is nested within a vector or option
-    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-    switch (typeName) {
-        case "0x1::option::Option":
-            if (arg === null) {
-                return txb.pure(bcs_1.bcs.option(bcs_1.bcs.Bool).serialize(null)); // bcs.Bool is arbitrary
-            }
-            if (isOrHasNestedTransactionArgument(arg)) {
-                throw new Error("nesting TransactionArgument is not supported");
-            }
-            break;
-        case "vector":
-            if (!Array.isArray(arg)) {
-                throw new Error("expected an array for vector type");
-            }
-            if (arg.length === 0) {
-                return txb.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
-            }
-            if (arg.some(function (arg) { return Array.isArray(arg) && isOrHasNestedTransactionArgument(arg); })) {
-                throw new Error("nesting TransactionArgument is not supported");
-            }
-            if (isTransactionArgument(arg[0]) && arg.filter(function (arg) { return !isTransactionArgument(arg); }).length > 0) {
-                throw new Error("mixing TransactionArgument with other types is not supported");
-            }
-            if (isTransactionObjectArgument(arg[0])) {
-                return txb.makeMoveVec({
-                    objects: arg,
-                    type: typeArgs[0],
-                });
-            }
-    }
-    return txb.pure(getBcsForType(type).serialize(arg));
-}
-function option(txb, type, arg) {
-    if (isTransactionArgument(arg)) {
-        return arg;
-    }
-    if (typeArgIsPure(type)) {
-        return pure(txb, arg, "0x1::option::Option<".concat(type, ">"));
-    }
-    if (arg === null) {
-        return txb.moveCall({
-            target: "0x1::option::none",
-            typeArguments: [type],
-            arguments: [],
-        });
-    }
-    // wrap it with some
-    var val = generic(txb, type, arg);
-    return txb.moveCall({
-        target: "0x1::option::some",
-        typeArguments: [type],
-        arguments: [val],
-    });
-}
-function generic(txb, type, arg) {
-    if (typeArgIsPure(type)) {
-        return pure(txb, arg, type);
-    }
-    else {
-        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-        if (typeName === "vector" && Array.isArray(arg)) {
-            var itemType = typeArgs[0];
-            return txb.makeMoveVec({
-                objects: arg.map(function (item) { return obj(txb, item); }),
-                type: itemType,
-            });
-        }
-        else {
-            return obj(txb, arg);
-        }
-    }
-}
-function vector(txb, itemType, items) {
-    if (typeArgIsPure(itemType)) {
-        return pure(txb, items, "vector<".concat(itemType, ">"));
-    }
-    else if (isTransactionArgument(items)) {
-        return items;
-    }
-    else {
-        var _a = parseTypeName(itemType), itemTypeName = _a.typeName, itemTypeArgs_1 = _a.typeArgs;
-        if (itemTypeName === "0x1::option::Option") {
-            var objects = items.map(function (item) { return option(txb, itemTypeArgs_1[0], item); });
-            return txb.makeMoveVec({
-                objects: objects,
-                type: itemType,
-            });
-        }
-        return txb.makeMoveVec({
-            objects: items,
-            type: itemType,
-        });
-    }
-}
-function typeArgIsPure(type) {
-    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-    switch (typeName) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "address":
-        case "signer":
-            return true;
-        case "vector":
-            return typeArgIsPure(typeArgs[0]);
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::object::ID":
-            return true;
-        case "0x1::option::Option":
-            return typeArgIsPure(typeArgs[0]);
-        default:
-            return false;
-    }
-}
-function compressSuiAddress(addr) {
-    // remove leading zeros
-    var stripped = addr.split("0x").join("");
-    for (var i = 0; i < stripped.length; i++) {
-        if (stripped[i] !== "0") {
-            return "0x".concat(stripped.substring(i));
-        }
-    }
-    return "0x0";
-}
-// Recursively removes leading zeros from a type.
-// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
-function compressSuiType(type) {
-    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
-    switch (typeName) {
-        case "bool":
-        case "u8":
-        case "u16":
-        case "u32":
-        case "u64":
-        case "u128":
-        case "u256":
-        case "address":
-        case "signer":
-            return typeName;
-        case "vector":
-            return "vector<".concat(compressSuiType(typeArgs[0]), ">");
-        default: {
-            var tok = typeName.split("::");
-            tok[0] = compressSuiAddress(tok[0]);
-            var compressedName = tok.join("::");
-            if (typeArgs.length > 0) {
-                return "".concat(compressedName, "<").concat(typeArgs.map(function (typeArg) { return compressSuiType(typeArg); }).join(","), ">");
-            }
-            else {
-                return compressedName;
-            }
-        }
-    }
-}
-function composeSuiType(typeName) {
-    var typeArgs = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        typeArgs[_i - 1] = arguments[_i];
-    }
-    if (typeArgs.length > 0) {
-        return "".concat(typeName, "<").concat(typeArgs.join(", "), ">");
-    }
-    else {
-        return typeName;
-    }
-}

package/dist/src/airdrop/authority-entry.d.ts

@@ -1,22 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-/**
-    public fun remove_airdrop<TOKEN>(
-        version: &Version,
-        typus_airdrop_registry: &mut TypusAirdropRegistry,
-        key: String,
-        ctx: &mut TxContext,
-    ): Balance<TOKEN>
-*/
-export declare function getRemoveAirdropTx(gasBudget: number, packageId: string, version: string, typusLeaderboardRegistry: string, key: string, typeArguments: string[], sender: string): Promise<TransactionBlock>;
-/**
-    public fun set_airdrop<TOKEN>(
-        version: &Version,
-        typus_airdrop_registry: &mut TypusAirdropRegistry,
-        key: String,
-        mut coins: vector<Coin<TOKEN>>,
-        mut users: vector<address>,
-        mut values: vector<u64>,
-        ctx: &mut TxContext,
-    )
-*/
-export declare function getSetAirdropTx(gasBudget: number, packageId: string, version: string, typusLeaderboardRegistry: string, key: string, coins: string[], amount: string, users: string[], values: string[], typeArguments: string[]): Promise<TransactionBlock>;