@solana-mobile/dapp-store-cli 0.15.0 → 0.16.1

package/lib/cli/__tests__/signer.test.js

@@ -0,0 +1,436 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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
+        };
+    }
+}
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, expect, jest, test } from "@jest/globals";
+import { createCreateInstruction, createVerifyInstruction, VerificationArgs } from "@metaplex-foundation/mpl-token-metadata";
+import { ComputeBudgetProgram, Keypair, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { signSerializedTransaction } from "../../../../core/src/portal/signer.js";
+import { createPublicationSignerFromKeypair, parseKeypair } from "../signer.js";
+var tempDirs = [];
+var TOKEN_METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var TOKEN_METADATA_SEED = Buffer.from("metadata");
+var TOKEN_METADATA_EDITION_SEED = Buffer.from("edition");
+afterEach(function() {
+    while(tempDirs.length > 0){
+        fs.rmSync(tempDirs.pop(), {
+            recursive: true,
+            force: true
+        });
+    }
+});
+function createReleaseMintTransaction(options) {
+    var _options_signer;
+    var signer = (_options_signer = options === null || options === void 0 ? void 0 : options.signer) !== null && _options_signer !== void 0 ? _options_signer : Keypair.generate();
+    var _options_mint;
+    var mint = (_options_mint = options === null || options === void 0 ? void 0 : options.mint) !== null && _options_mint !== void 0 ? _options_mint : Keypair.generate();
+    var _options_appMintAddress;
+    var appMintAddress = (_options_appMintAddress = options === null || options === void 0 ? void 0 : options.appMintAddress) !== null && _options_appMintAddress !== void 0 ? _options_appMintAddress : Keypair.generate().publicKey;
+    var transaction = new Transaction();
+    transaction.feePayer = signer.publicKey;
+    transaction.recentBlockhash = Keypair.generate().publicKey.toBase58();
+    transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+        units: 500000
+    }));
+    transaction.add(function() {
+        var instruction = createCreateInstruction({
+            metadata: Keypair.generate().publicKey,
+            masterEdition: Keypair.generate().publicKey,
+            mint: mint.publicKey,
+            authority: signer.publicKey,
+            payer: signer.publicKey,
+            updateAuthority: signer.publicKey,
+            sysvarInstructions: Keypair.generate().publicKey,
+            splTokenProgram: Keypair.generate().publicKey
+        }, {
+            createArgs: {
+                __kind: "V1",
+                assetData: {
+                    name: "Example release",
+                    symbol: "",
+                    uri: "https://example.com/release.json",
+                    sellerFeeBasisPoints: 0,
+                    creators: null,
+                    primarySaleHappened: false,
+                    isMutable: false,
+                    tokenStandard: 0,
+                    collection: {
+                        verified: false,
+                        key: appMintAddress
+                    },
+                    uses: null,
+                    collectionDetails: null,
+                    ruleSet: null
+                },
+                decimals: null,
+                printSupply: null
+            }
+        });
+        instruction.keys[2].isSigner = true;
+        instruction.keys[5].isSigner = true;
+        return instruction;
+    }());
+    if (options === null || options === void 0 ? void 0 : options.addUnexpectedProgram) {
+        transaction.add(SystemProgram.transfer({
+            fromPubkey: signer.publicKey,
+            toPubkey: Keypair.generate().publicKey,
+            lamports: 1
+        }));
+    }
+    transaction.partialSign(mint);
+    if (options === null || options === void 0 ? void 0 : options.tamperAfterMintSignature) {
+        transaction.instructions[1] = new TransactionInstruction({
+            programId: TOKEN_METADATA_PROGRAM_ID,
+            keys: transaction.instructions[1].keys,
+            data: Buffer.from([
+                9,
+                9,
+                9
+            ])
+        });
+    }
+    return {
+        signer: signer,
+        mint: mint,
+        appMintAddress: appMintAddress,
+        blockhash: transaction.recentBlockhash,
+        serialized: transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false
+        }).toString("base64")
+    };
+}
+function getMetadataPda(mintAddress) {
+    return PublicKey.findProgramAddressSync([
+        TOKEN_METADATA_SEED,
+        TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        mintAddress.toBuffer()
+    ], TOKEN_METADATA_PROGRAM_ID)[0];
+}
+function getMasterEditionPda(mintAddress) {
+    return PublicKey.findProgramAddressSync([
+        TOKEN_METADATA_SEED,
+        TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        mintAddress.toBuffer(),
+        TOKEN_METADATA_EDITION_SEED
+    ], TOKEN_METADATA_PROGRAM_ID)[0];
+}
+function createVerifyCollectionTransaction(options) {
+    var _options_signer;
+    var signer = (_options_signer = options === null || options === void 0 ? void 0 : options.signer) !== null && _options_signer !== void 0 ? _options_signer : Keypair.generate();
+    var _options_nftMintAddress;
+    var nftMintAddress = (_options_nftMintAddress = options === null || options === void 0 ? void 0 : options.nftMintAddress) !== null && _options_nftMintAddress !== void 0 ? _options_nftMintAddress : Keypair.generate().publicKey;
+    var _options_collectionMintAddress;
+    var collectionMintAddress = (_options_collectionMintAddress = options === null || options === void 0 ? void 0 : options.collectionMintAddress) !== null && _options_collectionMintAddress !== void 0 ? _options_collectionMintAddress : Keypair.generate().publicKey;
+    var transaction = new Transaction();
+    transaction.feePayer = signer.publicKey;
+    transaction.recentBlockhash = Keypair.generate().publicKey.toBase58();
+    transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: 1000
+    }));
+    transaction.add(createVerifyInstruction({
+        authority: signer.publicKey,
+        metadata: getMetadataPda(nftMintAddress),
+        collectionMint: collectionMintAddress,
+        collectionMetadata: getMetadataPda(collectionMintAddress),
+        collectionMasterEdition: getMasterEditionPda(collectionMintAddress),
+        systemProgram: SystemProgram.programId,
+        sysvarInstructions: SYSVAR_INSTRUCTIONS_PUBKEY
+    }, {
+        verificationArgs: VerificationArgs.CollectionV1
+    }));
+    return {
+        signer: signer,
+        nftMintAddress: nftMintAddress,
+        collectionMintAddress: collectionMintAddress,
+        blockhash: transaction.recentBlockhash,
+        serialized: transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false
+        }).toString("base64")
+    };
+}
+test("parseKeypair loads a Solana keypair from a JSON array file", function() {
+    var keypair = Keypair.generate();
+    var tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dapp-store-signer-"));
+    var keypairPath = path.join(tempDir, "signer.json");
+    tempDirs.push(tempDir);
+    fs.writeFileSync(keypairPath, JSON.stringify(Array.from(keypair.secretKey)));
+    var parsedKeypair = parseKeypair(keypairPath);
+    expect(parsedKeypair === null || parsedKeypair === void 0 ? void 0 : parsedKeypair.publicKey.toBase58()).toBe(keypair.publicKey.toBase58());
+});
+test("parseKeypair returns undefined and logs an error when the file is missing", function() {
+    var logSpy = jest.spyOn(console, "log").mockImplementation(function() {});
+    try {
+        expect(parseKeypair("/tmp/does-not-exist.json")).toBeUndefined();
+        expect(logSpy).toHaveBeenCalled();
+    } finally{
+        logSpy.mockRestore();
+    }
+});
+test("signSerializedTransaction signs a validated release mint transaction", function() {
+    return _async_to_generator(function() {
+        var _createReleaseMintTransaction, signer, mint, appMintAddress, blockhash, serialized, accountAddresses, signedTransaction;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _createReleaseMintTransaction = createReleaseMintTransaction(), signer = _createReleaseMintTransaction.signer, mint = _createReleaseMintTransaction.mint, appMintAddress = _createReleaseMintTransaction.appMintAddress, blockhash = _createReleaseMintTransaction.blockhash, serialized = _createReleaseMintTransaction.serialized;
+                    accountAddresses = Transaction.from(Buffer.from(serialized, "base64")).compileMessage().accountKeys.map(function(key) {
+                        return key.toBase58();
+                    });
+                    expect(accountAddresses).not.toContain(appMintAddress.toBase58());
+                    return [
+                        4,
+                        signSerializedTransaction(createPublicationSignerFromKeypair(signer), serialized, {
+                            kind: "release-mint",
+                            expectedBlockhash: blockhash,
+                            expectedFeePayerAddress: signer.publicKey.toBase58(),
+                            expectedSignerAddress: signer.publicKey.toBase58(),
+                            expectedMintAddress: mint.publicKey.toBase58(),
+                            expectedAppMintAddress: appMintAddress.toBase58()
+                        })
+                    ];
+                case 1:
+                    signedTransaction = _state.sent();
+                    expect(Transaction.from(Buffer.from(signedTransaction, "base64")).verifySignatures()).toBe(true);
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+test("signSerializedTransaction rejects release mint transactions with unexpected programs", function() {
+    return _async_to_generator(function() {
+        var _createReleaseMintTransaction, signer, mint, appMintAddress, blockhash, serialized;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _createReleaseMintTransaction = createReleaseMintTransaction({
+                        addUnexpectedProgram: true
+                    }), signer = _createReleaseMintTransaction.signer, mint = _createReleaseMintTransaction.mint, appMintAddress = _createReleaseMintTransaction.appMintAddress, blockhash = _createReleaseMintTransaction.blockhash, serialized = _createReleaseMintTransaction.serialized;
+                    return [
+                        4,
+                        expect(signSerializedTransaction(createPublicationSignerFromKeypair(signer), serialized, {
+                            kind: "release-mint",
+                            expectedBlockhash: blockhash,
+                            expectedFeePayerAddress: signer.publicKey.toBase58(),
+                            expectedSignerAddress: signer.publicKey.toBase58(),
+                            expectedMintAddress: mint.publicKey.toBase58(),
+                            expectedAppMintAddress: appMintAddress.toBase58()
+                        })).rejects.toThrow("unexpected program ids")
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+test("signSerializedTransaction rejects release mint transactions with invalid pre-existing signatures", function() {
+    return _async_to_generator(function() {
+        var _createReleaseMintTransaction, signer, mint, appMintAddress, blockhash, serialized;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _createReleaseMintTransaction = createReleaseMintTransaction({
+                        tamperAfterMintSignature: true
+                    }), signer = _createReleaseMintTransaction.signer, mint = _createReleaseMintTransaction.mint, appMintAddress = _createReleaseMintTransaction.appMintAddress, blockhash = _createReleaseMintTransaction.blockhash, serialized = _createReleaseMintTransaction.serialized;
+                    return [
+                        4,
+                        expect(signSerializedTransaction(createPublicationSignerFromKeypair(signer), serialized, {
+                            kind: "release-mint",
+                            expectedBlockhash: blockhash,
+                            expectedFeePayerAddress: signer.publicKey.toBase58(),
+                            expectedSignerAddress: signer.publicKey.toBase58(),
+                            expectedMintAddress: mint.publicKey.toBase58(),
+                            expectedAppMintAddress: appMintAddress.toBase58()
+                        })).rejects.toThrow("invalid existing signatures")
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+test("signSerializedTransaction rejects release mint transactions with a mismatched collection encoded in metadata", function() {
+    return _async_to_generator(function() {
+        var _createReleaseMintTransaction, signer, mint, blockhash, serialized, unexpectedAppMintAddress;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _createReleaseMintTransaction = createReleaseMintTransaction(), signer = _createReleaseMintTransaction.signer, mint = _createReleaseMintTransaction.mint, blockhash = _createReleaseMintTransaction.blockhash, serialized = _createReleaseMintTransaction.serialized;
+                    unexpectedAppMintAddress = Keypair.generate().publicKey;
+                    return [
+                        4,
+                        expect(signSerializedTransaction(createPublicationSignerFromKeypair(signer), serialized, {
+                            kind: "release-mint",
+                            expectedBlockhash: blockhash,
+                            expectedFeePayerAddress: signer.publicKey.toBase58(),
+                            expectedSignerAddress: signer.publicKey.toBase58(),
+                            expectedMintAddress: mint.publicKey.toBase58(),
+                            expectedAppMintAddress: unexpectedAppMintAddress.toBase58()
+                        })).rejects.toThrow("collection mismatch")
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+test("signSerializedTransaction signs a validated collection verification transaction", function() {
+    return _async_to_generator(function() {
+        var _createVerifyCollectionTransaction, signer, nftMintAddress, collectionMintAddress, blockhash, serialized, signedTransaction;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _createVerifyCollectionTransaction = createVerifyCollectionTransaction(), signer = _createVerifyCollectionTransaction.signer, nftMintAddress = _createVerifyCollectionTransaction.nftMintAddress, collectionMintAddress = _createVerifyCollectionTransaction.collectionMintAddress, blockhash = _createVerifyCollectionTransaction.blockhash, serialized = _createVerifyCollectionTransaction.serialized;
+                    return [
+                        4,
+                        signSerializedTransaction(createPublicationSignerFromKeypair(signer), serialized, {
+                            kind: "verify-collection",
+                            expectedBlockhash: blockhash,
+                            expectedFeePayerAddress: signer.publicKey.toBase58(),
+                            expectedSignerAddress: signer.publicKey.toBase58(),
+                            expectedNftMintAddress: nftMintAddress.toBase58(),
+                            expectedCollectionMintAddress: collectionMintAddress.toBase58(),
+                            expectedCollectionAuthority: signer.publicKey.toBase58()
+                        })
+                    ];
+                case 1:
+                    signedTransaction = _state.sent();
+                    expect(Transaction.from(Buffer.from(signedTransaction, "base64")).verifySignatures()).toBe(true);
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});

package/lib/cli/constants.js

@@ -0,0 +1,23 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export var Constants = function Constants() {
+    "use strict";
+    _class_call_check(this, Constants);
+};
+_define_property(Constants, "CLI_VERSION", '0.16.1');

package/lib/cli/messages.js

@@ -0,0 +1,21 @@
+import boxen from 'boxen';
+export var showMessage = function() {
+    var titleMessage = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '', contentMessage = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : '', type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 'standard';
+    var color = 'cyan';
+    if (type === 'error') {
+        color = 'redBright';
+    } else if (type === 'warning') {
+        color = 'yellow';
+    }
+    var message = boxen(contentMessage, {
+        title: titleMessage,
+        padding: 1,
+        margin: 1,
+        borderStyle: 'single',
+        borderColor: color,
+        textAlignment: 'left',
+        titleAlignment: 'center'
+    });
+    console.log(message);
+    return message;
+};

package/lib/cli/parseErrors.js

@@ -0,0 +1,41 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { formatUpdatedCliUsageError } from "../publication/cliValidation.js";
+var COMMANDER_EXIT_CODES_TO_IGNORE = new Set([
+    "commander.help",
+    "commander.helpDisplayed",
+    "commander.version"
+]);
+var UPDATED_DOCS_PARSE_ERROR_CODES = new Set([
+    "commander.excessArguments",
+    "commander.unknownCommand",
+    "commander.unknownOption"
+]);
+export function isCommanderLifecycleExit(error) {
+    var _error_code;
+    return isCommanderError(error) && COMMANDER_EXIT_CODES_TO_IGNORE.has((_error_code = error.code) !== null && _error_code !== void 0 ? _error_code : "");
+}
+export function getCommanderUserFacingError(error) {
+    if (!isCommanderError(error)) {
+        return null;
+    }
+    var _error_message;
+    var message = (_error_message = error.message) !== null && _error_message !== void 0 ? _error_message : "Invalid CLI arguments.";
+    var _error_exitCode, _error_code;
+    return {
+        exitCode: (_error_exitCode = error.exitCode) !== null && _error_exitCode !== void 0 ? _error_exitCode : 1,
+        message: UPDATED_DOCS_PARSE_ERROR_CODES.has((_error_code = error.code) !== null && _error_code !== void 0 ? _error_code : "") ? formatUpdatedCliUsageError(message) : normalizeCommanderErrorMessage(message)
+    };
+}
+function isCommanderError(error) {
+    return (typeof error === "undefined" ? "undefined" : _type_of(error)) === "object" && error !== null && "code" in error && "message" in error;
+}
+function normalizeCommanderErrorMessage(message) {
+    var normalized = message.replace(/^error:\s*/i, "").trim();
+    if (normalized.length === 0) {
+        return "Invalid CLI arguments.";
+    }
+    return normalized.endsWith(".") ? normalized : "".concat(normalized, ".");
+}

package/lib/{commands/publish/PublishCliSupport.js → cli/selfUpdate.js}

@@ -27,6 +27,10 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -118,59 +122,89 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { Connection } from "@solana/web3.js";
-import { publishSupport } from "@solana-mobile/dapp-store-publishing-tools";
-import { checkMintedStatus } from "../../CliUtils.js";
-import nacl from "tweetnacl";
-import { loadPublishDetailsWithChecks } from "../../config/PublishDetails.js";
-export var publishSupportCommand = function(param) {
-    var appMintAddress = param.appMintAddress, releaseMintAddress = param.releaseMintAddress, signer = param.signer, url = param.url, _param_dryRun = param.dryRun, dryRun = _param_dryRun === void 0 ? false : _param_dryRun, _param_requestorIsAuthorized = param.requestorIsAuthorized, requestorIsAuthorized = _param_requestorIsAuthorized === void 0 ? false : _param_requestorIsAuthorized, requestDetails = param.requestDetails;
+import { readFile } from "node:fs/promises";
+import semver from "semver";
+import updateNotifier from "update-notifier";
+import { Constants } from "./constants.js";
+var FALLBACK_CLI_PACKAGE = {
+    name: "@solana-mobile/dapp-store-cli",
+    version: Constants.CLI_VERSION
+};
+function loadCliPackageMetadata() {
     return _async_to_generator(function() {
-        var connection, _ref, publisherDetails, appDetails, releaseDetails, sign, appAddr, releaseAddr;
+        var packageContents, parsed, e;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    if (!requestorIsAuthorized) {
-                        console.error("ERROR: Cannot submit a request for which the requestor does not attest they are authorized to do so");
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        readFile(new URL("../../package.json", import.meta.url), {
+                            encoding: "utf8"
+                        })
+                    ];
+                case 1:
+                    packageContents = _state.sent();
+                    parsed = JSON.parse(packageContents);
+                    if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === "object" && parsed !== null && typeof parsed.name === "string" && typeof parsed.version === "string") {
                         return [
-                            2
+                            2,
+                            {
+                                name: String(parsed.name),
+                                version: String(parsed.version)
+                            }
                         ];
                     }
-                    connection = new Connection(url, {
-                        commitment: "confirmed"
-                    });
                     return [
-                        4,
-                        loadPublishDetailsWithChecks()
+                        3,
+                        3
                     ];
-                case 1:
-                    _ref = _state.sent(), publisherDetails = _ref.publisher, appDetails = _ref.app, releaseDetails = _ref.release;
-                    sign = function(buf) {
-                        return nacl.sign(buf, signer.secretKey);
-                    };
-                    appAddr = appMintAddress !== null && appMintAddress !== void 0 ? appMintAddress : appDetails.address;
-                    releaseAddr = releaseMintAddress !== null && releaseMintAddress !== void 0 ? releaseMintAddress : releaseDetails.address;
+                case 2:
+                    e = _state.sent();
+                    return [
+                        2,
+                        FALLBACK_CLI_PACKAGE
+                    ];
+                case 3:
+                    return [
+                        2,
+                        FALLBACK_CLI_PACKAGE
+                    ];
+            }
+        });
+    })();
+}
+export var checkForSelfUpdate = function() {
+    return _async_to_generator(function() {
+        var notifier, _tmp, updateInfo, latestVersion, currentVersion;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _tmp = {};
                     return [
                         4,
-                        checkMintedStatus(connection, appAddr, releaseAddr)
+                        loadCliPackageMetadata()
                     ];
-                case 2:
-                    _state.sent();
+                case 1:
+                    notifier = updateNotifier.apply(void 0, [
+                        (_tmp.pkg = _state.sent(), _tmp)
+                    ]);
                     return [
                         4,
-                        publishSupport({
-                            connection: connection,
-                            sign: sign
-                        }, {
-                            appMintAddress: appMintAddress !== null && appMintAddress !== void 0 ? appMintAddress : appDetails.address,
-                            releaseMintAddress: releaseMintAddress !== null && releaseMintAddress !== void 0 ? releaseMintAddress : releaseDetails.address,
-                            publisherDetails: publisherDetails,
-                            requestorIsAuthorized: requestorIsAuthorized,
-                            requestDetails: requestDetails
-                        }, dryRun)
+                        notifier.fetchInfo()
                     ];
-                case 3:
-                    _state.sent();
+                case 2:
+                    updateInfo = _state.sent();
+                    latestVersion = new semver.SemVer(updateInfo.latest);
+                    currentVersion = new semver.SemVer(updateInfo.current);
+                    if (latestVersion.major > currentVersion.major || latestVersion.minor > currentVersion.minor) {
+                        throw new Error("Please update to the latest version of the dApp Store CLI before proceeding.\nCurrent version is ".concat(currentVersion.raw, "\nLatest version is ").concat(latestVersion.raw));
+                    }
                     return [
                         2
                     ];