@bitgo/sdk-coin-sui 1.7.1 → 2.0.0

package/dist/src/lib/txnSchema.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiMoveCallTransactionSchema = exports.StakeTransactionSchema = exports.RequestSwitchDelegationTransactionSchema = exports.RequestWithdrawDelegationTransactionSchema = exports.RequestAddDelegationTransactionSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const SuiObjectRefSchema = joi_1.default.object({
+    objectId: joi_1.default.string().required(),
+    version: joi_1.default.number().required(),
+    digest: joi_1.default.string().required(),
+});
+const SharedObjectRefSchema = joi_1.default.object({
+    objectId: joi_1.default.string().required(),
+    initialSharedVersion: joi_1.default.number().required(),
+});
+const ImmOrOwnedArgSchema = joi_1.default.object({
+    ImmOrOwned: SuiObjectRefSchema.required(),
+});
+const SharedArgSchema = joi_1.default.object({
+    Shared: SharedObjectRefSchema.required(),
+});
+const ObjectArgSchema = joi_1.default.alternatives().try(ImmOrOwnedArgSchema, SharedArgSchema);
+const ObjVecArgSchema = joi_1.default.object({
+    ObjVec: joi_1.default.array().items(ObjectArgSchema).required(),
+});
+const CallArgSchema = joi_1.default.alternatives().try(joi_1.default.object({
+    Pure: joi_1.default.array().items(joi_1.default.number()).required(),
+}), joi_1.default.object({
+    Object: ObjectArgSchema.required(),
+}), ObjVecArgSchema);
+const SuiJsonValueSchema = joi_1.default
+    .alternatives()
+    .try(joi_1.default.boolean(), joi_1.default.number(), joi_1.default.string(), SuiObjectRefSchema, SharedObjectRefSchema, CallArgSchema, joi_1.default.array().items(joi_1.default.any()));
+const StructTagSchema = joi_1.default.object({
+    address: joi_1.default.string().required(),
+    module: joi_1.default.string().required(),
+    name: joi_1.default.string().required(),
+    typeParams: joi_1.default.array().items(joi_1.default.any()).optional(),
+});
+const TypeTagSchema = joi_1.default
+    .alternatives()
+    .try(joi_1.default.object({ bool: joi_1.default.equal(null).required() }), joi_1.default.object({ u8: joi_1.default.equal(null).required() }), joi_1.default.object({ u64: joi_1.default.equal(null).required() }), joi_1.default.object({ u128: joi_1.default.equal(null).required() }), joi_1.default.object({ address: joi_1.default.equal(null).required() }), joi_1.default.object({ signer: joi_1.default.equal(null).required() }), joi_1.default.object({ vector: joi_1.default.any().required() }), joi_1.default.object({ struct: StructTagSchema.required() }), joi_1.default.object({ u16: joi_1.default.equal(null).required() }), joi_1.default.object({ u32: joi_1.default.equal(null).required() }), joi_1.default.object({ u256: joi_1.default.equal(null).required() }));
+const TypeArgumentsSchema = joi_1.default.array().items(TypeTagSchema).required();
+const RequestAddDelegationArgumentsSchema = joi_1.default.array().length(4).items(SuiJsonValueSchema).required();
+const RequestWithdrawArgumentsSchema = joi_1.default.array().length(3).items(SuiJsonValueSchema).required();
+const RequestSwitchArgumentsSchema = joi_1.default.array().length(4).items(SuiJsonValueSchema).required();
+exports.RequestAddDelegationTransactionSchema = joi_1.default.object({
+    package: joi_1.default.alternatives(SuiObjectRefSchema).match('one').required(),
+    module: joi_1.default.string().required(),
+    function: joi_1.default.string().required(),
+    typeArguments: TypeArgumentsSchema.optional(),
+    arguments: RequestAddDelegationArgumentsSchema.required(),
+});
+exports.RequestWithdrawDelegationTransactionSchema = joi_1.default.object({
+    package: joi_1.default.alternatives(SuiObjectRefSchema).match('one').required(),
+    module: joi_1.default.string().required(),
+    function: joi_1.default.string().required(),
+    typeArguments: TypeArgumentsSchema.optional(),
+    arguments: RequestWithdrawArgumentsSchema.required(),
+});
+exports.RequestSwitchDelegationTransactionSchema = joi_1.default.object({
+    package: joi_1.default.alternatives(SuiObjectRefSchema).match('one').required(),
+    module: joi_1.default.string().required(),
+    function: joi_1.default.string().required(),
+    typeArguments: TypeArgumentsSchema.optional(),
+    arguments: RequestSwitchArgumentsSchema.required(),
+});
+exports.StakeTransactionSchema = joi_1.default.alternatives(exports.RequestAddDelegationTransactionSchema).match('one');
+exports.SuiMoveCallTransactionSchema = joi_1.default.object({
+    type: joi_1.default.string().required(),
+    sender: joi_1.default.string().required(),
+    tx: joi_1.default
+        .alternatives(exports.RequestAddDelegationTransactionSchema, exports.RequestWithdrawDelegationTransactionSchema, exports.RequestSwitchDelegationTransactionSchema)
+        .match('any')
+        .required(),
+    gasBudget: joi_1.default.number().required(),
+    gasPrice: joi_1.default.number().required(),
+    gasPayment: joi_1.default.alternatives(SuiObjectRefSchema).match('one').required(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txnSchema.js","sourceRoot":"","sources":["../../../src/lib/txnSchema.ts"],"names":[],"mappings":"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","sourcesContent":["import joi from 'joi';\n\nconst SuiObjectRefSchema = joi.object({\n  objectId: joi.string().required(),\n  version: joi.number().required(),\n  digest: joi.string().required(),\n});\n\nconst SharedObjectRefSchema = joi.object({\n  objectId: joi.string().required(),\n  initialSharedVersion: joi.number().required(),\n});\n\nconst ImmOrOwnedArgSchema = joi.object({\n  ImmOrOwned: SuiObjectRefSchema.required(),\n});\n\nconst SharedArgSchema = joi.object({\n  Shared: SharedObjectRefSchema.required(),\n});\n\nconst ObjectArgSchema = joi.alternatives().try(ImmOrOwnedArgSchema, SharedArgSchema);\n\nconst ObjVecArgSchema = joi.object({\n  ObjVec: joi.array().items(ObjectArgSchema).required(),\n});\n\nconst CallArgSchema = joi.alternatives().try(\n  joi.object({\n    Pure: joi.array().items(joi.number()).required(),\n  }),\n  joi.object({\n    Object: ObjectArgSchema.required(),\n  }),\n  ObjVecArgSchema\n);\n\nconst SuiJsonValueSchema = joi\n  .alternatives()\n  .try(\n    joi.boolean(),\n    joi.number(),\n    joi.string(),\n    SuiObjectRefSchema,\n    SharedObjectRefSchema,\n    CallArgSchema,\n    joi.array().items(joi.any())\n  );\n\nconst StructTagSchema = joi.object({\n  address: joi.string().required(),\n  module: joi.string().required(),\n  name: joi.string().required(),\n  typeParams: joi.array().items(joi.any()).optional(),\n});\n\nconst TypeTagSchema = joi\n  .alternatives()\n  .try(\n    joi.object({ bool: joi.equal(null).required() }),\n    joi.object({ u8: joi.equal(null).required() }),\n    joi.object({ u64: joi.equal(null).required() }),\n    joi.object({ u128: joi.equal(null).required() }),\n    joi.object({ address: joi.equal(null).required() }),\n    joi.object({ signer: joi.equal(null).required() }),\n    joi.object({ vector: joi.any().required() }),\n    joi.object({ struct: StructTagSchema.required() }),\n    joi.object({ u16: joi.equal(null).required() }),\n    joi.object({ u32: joi.equal(null).required() }),\n    joi.object({ u256: joi.equal(null).required() })\n  );\n\nconst TypeArgumentsSchema = joi.array().items(TypeTagSchema).required();\nconst RequestAddDelegationArgumentsSchema = joi.array().length(4).items(SuiJsonValueSchema).required();\nconst RequestWithdrawArgumentsSchema = joi.array().length(3).items(SuiJsonValueSchema).required();\nconst RequestSwitchArgumentsSchema = joi.array().length(4).items(SuiJsonValueSchema).required();\n\nexport const RequestAddDelegationTransactionSchema = joi.object({\n  package: joi.alternatives(SuiObjectRefSchema).match('one').required(),\n  module: joi.string().required(),\n  function: joi.string().required(),\n  typeArguments: TypeArgumentsSchema.optional(),\n  arguments: RequestAddDelegationArgumentsSchema.required(),\n});\n\nexport const RequestWithdrawDelegationTransactionSchema = joi.object({\n  package: joi.alternatives(SuiObjectRefSchema).match('one').required(),\n  module: joi.string().required(),\n  function: joi.string().required(),\n  typeArguments: TypeArgumentsSchema.optional(),\n  arguments: RequestWithdrawArgumentsSchema.required(),\n});\n\nexport const RequestSwitchDelegationTransactionSchema = joi.object({\n  package: joi.alternatives(SuiObjectRefSchema).match('one').required(),\n  module: joi.string().required(),\n  function: joi.string().required(),\n  typeArguments: TypeArgumentsSchema.optional(),\n  arguments: RequestSwitchArgumentsSchema.required(),\n});\n\nexport const StakeTransactionSchema = joi.alternatives(RequestAddDelegationTransactionSchema).match('one');\nexport const SuiMoveCallTransactionSchema = joi.object({\n  type: joi.string().required(),\n  sender: joi.string().required(),\n  tx: joi\n    .alternatives(\n      RequestAddDelegationTransactionSchema,\n      RequestWithdrawDelegationTransactionSchema,\n      RequestSwitchDelegationTransactionSchema\n    )\n    .match('any')\n    .required(),\n  gasBudget: joi.number().required(),\n  gasPrice: joi.number().required(),\n  gasPayment: joi.alternatives(SuiObjectRefSchema).match('one').required(),\n});\n"]}

package/dist/src/lib/utils.d.ts

@@ -1,4 +1,5 @@
-import { BaseUtils } from '@bitgo/sdk-core';
+import { BaseUtils, TransactionType } from '@bitgo/sdk-core';
+import { CallArg, ObjVecArg, SharedObjectRef, SuiAddress, SuiObjectRef, SuiTransactionType } from './iface';
 export declare class Utils implements BaseUtils {
     /** @inheritdoc */
     isValidBlockId(hash: string): boolean;
@@ -48,11 +49,119 @@ export declare class Utils implements BaseUtils {
      * @returns {boolean} - the validation result
      */
     isValidAmounts(amounts: number[]): boolean;
+    /**
+     * Returns whether or not the string is a valid amount
+     *
+     * @param {number} amounts - the amount to validate
+     * @returns {boolean} - the validation result
+     */
     isValidAmount(amount: number): boolean;
     /**
-     Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.
+     * Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.
+     *
+     * @param {string} id
+     * @return {string}
      **/
     normalizeHexId(id: string): string;
+    /**
+     * Map Shared object to CallArg
+     *
+     * @param {SharedObjectRef} obj
+     * @return { Object: ObjectArg }
+     *
+     * example: { Object: { Shared: SUI_SYSTEM_STATE_OBJECT } };
+     */
+    mapSharedObjectToCallArg(obj: SharedObjectRef): CallArg;
+    /**
+     * Normalize ObjectId and version
+     *
+     * @param {SharedObjectRef} obj
+     * @return {SharedObjectRef}
+     */
+    normalizeObject(obj: SharedObjectRef): SharedObjectRef;
+    /**
+     * Map CallArg object to Shared
+     *
+     * @param {CallArg} callArg
+     * @return {SharedObjectRef}
+     */
+    mapCallArgToSharedObject(callArg: CallArg): SharedObjectRef;
+    /**
+     * Map coins objects to CallArg
+     *
+     * @param {SuiObjectRef[]} coins
+     * @return {CallArg}
+     * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }
+     */
+    mapCoinsToCallArg(coins: SuiObjectRef[]): CallArg;
+    /**
+     * Map CallArg object to Coins
+     *
+     * @param {ObjVecArg} callArg
+     * @return {SuiObjectRef[]}
+     */
+    mapCallArgToCoins(callArg: ObjVecArg): SuiObjectRef[];
+    /**
+     * Map SuiObjectRef object to CallArg
+     *
+     * @param {SuiObjectRef[]} coins
+     * @return {CallArg}
+     * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }
+     */
+    mapSuiObjectRefToCallArg(suiObjectRef: SuiObjectRef): CallArg;
+    /**
+     * Map CallArg object to SuiObjectRef
+     *
+     * @param {ObjVecArg} callArg
+     * @return {SuiObjectRef}
+     */
+    mapCallArgToSuiObjectRef(callArg: CallArg): SuiObjectRef;
+    /**
+     * Map staking amount to CallArg
+     *
+     * @param {number} amount
+     * @return {CallArg}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapAmountToCallArg(amount: number): CallArg;
+    /**
+     * Map CallArg to staking amount
+     *
+     * @param {CallArg} callArg
+     * @return {number}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapCallArgToAmount(callArg: CallArg): number;
+    /**
+     * Map staking validator address to CallArg
+     *
+     * @param {SuiAddress} suiAddress
+     * @return {CallArg}
+     * example: { Pure: bcs.ser('address', VALIDATOR_ADDRESS).toBytes() };
+     */
+    mapAddressToCallArg(address: SuiAddress): CallArg;
+    /**
+     * Map CallArg to staking amount
+     *
+     * @param {CallArg} callArg
+     * @return {string}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapCallArgToAddress(callArg: CallArg): string;
+    /**
+     * Get transaction type by function name
+     *
+     * @param {MethodNames} fctName
+     * @return {TransactionType}
+     */
+    getTransactionType(fctName: string): TransactionType;
+    /**
+     * Get SUI transaction type by function name
+     *
+     * @param {MethodNames} fctName
+     * @return {SuiTransactionType}
+     */
+    getSuiTransactionType(fctName: string): SuiTransactionType;
 }
 declare const utils: Utils;
 export default utils;

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyE,MAAM,iBAAiB,CAAC;AAMnH,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;OAKG;IACH,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAWtD;;;;OAIG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IASpD;;;;;OAKG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM/D;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAMzD,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI7B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIvC;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO;IAS1C,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAQtC;;QAEI;IACJ,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;CAGnC;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKT,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAKzB,OAAO,EACL,OAAO,EAIP,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAGjB,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;OAKG;IACH,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAWtD;;;;OAIG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IASpD;;;;;OAKG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM/D;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAMzD,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI7B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIvC;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO;IAS1C;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAQtC;;;;;QAKI;IACJ,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAIlC;;;;;;;OAOG;IACH,wBAAwB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO;IAIvD;;;;;OAKG;IACH,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe;IAOtD;;;;;OAKG;IACH,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe;IAI3D;;;;;;OAMG;IACH,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO;IAQjD;;;;;OAKG;IACH,iBAAiB,CAAC,OAAO,EAAE,SAAS,GAAG,YAAY,EAAE;IAMrD;;;;;;OAMG;IACH,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO;IAM7D;;;;;OAKG;IACH,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY;IAIxD;;;;;;OAMG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAU3C;;;;;;OAMG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM;IAY5C;;;;;;OAMG;IACH,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO;IAUjD;;;;;;OAMG;IACH,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM;IAY7C;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IAapD;;;;;OAKG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB;CAY3D;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -9,6 +9,8 @@ const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const constants_1 = require("./constants");
 const bcs_1 = require("./bcs");
 const bcs_2 = require("@mysten/bcs");
+const iface_1 = require("./iface");
+const buffer_1 = require("buffer");
 class Utils {
     /** @inheritdoc */
     isValidBlockId(hash) {
@@ -106,6 +108,12 @@ class Utils {
         }
         return true;
     }
+    /**
+     * Returns whether or not the string is a valid amount
+     *
+     * @param {number} amounts - the amount to validate
+     * @returns {boolean} - the validation result
+     */
     isValidAmount(amount) {
         const bigNumberAmount = new bignumber_js_1.default(amount);
         if (!bigNumberAmount.isInteger() || bigNumberAmount.isLessThanOrEqualTo(0)) {
@@ -114,13 +122,204 @@ class Utils {
         return true;
     }
     /**
-     Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.
+     * Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.
+     *
+     * @param {string} id
+     * @return {string}
      **/
     normalizeHexId(id) {
         return id.startsWith('0x') ? id : '0x'.concat(id);
     }
+    /**
+     * Map Shared object to CallArg
+     *
+     * @param {SharedObjectRef} obj
+     * @return { Object: ObjectArg }
+     *
+     * example: { Object: { Shared: SUI_SYSTEM_STATE_OBJECT } };
+     */
+    mapSharedObjectToCallArg(obj) {
+        return { Object: { Shared: utils.normalizeObject(obj) } };
+    }
+    /**
+     * Normalize ObjectId and version
+     *
+     * @param {SharedObjectRef} obj
+     * @return {SharedObjectRef}
+     */
+    normalizeObject(obj) {
+        return {
+            objectId: utils.normalizeHexId(obj.objectId),
+            initialSharedVersion: Number(obj.initialSharedVersion),
+        };
+    }
+    /**
+     * Map CallArg object to Shared
+     *
+     * @param {CallArg} callArg
+     * @return {SharedObjectRef}
+     */
+    mapCallArgToSharedObject(callArg) {
+        return callArg['Object'].Shared;
+    }
+    /**
+     * Map coins objects to CallArg
+     *
+     * @param {SuiObjectRef[]} coins
+     * @return {CallArg}
+     * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }
+     */
+    mapCoinsToCallArg(coins) {
+        return {
+            ObjVec: coins.map((coin) => {
+                return { ImmOrOwned: coin };
+            }),
+        };
+    }
+    /**
+     * Map CallArg object to Coins
+     *
+     * @param {ObjVecArg} callArg
+     * @return {SuiObjectRef[]}
+     */
+    mapCallArgToCoins(callArg) {
+        return Array.from(callArg.ObjVec).map((it) => {
+            return it.ImmOrOwned;
+        });
+    }
+    /**
+     * Map SuiObjectRef object to CallArg
+     *
+     * @param {SuiObjectRef[]} coins
+     * @return {CallArg}
+     * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }
+     */
+    mapSuiObjectRefToCallArg(suiObjectRef) {
+        return {
+            Object: { ImmOrOwned: suiObjectRef },
+        };
+    }
+    /**
+     * Map CallArg object to SuiObjectRef
+     *
+     * @param {ObjVecArg} callArg
+     * @return {SuiObjectRef}
+     */
+    mapCallArgToSuiObjectRef(callArg) {
+        return callArg.Object.ImmOrOwned;
+    }
+    /**
+     * Map staking amount to CallArg
+     *
+     * @param {number} amount
+     * @return {CallArg}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapAmountToCallArg(amount) {
+        try {
+            return {
+                Pure: bcs_1.bcs.ser('vector<u64>', [String(amount)]).toBytes(),
+            };
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Failed to serialize amount to call argument');
+        }
+    }
+    /**
+     * Map CallArg to staking amount
+     *
+     * @param {CallArg} callArg
+     * @return {number}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapCallArgToAmount(callArg) {
+        try {
+            if ('Pure' in callArg && callArg.Pure.length) {
+                return Number(bcs_1.bcs.de('vector<u64>', buffer_1.Buffer.from(callArg.Pure).toString('base64'), 'base64'));
+            }
+            else {
+                throw new sdk_core_1.InvalidParameterValueError('Not a valid amount CallArg');
+            }
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Failed to deserialize amount from call argument');
+        }
+    }
+    /**
+     * Map staking validator address to CallArg
+     *
+     * @param {SuiAddress} suiAddress
+     * @return {CallArg}
+     * example: { Pure: bcs.ser('address', VALIDATOR_ADDRESS).toBytes() };
+     */
+    mapAddressToCallArg(address) {
+        try {
+            return {
+                Pure: bcs_1.bcs.ser('address', address).toBytes(),
+            };
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Failed to serialize address to call argument');
+        }
+    }
+    /**
+     * Map CallArg to staking amount
+     *
+     * @param {CallArg} callArg
+     * @return {string}
+     * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };
+     */
+    mapCallArgToAddress(callArg) {
+        try {
+            if ('Pure' in callArg && callArg.Pure.length) {
+                return String(bcs_1.bcs.de('address', buffer_1.Buffer.from(callArg.Pure).toString('base64'), 'base64'));
+            }
+            else {
+                throw new sdk_core_1.InvalidParameterValueError('Not a valid address CallArg');
+            }
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Failed to deserialize address from call argument');
+        }
+    }
+    /**
+     * Get transaction type by function name
+     *
+     * @param {MethodNames} fctName
+     * @return {TransactionType}
+     */
+    getTransactionType(fctName) {
+        switch (fctName) {
+            case iface_1.MethodNames.RequestAddDelegationMulCoin:
+                return sdk_core_1.TransactionType.AddDelegator;
+            case iface_1.MethodNames.RequestWithdrawDelegation:
+                return sdk_core_1.TransactionType.StakingWithdraw;
+            case iface_1.MethodNames.RequestSwitchDelegation:
+                return sdk_core_1.TransactionType.StakingSwitch;
+            default:
+                throw new sdk_core_1.NotSupported(`Staking Transaction type with function ${fctName} not supported`);
+        }
+    }
+    /**
+     * Get SUI transaction type by function name
+     *
+     * @param {MethodNames} fctName
+     * @return {SuiTransactionType}
+     */
+    getSuiTransactionType(fctName) {
+        switch (fctName) {
+            case iface_1.MethodNames.RequestAddDelegationMulCoin:
+                return iface_1.SuiTransactionType.AddDelegation;
+            case iface_1.MethodNames.RequestWithdrawDelegation:
+                return iface_1.SuiTransactionType.WithdrawDelegation;
+            case iface_1.MethodNames.RequestSwitchDelegation:
+                return iface_1.SuiTransactionType.SwitchDelegation;
+            default:
+                throw new sdk_core_1.NotSupported(`Sui staking transaction type with function ${fctName} not supported`);
+        }
+    }
 }
 exports.Utils = Utils;
 const utils = new Utils();
 exports.default = utils;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseUtils, BuildTransactionError, ParseTransactionError, isValidEd25519PublicKey } from '@bitgo/sdk-core';\nimport BigNumber from 'bignumber.js';\nimport { SUI_ADDRESS_LENGTH } from './constants';\nimport { bcs } from './bcs';\nimport { fromB64 } from '@mysten/bcs';\n\nexport class Utils implements BaseUtils {\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    return isValidEd25519PublicKey(key);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Checks if raw transaction can be deserialized\n   *\n   * @param {string} rawTransaction - transaction in base64 string format\n   * @returns {boolean} - the validation result\n   */\n  isValidRawTransaction(rawTransaction: string): boolean {\n    try {\n      const data = fromB64(rawTransaction);\n      const deserialized = bcs.de('TransactionData', data);\n      bcs.ser('TransactionData', deserialized);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param {string} rawTransaction - Transaction in base64 string  format\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new ParseTransactionError('Invalid raw transaction: Undefined');\n    }\n    if (!this.isValidRawTransaction(rawTransaction)) {\n      throw new ParseTransactionError('Invalid raw transaction');\n    }\n  }\n\n  /**\n   * Validates addresses to check if all exist and are valid Sui public keys\n   *\n   * @param {string} addresses The address to be validated\n   * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n   */\n  validateAddresses(addresses: string[], fieldName: string): void {\n    for (const address of addresses) {\n      this.validateAddress(address, fieldName);\n    }\n  }\n\n  /**\n   * Validates address to check if it exists and is a valid Sui public key\n   *\n   * @param {string} address The address to be validated\n   * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n   */\n  validateAddress(address: string, fieldName: string): void {\n    if (!address || !this.isValidAddress(address)) {\n      throw new BuildTransactionError(`Invalid or missing ${fieldName}, got: ${address}`);\n    }\n  }\n\n  /** @inheritdoc */\n  isValidAddress(address: string): boolean {\n    return this.isHex(address) && this.getHexByteLength(address) === SUI_ADDRESS_LENGTH;\n  }\n\n  isHex(value: string): boolean {\n    return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;\n  }\n\n  getHexByteLength(value: string): number {\n    return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;\n  }\n\n  /**\n   * Returns whether or not the string is a valid amount\n   *\n   * @param {number[]} amounts - the amounts to validate\n   * @returns {boolean} - the validation result\n   */\n  isValidAmounts(amounts: number[]): boolean {\n    for (const amount of amounts) {\n      if (!this.isValidAmount(amount)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  isValidAmount(amount: number): boolean {\n    const bigNumberAmount = new BigNumber(amount);\n    if (!bigNumberAmount.isInteger() || bigNumberAmount.isLessThanOrEqualTo(0)) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.\n   **/\n  normalizeHexId(id: string): string {\n    return id.startsWith('0x') ? id : '0x'.concat(id);\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseUtils,\n  BuildTransactionError,\n  ParseTransactionError,\n  isValidEd25519PublicKey,\n  InvalidParameterValueError,\n  TransactionType,\n  NotSupported,\n} from '@bitgo/sdk-core';\nimport BigNumber from 'bignumber.js';\nimport { SUI_ADDRESS_LENGTH } from './constants';\nimport { bcs } from './bcs';\nimport { fromB64 } from '@mysten/bcs';\nimport {\n  CallArg,\n  ImmOrOwnedArg,\n  MethodNames,\n  ObjectArg,\n  ObjVecArg,\n  SharedObjectRef,\n  SuiAddress,\n  SuiObjectRef,\n  SuiTransactionType,\n} from './iface';\nimport { Buffer } from 'buffer';\n\nexport class Utils implements BaseUtils {\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    return isValidEd25519PublicKey(key);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Checks if raw transaction can be deserialized\n   *\n   * @param {string} rawTransaction - transaction in base64 string format\n   * @returns {boolean} - the validation result\n   */\n  isValidRawTransaction(rawTransaction: string): boolean {\n    try {\n      const data = fromB64(rawTransaction);\n      const deserialized = bcs.de('TransactionData', data);\n      bcs.ser('TransactionData', deserialized);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param {string} rawTransaction - Transaction in base64 string  format\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new ParseTransactionError('Invalid raw transaction: Undefined');\n    }\n    if (!this.isValidRawTransaction(rawTransaction)) {\n      throw new ParseTransactionError('Invalid raw transaction');\n    }\n  }\n\n  /**\n   * Validates addresses to check if all exist and are valid Sui public keys\n   *\n   * @param {string} addresses The address to be validated\n   * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n   */\n  validateAddresses(addresses: string[], fieldName: string): void {\n    for (const address of addresses) {\n      this.validateAddress(address, fieldName);\n    }\n  }\n\n  /**\n   * Validates address to check if it exists and is a valid Sui public key\n   *\n   * @param {string} address The address to be validated\n   * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n   */\n  validateAddress(address: string, fieldName: string): void {\n    if (!address || !this.isValidAddress(address)) {\n      throw new BuildTransactionError(`Invalid or missing ${fieldName}, got: ${address}`);\n    }\n  }\n\n  /** @inheritdoc */\n  isValidAddress(address: string): boolean {\n    return this.isHex(address) && this.getHexByteLength(address) === SUI_ADDRESS_LENGTH;\n  }\n\n  isHex(value: string): boolean {\n    return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;\n  }\n\n  getHexByteLength(value: string): number {\n    return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;\n  }\n\n  /**\n   * Returns whether or not the string is a valid amount\n   *\n   * @param {number[]} amounts - the amounts to validate\n   * @returns {boolean} - the validation result\n   */\n  isValidAmounts(amounts: number[]): boolean {\n    for (const amount of amounts) {\n      if (!this.isValidAmount(amount)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Returns whether or not the string is a valid amount\n   *\n   * @param {number} amounts - the amount to validate\n   * @returns {boolean} - the validation result\n   */\n  isValidAmount(amount: number): boolean {\n    const bigNumberAmount = new BigNumber(amount);\n    if (!bigNumberAmount.isInteger() || bigNumberAmount.isLessThanOrEqualTo(0)) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Normalizes hex ids (addresses, object ids) to always contain the '0x' prefix.\n   *\n   * @param {string} id\n   * @return {string}\n   **/\n  normalizeHexId(id: string): string {\n    return id.startsWith('0x') ? id : '0x'.concat(id);\n  }\n\n  /**\n   * Map Shared object to CallArg\n   *\n   * @param {SharedObjectRef} obj\n   * @return { Object: ObjectArg }\n   *\n   * example: { Object: { Shared: SUI_SYSTEM_STATE_OBJECT } };\n   */\n  mapSharedObjectToCallArg(obj: SharedObjectRef): CallArg {\n    return { Object: { Shared: utils.normalizeObject(obj) } };\n  }\n\n  /**\n   * Normalize ObjectId and version\n   *\n   * @param {SharedObjectRef} obj\n   * @return {SharedObjectRef}\n   */\n  normalizeObject(obj: SharedObjectRef): SharedObjectRef {\n    return {\n      objectId: utils.normalizeHexId(obj.objectId),\n      initialSharedVersion: Number(obj.initialSharedVersion),\n    };\n  }\n\n  /**\n   * Map CallArg object to Shared\n   *\n   * @param {CallArg} callArg\n   * @return {SharedObjectRef}\n   */\n  mapCallArgToSharedObject(callArg: CallArg): SharedObjectRef {\n    return callArg['Object'].Shared;\n  }\n\n  /**\n   * Map coins objects to CallArg\n   *\n   * @param {SuiObjectRef[]} coins\n   * @return {CallArg}\n   * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }\n   */\n  mapCoinsToCallArg(coins: SuiObjectRef[]): CallArg {\n    return {\n      ObjVec: coins.map((coin) => {\n        return { ImmOrOwned: coin };\n      }),\n    };\n  }\n\n  /**\n   * Map CallArg object to Coins\n   *\n   * @param {ObjVecArg} callArg\n   * @return {SuiObjectRef[]}\n   */\n  mapCallArgToCoins(callArg: ObjVecArg): SuiObjectRef[] {\n    return Array.from(callArg.ObjVec).map((it: ObjectArg) => {\n      return (it as ImmOrOwnedArg).ImmOrOwned;\n    });\n  }\n\n  /**\n   * Map SuiObjectRef object to CallArg\n   *\n   * @param {SuiObjectRef[]} coins\n   * @return {CallArg}\n   * example: { ObjVec: [{ ImmOrOwned: coin_to_stake }] }\n   */\n  mapSuiObjectRefToCallArg(suiObjectRef: SuiObjectRef): CallArg {\n    return {\n      Object: { ImmOrOwned: suiObjectRef },\n    };\n  }\n\n  /**\n   * Map CallArg object to SuiObjectRef\n   *\n   * @param {ObjVecArg} callArg\n   * @return {SuiObjectRef}\n   */\n  mapCallArgToSuiObjectRef(callArg: CallArg): SuiObjectRef {\n    return ((callArg as { Object: ObjectArg }).Object as ImmOrOwnedArg).ImmOrOwned;\n  }\n\n  /**\n   * Map staking amount to CallArg\n   *\n   * @param {number} amount\n   * @return {CallArg}\n   * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };\n   */\n  mapAmountToCallArg(amount: number): CallArg {\n    try {\n      return {\n        Pure: bcs.ser('vector<u64>', [String(amount)]).toBytes(),\n      };\n    } catch (e) {\n      throw new BuildTransactionError('Failed to serialize amount to call argument');\n    }\n  }\n\n  /**\n   * Map CallArg to staking amount\n   *\n   * @param {CallArg} callArg\n   * @return {number}\n   * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };\n   */\n  mapCallArgToAmount(callArg: CallArg): number {\n    try {\n      if ('Pure' in callArg && callArg.Pure.length) {\n        return Number(bcs.de('vector<u64>', Buffer.from(callArg.Pure).toString('base64'), 'base64'));\n      } else {\n        throw new InvalidParameterValueError('Not a valid amount CallArg');\n      }\n    } catch (e) {\n      throw new BuildTransactionError('Failed to deserialize amount from call argument');\n    }\n  }\n\n  /**\n   * Map staking validator address to CallArg\n   *\n   * @param {SuiAddress} suiAddress\n   * @return {CallArg}\n   * example: { Pure: bcs.ser('address', VALIDATOR_ADDRESS).toBytes() };\n   */\n  mapAddressToCallArg(address: SuiAddress): CallArg {\n    try {\n      return {\n        Pure: bcs.ser('address', address).toBytes(),\n      };\n    } catch (e) {\n      throw new BuildTransactionError('Failed to serialize address to call argument');\n    }\n  }\n\n  /**\n   * Map CallArg to staking amount\n   *\n   * @param {CallArg} callArg\n   * @return {string}\n   * example: { Pure: bcs.ser('vector<u64>', [AMOUNT]).toBytes() };\n   */\n  mapCallArgToAddress(callArg: CallArg): string {\n    try {\n      if ('Pure' in callArg && callArg.Pure.length) {\n        return String(bcs.de('address', Buffer.from(callArg.Pure).toString('base64'), 'base64'));\n      } else {\n        throw new InvalidParameterValueError('Not a valid address CallArg');\n      }\n    } catch (e) {\n      throw new BuildTransactionError('Failed to deserialize address from call argument');\n    }\n  }\n\n  /**\n   * Get transaction type by function name\n   *\n   * @param {MethodNames} fctName\n   * @return {TransactionType}\n   */\n  getTransactionType(fctName: string): TransactionType {\n    switch (fctName) {\n      case MethodNames.RequestAddDelegationMulCoin:\n        return TransactionType.AddDelegator;\n      case MethodNames.RequestWithdrawDelegation:\n        return TransactionType.StakingWithdraw;\n      case MethodNames.RequestSwitchDelegation:\n        return TransactionType.StakingSwitch;\n      default:\n        throw new NotSupported(`Staking Transaction type with function ${fctName} not supported`);\n    }\n  }\n\n  /**\n   * Get SUI transaction type by function name\n   *\n   * @param {MethodNames} fctName\n   * @return {SuiTransactionType}\n   */\n  getSuiTransactionType(fctName: string): SuiTransactionType {\n    switch (fctName) {\n      case MethodNames.RequestAddDelegationMulCoin:\n        return SuiTransactionType.AddDelegation;\n      case MethodNames.RequestWithdrawDelegation:\n        return SuiTransactionType.WithdrawDelegation;\n      case MethodNames.RequestSwitchDelegation:\n        return SuiTransactionType.SwitchDelegation;\n      default:\n        throw new NotSupported(`Sui staking transaction type with function ${fctName} not supported`);\n    }\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/dist/src/sui.d.ts

@@ -47,6 +47,8 @@ export declare class Sui extends BaseCoin {
     explainTransaction(params: ExplainTransactionOptions): Promise<SuiTransactionExplanation>;
     private getBuilder;
     private getAddressFromPublicKey;
+    /** @inheritDoc */
+    getSignablePayload(serializedTx: string): Promise<Buffer>;
 }
 export {};
 //# sourceMappingURL=sui.d.ts.map

package/dist/src/sui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sui.d.ts","sourceRoot":"","sources":["../../src/sui.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,QAAQ,EAER,SAAS,EAGT,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,uBAAuB,IAAI,2BAA2B,EACtD,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,gBAAgB,CAAC;AAOpE,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,0BAA2B,SAAQ,2BAA2B;IAC7E,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,aAAK,gBAAgB,GAAG,iBAAiB,CAAC;AAE1C,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAE7D,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAG3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAC9B;AAED,oBAAY,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F;;OAEG;IACI,aAAa,IAAI,MAAM;IAIvB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAI5B,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,eAAe,IAAI,YAAY;IAI/B,2BAA2B,IAAI,OAAO;IAIhC,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IA8BrE,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BlE,gBAAgB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuCzF,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAIvC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,eAAe,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI3E;;;OAGG;IACG,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAc/F,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,uBAAuB;CAShC"}
+{"version":3,"file":"sui.d.ts","sourceRoot":"","sources":["../../src/sui.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,QAAQ,EAER,SAAS,EAGT,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,uBAAuB,IAAI,2BAA2B,EACtD,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,gBAAgB,CAAC;AAQpE,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,0BAA2B,SAAQ,2BAA2B;IAC7E,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,aAAK,gBAAgB,GAAG,iBAAiB,CAAC;AAE1C,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAE7D,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAG3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAC9B;AAED,oBAAY,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F;;OAEG;IACI,aAAa,IAAI,MAAM;IAIvB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAI5B,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,eAAe,IAAI,YAAY;IAI/B,2BAA2B,IAAI,OAAO;IAIhC,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IA8BrE,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BlE,gBAAgB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuCzF,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAIvC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,eAAe,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI3E;;;OAGG;IACG,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAc/F,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,uBAAuB;IAU/B,kBAAkB;IACZ,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAKhE"}