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

package/lib/portal/releaseMetadata.js

@@ -0,0 +1,748 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _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;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import getVideoDimensions from "get-video-dimensions";
+import { imageSize } from "image-size";
+import { ensureHttpsUrl, inferFileNameFromUrl, inferMimeType } from "./files.js";
+import { uploadBytes } from "./http.js";
+import { firstString, readDeep } from "./records.js";
+var NFT_SCHEMA_VERSION = "0.4.0";
+var DEFAULT_R2_PUBLIC_HOSTS = [
+    "r2.solanamobiledappstore.com",
+    "r2-staging.solanamobiledappstore.com"
+];
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter(function(item) {
+        return typeof item === "string";
+    }) : [];
+}
+function normalizeMimeType(value) {
+    var _value_split_;
+    return value === null || value === void 0 ? void 0 : (_value_split_ = value.split(";")[0]) === null || _value_split_ === void 0 ? void 0 : _value_split_.trim().toLowerCase();
+}
+function toPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function isR2PublicUrl(url) {
+    try {
+        var hostname = new URL(url).hostname.toLowerCase();
+        return DEFAULT_R2_PUBLIC_HOSTS.includes(hostname);
+    } catch (e) {
+        return false;
+    }
+}
+function inferExtensionFromMimeType(mimeType) {
+    switch(mimeType){
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+            return "jpg";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        case "video/mp4":
+            return "mp4";
+        case "video/webm":
+            return "webm";
+        case "video/quicktime":
+            return "mov";
+        case "application/json":
+            return "json";
+        default:
+            {
+                var _mimeType_split__split_, _mimeType_split_;
+                var subtype = (_mimeType_split_ = mimeType.split("/")[1]) === null || _mimeType_split_ === void 0 ? void 0 : (_mimeType_split__split_ = _mimeType_split_.split("+")[0]) === null || _mimeType_split__split_ === void 0 ? void 0 : _mimeType_split__split_.trim().toLowerCase();
+                return (subtype === null || subtype === void 0 ? void 0 : subtype.replace(/[^a-z0-9]/g, "")) || undefined;
+            }
+    }
+}
+function inferUploadFileExtension(fileName, mimeType) {
+    var _fileName_split_pop;
+    var byName = (_fileName_split_pop = fileName.split(".").pop()) === null || _fileName_split_pop === void 0 ? void 0 : _fileName_split_pop.trim().toLowerCase();
+    if (byName && /^[a-z0-9]+$/.test(byName)) {
+        return byName;
+    }
+    return inferExtensionFromMimeType(mimeType) || "bin";
+}
+function normalizeOptionalUrl(value) {
+    if (!value) {
+        return undefined;
+    }
+    var trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return ensureHttpsUrl(trimmed);
+}
+function normalizeReleaseName(value) {
+    var trimmed = value.trim();
+    return trimmed.length <= 32 ? trimmed : trimmed.slice(0, 32);
+}
+function isVideoMimeType(mimeType) {
+    return mimeType.startsWith("video/");
+}
+function getVideoMediaDimensions(fileBytes, fileName, mimeType) {
+    return _async_to_generator(function() {
+        var tempFilePath, dimensions, width, height;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    tempFilePath = path.join(os.tmpdir(), "dapp-store-media-".concat(process.pid, "-").concat(Date.now(), "-").concat(Math.random().toString(36).slice(2), ".").concat(inferUploadFileExtension(fileName, mimeType)));
+                    return [
+                        4,
+                        fs.writeFile(tempFilePath, fileBytes)
+                    ];
+                case 1:
+                    _state.sent();
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        ,
+                        4,
+                        6
+                    ]);
+                    return [
+                        4,
+                        getVideoDimensions(tempFilePath)
+                    ];
+                case 3:
+                    dimensions = _state.sent();
+                    width = toPositiveNumber(dimensions.width);
+                    height = toPositiveNumber(dimensions.height);
+                    if (!width || !height) {
+                        throw new Error("Unable to determine video dimensions for ".concat(fileName));
+                    }
+                    return [
+                        2,
+                        {
+                            width: width,
+                            height: height
+                        }
+                    ];
+                case 4:
+                    return [
+                        4,
+                        fs.rm(tempFilePath, {
+                            force: true
+                        })
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        7
+                    ];
+                case 6:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function getMediaDimensions(fileBytes, fileName, mimeType) {
+    return _async_to_generator(function() {
+        var dimensions, width, height;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!isVideoMimeType(mimeType)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        getVideoMediaDimensions(fileBytes, fileName, mimeType)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 2:
+                    dimensions = imageSize(fileBytes);
+                    width = toPositiveNumber(dimensions.width);
+                    height = toPositiveNumber(dimensions.height);
+                    if (!width || !height) {
+                        throw new Error("Unable to determine image dimensions for ".concat(fileName));
+                    }
+                    return [
+                        2,
+                        {
+                            width: width,
+                            height: height
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function getPreferredFeatureGraphicUrl(bundle) {
+    return firstString(bundle, [
+        "dapp.editorsChoiceGraphicUrl",
+        "dapp.featureGraphicUrl"
+    ]) || "";
+}
+function resolveMediaItem(client, input) {
+    return _async_to_generator(function() {
+        var resolvedUri, isAlreadyPublicR2, remoteFile, error, message, fileBytes, remoteFileName, resolvedMimeType, fileHash, dimensions, uploadTarget;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    resolvedUri = ensureHttpsUrl(input.uri);
+                    isAlreadyPublicR2 = isR2PublicUrl(resolvedUri);
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        client.fetchRemoteFile({
+                            url: resolvedUri,
+                            fileName: input.fallbackFileName,
+                            expectedMimeType: input.expectedMimeType
+                        })
+                    ];
+                case 2:
+                    remoteFile = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    throw new Error("Failed to fetch ".concat(input.purpose, " media from ").concat(resolvedUri, ": ").concat(message));
+                case 4:
+                    fileBytes = Buffer.from(remoteFile.data, "base64");
+                    if (fileBytes.byteLength === 0) {
+                        throw new Error("Remote media file is empty: ".concat(resolvedUri));
+                    }
+                    remoteFileName = remoteFile.fileName || input.fallbackFileName;
+                    resolvedMimeType = normalizeMimeType(remoteFile.mimeType) || input.defaultMimeType || inferMimeType(remoteFileName);
+                    fileHash = createHash("sha256").update(fileBytes).digest("hex");
+                    return [
+                        4,
+                        getMediaDimensions(fileBytes, remoteFileName, resolvedMimeType)
+                    ];
+                case 5:
+                    dimensions = _state.sent();
+                    if (isAlreadyPublicR2) {
+                        return [
+                            2,
+                            {
+                                mime: resolvedMimeType,
+                                purpose: input.purpose,
+                                uri: resolvedUri,
+                                width: dimensions.width,
+                                height: dimensions.height,
+                                sha256: fileHash
+                            }
+                        ];
+                    }
+                    return [
+                        4,
+                        client.createUploadTarget({
+                            fileHash: fileHash,
+                            fileExtension: inferUploadFileExtension(remoteFileName, resolvedMimeType),
+                            contentType: resolvedMimeType
+                        })
+                    ];
+                case 6:
+                    uploadTarget = _state.sent();
+                    if (!uploadTarget.uploadUrl || !uploadTarget.publicUrl) {
+                        throw new Error("The portal did not return a valid upload target for ".concat(input.purpose, "."));
+                    }
+                    return [
+                        4,
+                        uploadBytes(uploadTarget.uploadUrl, fileBytes, resolvedMimeType)
+                    ];
+                case 7:
+                    _state.sent();
+                    return [
+                        2,
+                        {
+                            mime: resolvedMimeType,
+                            purpose: input.purpose,
+                            uri: uploadTarget.publicUrl,
+                            width: dimensions.width,
+                            height: dimensions.height,
+                            sha256: fileHash
+                        }
+                    ];
+            }
+        });
+    })();
+}
+export function buildReleaseMetadataDocument(client, bundle, sourceKind) {
+    return _async_to_generator(function() {
+        var _bundle_metadata, _bundle_metadata1, _bundle_metadata2, _bundle_metadata3, _bundle_metadata4, _bundle_metadata5, _bundle_metadata6, _bundle_metadata7, _bundle_metadata8, _bundle_metadata9, releaseName, shortDescription, longDescription, newInVersion, publisherAddress, publisherName, publisherWebsite, publisherContact, publisherSupportEmail, iconUri, installUri, installMimeType, _bundle_installFile_size, _ref, installSize, installSha256, androidPackage, versionName, _bundle_release_versionCode, versionCode, _bundle_release_minSdkVersion, minSdkVersion, targetSdkRaw, targetSdkVersion, certificateFingerprint, _bundle_release_permissions, permissions, locales, _bundle_dapp_dappPreviewUrls, previewUris, bannerUri, featureGraphicUri, media, iconMedia, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, index, previewUri, _, err, _1, _2, licenseUrl, copyrightUrl, privacyPolicyUrl;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    releaseName = normalizeReleaseName(((_bundle_metadata = bundle.metadata) === null || _bundle_metadata === void 0 ? void 0 : _bundle_metadata.localizedName) || bundle.release.localizedName || bundle.release.releaseName || bundle.dapp.dappName || "Release update");
+                    shortDescription = ((_bundle_metadata1 = bundle.metadata) === null || _bundle_metadata1 === void 0 ? void 0 : _bundle_metadata1.shortDescription) || bundle.release.shortDescription || bundle.dapp.subtitle || "Release NFT";
+                    longDescription = ((_bundle_metadata2 = bundle.metadata) === null || _bundle_metadata2 === void 0 ? void 0 : _bundle_metadata2.longDescription) || bundle.release.longDescription || bundle.dapp.description || shortDescription;
+                    newInVersion = ((_bundle_metadata3 = bundle.metadata) === null || _bundle_metadata3 === void 0 ? void 0 : _bundle_metadata3.newInVersion) || bundle.release.newInVersion || "";
+                    publisherAddress = bundle.signerAuthority.dappWalletAddress || bundle.signerAuthority.collectionAuthority || bundle.dapp.walletAddress || "";
+                    publisherName = bundle.publisher.name || "";
+                    publisherWebsite = normalizeOptionalUrl(((_bundle_metadata4 = bundle.metadata) === null || _bundle_metadata4 === void 0 ? void 0 : _bundle_metadata4.publisherWebsite) || bundle.publisher.website || bundle.dapp.appWebsite || bundle.dapp.website || undefined);
+                    publisherContact = bundle.publisher.email || bundle.dapp.contactEmail || bundle.dapp.supportEmail || "";
+                    publisherSupportEmail = bundle.publisher.supportEmail || ((_bundle_metadata5 = bundle.metadata) === null || _bundle_metadata5 === void 0 ? void 0 : _bundle_metadata5.supportEmail) || bundle.dapp.supportEmail || bundle.dapp.contactEmail || bundle.publisher.email || publisherContact;
+                    iconUri = bundle.dapp.dappIconUrl || "";
+                    if (!iconUri) {
+                        throw new Error("Publication bundle did not include a public app icon URL.");
+                    }
+                    installUri = bundle.installFile.uri || bundle.release.releaseFileUrl || "";
+                    installMimeType = bundle.installFile.mimeType || inferMimeType(inferFileNameFromUrl(installUri));
+                    installSize = (_ref = (_bundle_installFile_size = bundle.installFile.size) !== null && _bundle_installFile_size !== void 0 ? _bundle_installFile_size : bundle.release.releaseFileSize) !== null && _ref !== void 0 ? _ref : 0;
+                    installSha256 = bundle.installFile.sha256 || bundle.release.releaseFileHash || "";
+                    androidPackage = bundle.release.androidPackage || bundle.dapp.androidPackage;
+                    versionName = bundle.release.versionName || "";
+                    versionCode = (_bundle_release_versionCode = bundle.release.versionCode) !== null && _bundle_release_versionCode !== void 0 ? _bundle_release_versionCode : 0;
+                    minSdkVersion = (_bundle_release_minSdkVersion = bundle.release.minSdkVersion) !== null && _bundle_release_minSdkVersion !== void 0 ? _bundle_release_minSdkVersion : 1;
+                    targetSdkRaw = readDeep(bundle, "release.targetSdkVersion");
+                    targetSdkVersion = typeof targetSdkRaw === "number" ? targetSdkRaw : Number(targetSdkRaw || 0) || null;
+                    certificateFingerprint = bundle.release.certificateFingerprint || "";
+                    permissions = (_bundle_release_permissions = bundle.release.permissions) !== null && _bundle_release_permissions !== void 0 ? _bundle_release_permissions : [];
+                    locales = bundle.release.locales && bundle.release.locales.length > 0 ? bundle.release.locales : ((_bundle_metadata6 = bundle.metadata) === null || _bundle_metadata6 === void 0 ? void 0 : _bundle_metadata6.locales) && bundle.metadata.locales.length > 0 ? bundle.metadata.locales : bundle.dapp.languages && bundle.dapp.languages.length > 0 ? bundle.dapp.languages : [
+                        "en-US"
+                    ];
+                    previewUris = (_bundle_dapp_dappPreviewUrls = bundle.dapp.dappPreviewUrls) !== null && _bundle_dapp_dappPreviewUrls !== void 0 ? _bundle_dapp_dappPreviewUrls : [];
+                    bannerUri = bundle.dapp.bannerUrl || "";
+                    featureGraphicUri = getPreferredFeatureGraphicUrl(bundle);
+                    media = [];
+                    return [
+                        4,
+                        resolveMediaItem(client, {
+                            defaultMimeType: "image/png",
+                            fallbackFileName: "release-icon.png",
+                            purpose: "icon",
+                            uri: iconUri
+                        })
+                    ];
+                case 1:
+                    iconMedia = _state.sent();
+                    media.push(iconMedia);
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        7,
+                        8,
+                        9
+                    ]);
+                    _iterator = previewUris.entries()[Symbol.iterator]();
+                    _state.label = 3;
+                case 3:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        6
+                    ];
+                    _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], previewUri = _step_value[1];
+                    _ = media.push;
+                    return [
+                        4,
+                        resolveMediaItem(client, {
+                            fallbackFileName: "release-screenshot-".concat(index + 1),
+                            purpose: "screenshot",
+                            uri: previewUri
+                        })
+                    ];
+                case 4:
+                    _.apply(media, [
+                        _state.sent()
+                    ]);
+                    _state.label = 5;
+                case 5:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        3
+                    ];
+                case 6:
+                    return [
+                        3,
+                        9
+                    ];
+                case 7:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        9
+                    ];
+                case 8:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 9:
+                    if (!bannerUri) return [
+                        3,
+                        11
+                    ];
+                    _1 = media.push;
+                    return [
+                        4,
+                        resolveMediaItem(client, {
+                            defaultMimeType: inferMimeType(inferFileNameFromUrl(bannerUri)),
+                            fallbackFileName: "release-banner.png",
+                            purpose: "banner",
+                            uri: bannerUri
+                        })
+                    ];
+                case 10:
+                    _1.apply(media, [
+                        _state.sent()
+                    ]);
+                    _state.label = 11;
+                case 11:
+                    if (!featureGraphicUri) return [
+                        3,
+                        13
+                    ];
+                    _2 = media.push;
+                    return [
+                        4,
+                        resolveMediaItem(client, {
+                            defaultMimeType: inferMimeType(inferFileNameFromUrl(featureGraphicUri)),
+                            fallbackFileName: "release-feature-graphic.png",
+                            purpose: "featureGraphic",
+                            uri: featureGraphicUri
+                        })
+                    ];
+                case 12:
+                    _2.apply(media, [
+                        _state.sent()
+                    ]);
+                    _state.label = 13;
+                case 13:
+                    licenseUrl = normalizeOptionalUrl(((_bundle_metadata7 = bundle.metadata) === null || _bundle_metadata7 === void 0 ? void 0 : _bundle_metadata7.legal.licenseUrl) || bundle.dapp.licenseUrl || undefined);
+                    copyrightUrl = ((_bundle_metadata8 = bundle.metadata) === null || _bundle_metadata8 === void 0 ? void 0 : _bundle_metadata8.legal.copyrightUrl) || bundle.dapp.copyrightUrl || undefined;
+                    privacyPolicyUrl = normalizeOptionalUrl(((_bundle_metadata9 = bundle.metadata) === null || _bundle_metadata9 === void 0 ? void 0 : _bundle_metadata9.legal.privacyPolicyUrl) || bundle.dapp.privacyPolicyUrl || undefined);
+                    return [
+                        2,
+                        _object_spread_props(_object_spread({
+                            schema_version: NFT_SCHEMA_VERSION,
+                            name: releaseName,
+                            description: shortDescription,
+                            image: iconMedia.uri
+                        }, publisherWebsite ? {
+                            external_url: publisherWebsite
+                        } : {}), {
+                            properties: {
+                                category: "dApp",
+                                creators: [
+                                    {
+                                        address: publisherAddress,
+                                        share: 100
+                                    }
+                                ]
+                            },
+                            extensions: {
+                                solana_dapp_store: {
+                                    publisher_details: _object_spread_props(_object_spread({
+                                        name: publisherName
+                                    }, publisherWebsite ? {
+                                        website: publisherWebsite
+                                    } : {}), {
+                                        contact: publisherContact,
+                                        support_email: publisherSupportEmail
+                                    }),
+                                    release_details: _object_spread_props(_object_spread({
+                                        updated_on: new Date().toISOString()
+                                    }, licenseUrl ? {
+                                        license_url: licenseUrl
+                                    } : {}, copyrightUrl ? {
+                                        copyright_url: copyrightUrl
+                                    } : {}, privacyPolicyUrl ? {
+                                        privacy_policy_url: privacyPolicyUrl
+                                    } : {}), {
+                                        localized_resources: {
+                                            long_description: "1",
+                                            new_in_version: "2",
+                                            name: "4",
+                                            short_description: "5"
+                                        }
+                                    }),
+                                    media: media,
+                                    files: [
+                                        {
+                                            mime: installMimeType,
+                                            purpose: "install",
+                                            size: installSize,
+                                            sha256: installSha256,
+                                            uri: installUri
+                                        }
+                                    ],
+                                    android_details: {
+                                        android_package: androidPackage,
+                                        version: versionName,
+                                        version_code: versionCode,
+                                        min_sdk: minSdkVersion,
+                                        target_sdk: targetSdkVersion,
+                                        cert_fingerprint: certificateFingerprint,
+                                        permissions: asStringArray(permissions),
+                                        locales: asStringArray(locales)
+                                    }
+                                },
+                                i18n: {
+                                    "en-US": {
+                                        "1": longDescription,
+                                        "2": newInVersion,
+                                        "4": releaseName,
+                                        "5": shortDescription.slice(0, 50)
+                                    }
+                                }
+                            },
+                            __origin: sourceKind
+                        })
+                    ];
+            }
+        });
+    })();
+}