@typus/typus-sdk 1.0.39 → 1.0.40

package/lib/utils/sponsorTransaction.d.ts

@@ -0,0 +1,19 @@
+export interface SponsoredTransaction {
+    txBytes: string;
+    txDigest: string;
+    signature: string;
+    expireAtTime: number;
+    expireAfterEpoch: number;
+}
+export type SponsoredTransactionStatus = "IN_FLIGHT" | "COMPLETE" | "INVALID";
+export declare const sponsorRpcClient: (sponserRpcUrl: any) => {
+    gas_sponsorTransactionBlock: (txBytes: string, sender: string, gasBudget: number) => Promise<SponsoredTransaction>;
+    gas_getSponsoredTransactionBlockStatus: (txDigest: string) => Promise<SponsoredTransactionStatus>;
+};
+export interface SponsorRpc {
+    gas_sponsorTransactionBlock(txBytes: string, sender: string, gasBudget: number): SponsoredTransaction;
+    gas_getSponsoredTransactionBlockStatus(txDigest: string): SponsoredTransactionStatus;
+}
+export declare const sponsorTransactionBlock: (gaslessTxb: any, sponsor: any, provider: any, gasBudget: any, signerAddress: any) => Promise<[SponsoredTransaction, Uint8Array]>;
+export declare const executeSponsorTransactionBlock: (provider: any, sponsoredResponse: any, senderSig: any) => Promise<void>;
+export declare const sponsorTransactionE2E: (gaslessTxb: any, sponsor: any, provider: any, signer: any, gasBudget: any) => Promise<void>;

package/lib/utils/sponsorTransaction.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sponsorTransactionE2E = exports.executeSponsorTransactionBlock = exports.sponsorTransactionBlock = exports.sponsorRpcClient = void 0;
+var typed_rpc_1 = require("typed-rpc");
+var sponsorRpcClient = function (sponserRpcUrl) { return (0, typed_rpc_1.rpcClient)(sponserRpcUrl); };
+exports.sponsorRpcClient = sponsorRpcClient;
+var sponsorTransactionBlock = function (gaslessTxb, sponsor, provider, gasBudget, signerAddress) { return __awaiter(void 0, void 0, void 0, function () {
+    var gaslessPayloadBytes, gaslessPayloadBase64, sponsoredResponse, sponsoredStatus, transactionBlock;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, gaslessTxb.build({ provider: provider, onlyTransactionKind: true })];
+            case 1:
+                gaslessPayloadBytes = _a.sent();
+                gaslessPayloadBase64 = btoa(gaslessPayloadBytes.reduce(function (data, byte) { return data + String.fromCharCode(byte); }, ""));
+                return [4 /*yield*/, sponsor.gas_sponsorTransactionBlock(gaslessPayloadBase64, signerAddress, gasBudget)];
+            case 2:
+                sponsoredResponse = _a.sent();
+                return [4 /*yield*/, sponsor.gas_getSponsoredTransactionBlockStatus(sponsoredResponse.txDigest)];
+            case 3:
+                sponsoredStatus = _a.sent();
+                console.log("Sponsorship Status:", sponsoredStatus);
+                transactionBlock = Uint8Array.from(atob(sponsoredResponse.txBytes), function (c) { return c.charCodeAt(0); });
+                return [2 /*return*/, [sponsoredResponse, transactionBlock]];
+        }
+    });
+}); };
+exports.sponsorTransactionBlock = sponsorTransactionBlock;
+// // Sign the full transaction payload with the sender's key.
+// const senderSig = await signer.signTransactionBlock({ transactionBlock });
+var executeSponsorTransactionBlock = function (provider, sponsoredResponse, senderSig) { return __awaiter(void 0, void 0, void 0, function () {
+    var executeResponse;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, provider.executeTransactionBlock({
+                    transactionBlock: sponsoredResponse.txBytes,
+                    signature: [senderSig.signature, sponsoredResponse.signature],
+                    options: { showEffects: true },
+                    requestType: "WaitForLocalExecution",
+                })];
+            case 1:
+                executeResponse = _b.sent();
+                console.log("Execution Status:", (_a = executeResponse.effects) === null || _a === void 0 ? void 0 : _a.status.status);
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.executeSponsorTransactionBlock = executeSponsorTransactionBlock;
+var sponsorTransactionE2E = function (gaslessTxb, sponsor, provider, signer, gasBudget) { return __awaiter(void 0, void 0, void 0, function () {
+    var gaslessPayloadBytes, gaslessPayloadBase64, sponsoredResponse, _a, _b, _c, sponsoredStatus, transactionBlock, senderSig, executeResponse;
+    var _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4 /*yield*/, gaslessTxb.build({ provider: provider, onlyTransactionKind: true })];
+            case 1:
+                gaslessPayloadBytes = _e.sent();
+                gaslessPayloadBase64 = btoa(gaslessPayloadBytes.reduce(function (data, byte) { return data + String.fromCharCode(byte); }, ""));
+                _b = (_a = sponsor).gas_sponsorTransactionBlock;
+                _c = [gaslessPayloadBase64];
+                return [4 /*yield*/, signer.getAddress()];
+            case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([_e.sent(), gasBudget]))];
+            case 3:
+                sponsoredResponse = _e.sent();
+                return [4 /*yield*/, sponsor.gas_getSponsoredTransactionBlockStatus(sponsoredResponse.txDigest)];
+            case 4:
+                sponsoredStatus = _e.sent();
+                console.log("Sponsorship Status:", sponsoredStatus);
+                transactionBlock = Uint8Array.from(atob(sponsoredResponse.txBytes), function (c) { return c.charCodeAt(0); });
+                return [4 /*yield*/, signer.signTransactionBlock({ transactionBlock: transactionBlock })];
+            case 5:
+                senderSig = _e.sent();
+                return [4 /*yield*/, provider.executeTransactionBlock({
+                        transactionBlock: sponsoredResponse.txBytes,
+                        signature: [senderSig.signature, sponsoredResponse.signature],
+                        options: { showEffects: true },
+                        requestType: "WaitForLocalExecution",
+                    })];
+            case 6:
+                executeResponse = _e.sent();
+                console.log("Execution Status:", (_d = executeResponse.effects) === null || _d === void 0 ? void 0 : _d.status.status);
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.sponsorTransactionE2E = sponsorTransactionE2E;

package/lib/utils/typus-dov-single/user-entry.js

@@ -254,7 +254,7 @@ function getNewBidTx(gasBudget, packageId, typeArguments, registry, index, price
         var tx, _a, coin;
         return __generator(this, function (_b) {
             tx = new sui_js_1.TransactionBlock();
-            if (typeArguments[1] == sui_js_1.SUI_TYPE_ARG) {
+            if (typeArguments[1] == "0x2::sui::SUI" || typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
                 _a = __read(tx.splitCoins(tx.gas, [tx.pure(premium_required)]), 1), coin = _a[0];
                 tx.moveCall({
                     target: "".concat(packageId, "::typus_dov_single::new_bid"),

package/package.json

@@ -2,9 +2,9 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.0.39",
+    "version": "1.0.40",
     "dependencies": {
-        "@mysten/sui.js": "0.32.0",
+        "@mysten/sui.js": "0.34.0",
         "@types/node": "^17.0.0",
         "bignumber.js": "^9.1.1",
         "bs58": "^4.0.1",