@iota/wallet-standard 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iota/wallet-standard
 
+## 0.2.0
+
+### Minor Changes
+
+-   6eabd18: Changes for compatibility with the node, simplification of exposed APIs and general
+    improvements.
+
+### Patch Changes
+
+-   Updated dependencies [6eabd18]
+    -   @iota/iota-sdk@0.3.0
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -3,4 +3,4 @@
 A suite of standard utilities for implementing wallets and libraries based on the
 [Wallet Standard](https://github.com/wallet-standard/wallet-standard/).
 
-**Documentation:** https://docs.iota.io/standards/wallet-standard
+**Documentation:** https://wiki.iota.org/standards/wallet-standard

package/dist/cjs/detect.d.ts

@@ -1,7 +1,3 @@
 import type { Wallet, WalletWithFeatures } from '@wallet-standard/core';
-import type { MinimallyRequiredFeatures, WalletWithIotaFeatures } from './features/index.js';
-/** @deprecated Use isWalletWithRequiredFeatureSet instead since it provides more accurate typing! */
-export declare function isWalletWithIotaFeatures(wallet: Wallet, 
-/** Extra features that are required to be present, in addition to the expected feature set. */
-features?: string[]): wallet is WalletWithIotaFeatures;
+import type { MinimallyRequiredFeatures } from './features/index.js';
 export declare function isWalletWithRequiredFeatureSet<AdditionalFeatures extends Wallet['features']>(wallet: Wallet, additionalFeatures?: (keyof AdditionalFeatures)[]): wallet is WalletWithFeatures<MinimallyRequiredFeatures & AdditionalFeatures>;

package/dist/cjs/detect.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var detect_exports = {};
 __export(detect_exports, {
-  isWalletWithIotaFeatures: () => isWalletWithIotaFeatures,
   isWalletWithRequiredFeatureSet: () => isWalletWithRequiredFeatureSet
 });
 module.exports = __toCommonJS(detect_exports);
@@ -26,9 +25,6 @@ const REQUIRED_FEATURES = [
   "standard:connect",
   "standard:events"
 ];
-function isWalletWithIotaFeatures(wallet, features = []) {
-  return [...REQUIRED_FEATURES, ...features].every((feature) => feature in wallet.features);
-}
 function isWalletWithRequiredFeatureSet(wallet, additionalFeatures = []) {
   return [...REQUIRED_FEATURES, ...additionalFeatures].every(
     (feature) => feature in wallet.features

package/dist/cjs/detect.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/detect.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Wallet, WalletWithFeatures } from '@wallet-standard/core';\n\nimport type { MinimallyRequiredFeatures, WalletWithIotaFeatures } from './features/index.js';\n\n// These features are absolutely required for wallets to function in the Iota ecosystem.\n// Eventually, as wallets have more consistent support of features, we may want to extend this list.\nconst REQUIRED_FEATURES: (keyof MinimallyRequiredFeatures)[] = [\n    'standard:connect',\n    'standard:events',\n];\n\n/** @deprecated Use isWalletWithRequiredFeatureSet instead since it provides more accurate typing! */\nexport function isWalletWithIotaFeatures(\n    wallet: Wallet,\n    /** Extra features that are required to be present, in addition to the expected feature set. */\n    features: string[] = [],\n): wallet is WalletWithIotaFeatures {\n    return [...REQUIRED_FEATURES, ...features].every((feature) => feature in wallet.features);\n}\n\nexport function isWalletWithRequiredFeatureSet<AdditionalFeatures extends Wallet['features']>(\n    wallet: Wallet,\n    additionalFeatures: (keyof AdditionalFeatures)[] = [],\n): wallet is WalletWithFeatures<MinimallyRequiredFeatures & AdditionalFeatures> {\n    return [...REQUIRED_FEATURES, ...additionalFeatures].every(\n        (feature) => feature in wallet.features,\n    );\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,MAAM,oBAAyD;AAAA,EAC3D;AAAA,EACA;AACJ;AAGO,SAAS,yBACZ,QAEA,WAAqB,CAAC,GACU;AAChC,SAAO,CAAC,GAAG,mBAAmB,GAAG,QAAQ,EAAE,MAAM,CAAC,YAAY,WAAW,OAAO,QAAQ;AAC5F;AAEO,SAAS,+BACZ,QACA,qBAAmD,CAAC,GACwB;AAC5E,SAAO,CAAC,GAAG,mBAAmB,GAAG,kBAAkB,EAAE;AAAA,IACjD,CAAC,YAAY,WAAW,OAAO;AAAA,EACnC;AACJ;",
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Wallet, WalletWithFeatures } from '@wallet-standard/core';\n\nimport type { MinimallyRequiredFeatures } from './features/index.js';\n\n// These features are absolutely required for wallets to function in the IOTA ecosystem.\n// Eventually, as wallets have more consistent support of features, we may want to extend this list.\nconst REQUIRED_FEATURES: (keyof MinimallyRequiredFeatures)[] = [\n    'standard:connect',\n    'standard:events',\n];\n\nexport function isWalletWithRequiredFeatureSet<AdditionalFeatures extends Wallet['features']>(\n    wallet: Wallet,\n    additionalFeatures: (keyof AdditionalFeatures)[] = [],\n): wallet is WalletWithFeatures<MinimallyRequiredFeatures & AdditionalFeatures> {\n    return [...REQUIRED_FEATURES, ...additionalFeatures].every(\n        (feature) => feature in wallet.features,\n    );\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,MAAM,oBAAyD;AAAA,EAC3D;AAAA,EACA;AACJ;AAEO,SAAS,+BACZ,QACA,qBAAmD,CAAC,GACwB;AAC5E,SAAO,CAAC,GAAG,mBAAmB,GAAG,kBAAkB,EAAE;AAAA,IACjD,CAAC,YAAY,WAAW,OAAO;AAAA,EACnC;AACJ;",
   "names": []
 }

package/dist/cjs/features/index.d.ts

@@ -1,19 +1,20 @@
 import type { IdentifierRecord, StandardConnectFeature, StandardDisconnectFeature, StandardEventsFeature, WalletWithFeatures } from '@wallet-standard/core';
-import type { IotaSignAndExecuteTransactionBlockFeature } from './iotaSignAndExecuteTransactionBlock.js';
-import type { IotaSignMessageFeature } from './iotaSignMessage.js';
+import type { IotaReportTransactionEffectsFeature } from './iotaReportTransactionEffects.js';
+import type { IotaSignAndExecuteTransactionFeature } from './iotaSignAndExecuteTransaction.js';
 import type { IotaSignPersonalMessageFeature } from './iotaSignPersonalMessage.js';
-import type { IotaSignTransactionBlockFeature } from './iotaSignTransactionBlock.js';
+import type { IotaSignTransactionFeature } from './iotaSignTransaction.js';
 /**
- * Wallet Standard features that are unique to Iota, and that all Iota wallets are expected to implement.
+ * Wallet Standard features that are unique to IOTA, and that all IOTA wallets are expected to implement.
  */
-export type IotaFeatures = IotaSignTransactionBlockFeature & IotaSignAndExecuteTransactionBlockFeature & IotaSignPersonalMessageFeature & Partial<IotaSignMessageFeature>;
-export type WalletWithIotaFeatures = WalletWithFeatures<StandardConnectFeature & StandardEventsFeature & IotaFeatures & Partial<StandardDisconnectFeature>>;
+export type IotaFeatures = IotaSignPersonalMessageFeature & IotaSignAndExecuteTransactionFeature & IotaSignTransactionFeature & Partial<IotaReportTransactionEffectsFeature>;
+export type IotaWalletFeatures = StandardConnectFeature & StandardEventsFeature & IotaFeatures & Partial<StandardDisconnectFeature>;
+export type WalletWithIotaFeatures = WalletWithFeatures<IotaWalletFeatures>;
 /**
- * Represents a wallet with the absolute minimum feature set required to function in the Iota ecosystem.
+ * Represents a wallet with the absolute minimum feature set required to function in the IOTA ecosystem.
  */
 export type WalletWithRequiredFeatures = WalletWithFeatures<MinimallyRequiredFeatures & Partial<IotaFeatures> & Partial<StandardDisconnectFeature> & IdentifierRecord<unknown>>;
 export type MinimallyRequiredFeatures = StandardConnectFeature & StandardEventsFeature;
-export * from './iotaSignMessage.js';
-export * from './iotaSignTransactionBlock.js';
-export * from './iotaSignAndExecuteTransactionBlock.js';
+export * from './iotaSignTransaction.js';
+export * from './iotaSignAndExecuteTransaction.js';
 export * from './iotaSignPersonalMessage.js';
+export * from './iotaReportTransactionEffects.js';

package/dist/cjs/features/index.js

@@ -15,8 +15,8 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var features_exports = {};
 module.exports = __toCommonJS(features_exports);
-__reExport(features_exports, require("./iotaSignMessage.js"), module.exports);
-__reExport(features_exports, require("./iotaSignTransactionBlock.js"), module.exports);
-__reExport(features_exports, require("./iotaSignAndExecuteTransactionBlock.js"), module.exports);
+__reExport(features_exports, require("./iotaSignTransaction.js"), module.exports);
+__reExport(features_exports, require("./iotaSignAndExecuteTransaction.js"), module.exports);
 __reExport(features_exports, require("./iotaSignPersonalMessage.js"), module.exports);
+__reExport(features_exports, require("./iotaReportTransactionEffects.js"), module.exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/features/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/features/index.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type {\n    IdentifierRecord,\n    StandardConnectFeature,\n    StandardDisconnectFeature,\n    StandardEventsFeature,\n    WalletWithFeatures,\n} from '@wallet-standard/core';\n\nimport type { IotaSignAndExecuteTransactionBlockFeature } from './iotaSignAndExecuteTransactionBlock.js';\nimport type { IotaSignMessageFeature } from './iotaSignMessage.js';\nimport type { IotaSignPersonalMessageFeature } from './iotaSignPersonalMessage.js';\nimport type { IotaSignTransactionBlockFeature } from './iotaSignTransactionBlock.js';\n\n/**\n * Wallet Standard features that are unique to Iota, and that all Iota wallets are expected to implement.\n */\nexport type IotaFeatures = IotaSignTransactionBlockFeature &\n    IotaSignAndExecuteTransactionBlockFeature &\n    IotaSignPersonalMessageFeature &\n    // This deprecated feature should be removed once wallets update to the new method:\n    Partial<IotaSignMessageFeature>;\n\nexport type WalletWithIotaFeatures = WalletWithFeatures<\n    StandardConnectFeature &\n        StandardEventsFeature &\n        IotaFeatures &\n        // Disconnect is an optional feature:\n        Partial<StandardDisconnectFeature>\n>;\n\n/**\n * Represents a wallet with the absolute minimum feature set required to function in the Iota ecosystem.\n */\nexport type WalletWithRequiredFeatures = WalletWithFeatures<\n    MinimallyRequiredFeatures &\n        Partial<IotaFeatures> &\n        Partial<StandardDisconnectFeature> &\n        IdentifierRecord<unknown>\n>;\n\nexport type MinimallyRequiredFeatures = StandardConnectFeature & StandardEventsFeature;\n\nexport * from './iotaSignMessage.js';\nexport * from './iotaSignTransactionBlock.js';\nexport * from './iotaSignAndExecuteTransactionBlock.js';\nexport * from './iotaSignPersonalMessage.js';\n"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AA8CA,6BAAc,iCA9Cd;AA+CA,6BAAc,0CA/Cd;AAgDA,6BAAc,oDAhDd;AAiDA,6BAAc,yCAjDd;",
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type {\n    IdentifierRecord,\n    StandardConnectFeature,\n    StandardDisconnectFeature,\n    StandardEventsFeature,\n    WalletWithFeatures,\n} from '@wallet-standard/core';\n\nimport type { IotaReportTransactionEffectsFeature } from './iotaReportTransactionEffects.js';\nimport type { IotaSignAndExecuteTransactionFeature } from './iotaSignAndExecuteTransaction.js';\nimport type { IotaSignPersonalMessageFeature } from './iotaSignPersonalMessage.js';\nimport type { IotaSignTransactionFeature } from './iotaSignTransaction.js';\n\n/**\n * Wallet Standard features that are unique to IOTA, and that all IOTA wallets are expected to implement.\n */\nexport type IotaFeatures = IotaSignPersonalMessageFeature &\n    IotaSignAndExecuteTransactionFeature &\n    IotaSignTransactionFeature &\n    Partial<IotaReportTransactionEffectsFeature>;\n\nexport type IotaWalletFeatures = StandardConnectFeature &\n    StandardEventsFeature &\n    IotaFeatures &\n    // Disconnect is an optional feature:\n    Partial<StandardDisconnectFeature>;\n\nexport type WalletWithIotaFeatures = WalletWithFeatures<IotaWalletFeatures>;\n\n/**\n * Represents a wallet with the absolute minimum feature set required to function in the IOTA ecosystem.\n */\nexport type WalletWithRequiredFeatures = WalletWithFeatures<\n    MinimallyRequiredFeatures &\n        Partial<IotaFeatures> &\n        Partial<StandardDisconnectFeature> &\n        IdentifierRecord<unknown>\n>;\n\nexport type MinimallyRequiredFeatures = StandardConnectFeature & StandardEventsFeature;\n\nexport * from './iotaSignTransaction.js';\nexport * from './iotaSignAndExecuteTransaction.js';\nexport * from './iotaSignPersonalMessage.js';\nexport * from './iotaReportTransactionEffects.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AA6CA,6BAAc,qCA7Cd;AA8CA,6BAAc,+CA9Cd;AA+CA,6BAAc,yCA/Cd;AAgDA,6BAAc,8CAhDd;",
   "names": []
 }

package/dist/cjs/features/iotaReportTransactionEffects.d.ts

@@ -0,0 +1,22 @@
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+/**
+ * A Wallet Standard feature for reporting the effects of a transaction block executed by a dapp
+ * The feature allows wallets to updated their caches using the effects of the transaction
+ * executed outside of the wallet
+ */
+export type IotaReportTransactionEffectsFeature = {
+    /** Namespace for the feature. */
+    'iota:reportTransactionEffects': {
+        /** Version of the feature API. */
+        version: '1.0.0';
+        reportTransactionEffects: IotaReportTransactionEffectsMethod;
+    };
+};
+export type IotaReportTransactionEffectsMethod = (input: IotaReportTransactionEffectsInput) => Promise<void>;
+/** Input for signing transactions. */
+export interface IotaReportTransactionEffectsInput {
+    account: WalletAccount;
+    chain: IdentifierString;
+    /** Transaction effects as base64 encoded bcs. */
+    effects: string;
+}

package/dist/cjs/features/{iotaSignAndExecuteTransactionBlock.js → iotaReportTransactionEffects.js}

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var iotaSignAndExecuteTransactionBlock_exports = {};
-module.exports = __toCommonJS(iotaSignAndExecuteTransactionBlock_exports);
-//# sourceMappingURL=iotaSignAndExecuteTransactionBlock.js.map
+var iotaReportTransactionEffects_exports = {};
+module.exports = __toCommonJS(iotaReportTransactionEffects_exports);
+//# sourceMappingURL=iotaReportTransactionEffects.js.map

package/dist/cjs/features/iotaReportTransactionEffects.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/iotaReportTransactionEffects.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { IdentifierString, WalletAccount } from '@wallet-standard/core';\n\n/**\n * A Wallet Standard feature for reporting the effects of a transaction block executed by a dapp\n * The feature allows wallets to updated their caches using the effects of the transaction\n * executed outside of the wallet\n */\nexport type IotaReportTransactionEffectsFeature = {\n    /** Namespace for the feature. */\n    'iota:reportTransactionEffects': {\n        /** Version of the feature API. */\n        version: '1.0.0';\n        reportTransactionEffects: IotaReportTransactionEffectsMethod;\n    };\n};\n\nexport type IotaReportTransactionEffectsMethod = (\n    input: IotaReportTransactionEffectsInput,\n) => Promise<void>;\n\n/** Input for signing transactions. */\nexport interface IotaReportTransactionEffectsInput {\n    account: WalletAccount;\n    chain: IdentifierString;\n    /** Transaction effects as base64 encoded bcs. */\n    effects: string;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/features/iotaSignAndExecuteTransaction.d.ts

@@ -0,0 +1,29 @@
+import type { IotaTransactionBlockResponseOptions } from '@iota/iota-sdk/client';
+import type { SignedTransaction, IotaSignTransactionInput } from './iotaSignTransaction.js';
+/** The latest API version of the signAndExecuteTransactionBlock API. */
+export type IotaSignAndExecuteTransactionVersion = '2.0.0';
+/**
+ * A Wallet Standard feature for signing a transaction, and submitting it to the
+ * network. The wallet is expected to submit the transaction to the network via RPC,
+ * and return the transaction response.
+ */
+export type IotaSignAndExecuteTransactionFeature = {
+    /** Namespace for the feature. */
+    'iota:signAndExecuteTransaction': {
+        /** Version of the feature API. */
+        version: IotaSignAndExecuteTransactionVersion;
+        signAndExecuteTransaction: IotaSignAndExecuteTransactionMethod;
+    };
+};
+export type IotaSignAndExecuteTransactionMethod = (input: IotaSignAndExecuteTransactionInput) => Promise<IotaSignAndExecuteTransactionOutput>;
+/** Input for signing and sending transactions. */
+export interface IotaSignAndExecuteTransactionInput extends IotaSignTransactionInput {
+    /** specify which fields to return (e.g., transaction, effects, events, etc). By default, only the transaction digest will be returned. */
+    options?: IotaTransactionBlockResponseOptions;
+}
+/** Output of signing and sending transactions. */
+export interface IotaSignAndExecuteTransactionOutput extends SignedTransaction {
+    digest: string;
+    /** Transaction effects as base64 encoded bcs. */
+    effects: string;
+}

package/dist/cjs/features/iotaSignAndExecuteTransaction.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var iotaSignAndExecuteTransaction_exports = {};
+module.exports = __toCommonJS(iotaSignAndExecuteTransaction_exports);
+//# sourceMappingURL=iotaSignAndExecuteTransaction.js.map

package/dist/cjs/features/iotaSignAndExecuteTransaction.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/iotaSignAndExecuteTransaction.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { IotaTransactionBlockResponseOptions } from '@iota/iota-sdk/client';\nimport type { SignedTransaction, IotaSignTransactionInput } from './iotaSignTransaction.js';\n\n/** The latest API version of the signAndExecuteTransactionBlock API. */\nexport type IotaSignAndExecuteTransactionVersion = '2.0.0';\n\n/**\n * A Wallet Standard feature for signing a transaction, and submitting it to the\n * network. The wallet is expected to submit the transaction to the network via RPC,\n * and return the transaction response.\n */\nexport type IotaSignAndExecuteTransactionFeature = {\n    /** Namespace for the feature. */\n    'iota:signAndExecuteTransaction': {\n        /** Version of the feature API. */\n        version: IotaSignAndExecuteTransactionVersion;\n        signAndExecuteTransaction: IotaSignAndExecuteTransactionMethod;\n    };\n};\n\nexport type IotaSignAndExecuteTransactionMethod = (\n    input: IotaSignAndExecuteTransactionInput,\n) => Promise<IotaSignAndExecuteTransactionOutput>;\n\n/** Input for signing and sending transactions. */\nexport interface IotaSignAndExecuteTransactionInput extends IotaSignTransactionInput {\n    /** specify which fields to return (e.g., transaction, effects, events, etc). By default, only the transaction digest will be returned. */\n    options?: IotaTransactionBlockResponseOptions;\n}\n\n/** Output of signing and sending transactions. */\nexport interface IotaSignAndExecuteTransactionOutput extends SignedTransaction {\n    digest: string;\n    /** Transaction effects as base64 encoded bcs. */\n    effects: string;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/features/iotaSignPersonalMessage.d.ts

@@ -23,6 +23,8 @@ export interface IotaSignPersonalMessageInput {
 export interface IotaSignPersonalMessageOutput extends SignedPersonalMessage {
 }
 export interface SignedPersonalMessage {
+    /** Base64 encoded message bytes */
     bytes: string;
+    /** Base64 encoded signature */
     signature: string;
 }

package/dist/cjs/features/iotaSignPersonalMessage.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/features/iotaSignPersonalMessage.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { WalletAccount } from '@wallet-standard/core';\n\n/** The latest API version of the signPersonalMessage API. */\nexport type IotaSignPersonalMessageVersion = '1.0.0';\n\n/**\n * A Wallet Standard feature for signing a personal message, and returning the\n * message bytes that were signed, and message signature.\n */\nexport type IotaSignPersonalMessageFeature = {\n    /** Namespace for the feature. */\n    'iota:signPersonalMessage': {\n        /** Version of the feature API. */\n        version: IotaSignPersonalMessageVersion;\n        signPersonalMessage: IotaSignPersonalMessageMethod;\n    };\n};\n\nexport type IotaSignPersonalMessageMethod = (\n    input: IotaSignPersonalMessageInput,\n) => Promise<IotaSignPersonalMessageOutput>;\n\n/** Input for signing personal messages. */\nexport interface IotaSignPersonalMessageInput {\n    message: Uint8Array;\n    account: WalletAccount;\n}\n\n/** Output of signing personal messages. */\nexport interface IotaSignPersonalMessageOutput extends SignedPersonalMessage {}\n\nexport interface SignedPersonalMessage {\n    bytes: string;\n    signature: string;\n}\n"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { WalletAccount } from '@wallet-standard/core';\n\n/** The latest API version of the signPersonalMessage API. */\nexport type IotaSignPersonalMessageVersion = '1.0.0';\n\n/**\n * A Wallet Standard feature for signing a personal message, and returning the\n * message bytes that were signed, and message signature.\n */\nexport type IotaSignPersonalMessageFeature = {\n    /** Namespace for the feature. */\n    'iota:signPersonalMessage': {\n        /** Version of the feature API. */\n        version: IotaSignPersonalMessageVersion;\n        signPersonalMessage: IotaSignPersonalMessageMethod;\n    };\n};\n\nexport type IotaSignPersonalMessageMethod = (\n    input: IotaSignPersonalMessageInput,\n) => Promise<IotaSignPersonalMessageOutput>;\n\n/** Input for signing personal messages. */\nexport interface IotaSignPersonalMessageInput {\n    message: Uint8Array;\n    account: WalletAccount;\n}\n\n/** Output of signing personal messages. */\nexport interface IotaSignPersonalMessageOutput extends SignedPersonalMessage {}\n\nexport interface SignedPersonalMessage {\n    /** Base64 encoded message bytes */\n    bytes: string;\n    /** Base64 encoded signature */\n    signature: string;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/features/iotaSignTransaction.d.ts

@@ -0,0 +1,34 @@
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+/** The latest API version of the signTransaction API. */
+export type IotaSignTransactionVersion = '2.0.0';
+/**
+ * A Wallet Standard feature for signing a transaction, and returning the
+ * serialized transaction and transaction signature.
+ */
+export type IotaSignTransactionFeature = {
+    /** Namespace for the feature. */
+    'iota:signTransaction': {
+        /** Version of the feature API. */
+        version: IotaSignTransactionVersion;
+        signTransaction: IotaSignTransactionMethod;
+    };
+};
+export type IotaSignTransactionMethod = (input: IotaSignTransactionInput) => Promise<SignedTransaction>;
+/** Input for signing transactions. */
+export interface IotaSignTransactionInput {
+    transaction: {
+        toJSON: () => Promise<string>;
+    };
+    account: WalletAccount;
+    chain: IdentifierString;
+    signal?: AbortSignal;
+}
+/** Output of signing transactions. */
+export interface SignedTransaction {
+    /** Transaction as base64 encoded bcs. */
+    bytes: string;
+    /** Base64 encoded signature */
+    signature: string;
+}
+export interface IotaSignTransactionOutput extends SignedTransaction {
+}

package/dist/cjs/features/{iotaSignTransactionBlock.js → iotaSignTransaction.js}

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var iotaSignTransactionBlock_exports = {};
-module.exports = __toCommonJS(iotaSignTransactionBlock_exports);
-//# sourceMappingURL=iotaSignTransactionBlock.js.map
+var iotaSignTransaction_exports = {};
+module.exports = __toCommonJS(iotaSignTransaction_exports);
+//# sourceMappingURL=iotaSignTransaction.js.map

package/dist/cjs/features/iotaSignTransaction.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/iotaSignTransaction.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { IdentifierString, WalletAccount } from '@wallet-standard/core';\n\n/** The latest API version of the signTransaction API. */\nexport type IotaSignTransactionVersion = '2.0.0';\n\n/**\n * A Wallet Standard feature for signing a transaction, and returning the\n * serialized transaction and transaction signature.\n */\nexport type IotaSignTransactionFeature = {\n    /** Namespace for the feature. */\n    'iota:signTransaction': {\n        /** Version of the feature API. */\n        version: IotaSignTransactionVersion;\n        signTransaction: IotaSignTransactionMethod;\n    };\n};\n\nexport type IotaSignTransactionMethod = (\n    input: IotaSignTransactionInput,\n) => Promise<SignedTransaction>;\n\n/** Input for signing transactions. */\nexport interface IotaSignTransactionInput {\n    transaction: { toJSON: () => Promise<string> };\n    account: WalletAccount;\n    chain: IdentifierString;\n    signal?: AbortSignal;\n}\n\n/** Output of signing transactions. */\n\nexport interface SignedTransaction {\n    /** Transaction as base64 encoded bcs. */\n    bytes: string;\n    /** Base64 encoded signature */\n    signature: string;\n}\n\nexport interface IotaSignTransactionOutput extends SignedTransaction {}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -1,5 +1,6 @@
 export * from '@wallet-standard/core';
-export type { Wallet } from './wallet.js';
+export { type Wallet, signAndExecuteTransaction, signTransaction } from './wallet.js';
 export * from './features/index.js';
 export * from './detect.js';
 export * from './chains.js';
+export * from './types.js';

package/dist/cjs/index.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,9 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
+__export(src_exports, {
+  signAndExecuteTransaction: () => import_wallet.signAndExecuteTransaction,
+  signTransaction: () => import_wallet.signTransaction
+});
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("@wallet-standard/core"), module.exports);
+var import_wallet = require("./wallet.js");
 __reExport(src_exports, require("./features/index.js"), module.exports);
 __reExport(src_exports, require("./detect.js"), module.exports);
 __reExport(src_exports, require("./chains.js"), module.exports);
+__reExport(src_exports, require("./types.js"), module.exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nexport * from '@wallet-standard/core';\n\nexport type { Wallet } from './wallet.js';\nexport * from './features/index.js';\nexport * from './detect.js';\nexport * from './chains.js';\n"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAIA,wBAAc,kCAJd;AAOA,wBAAc,gCAPd;AAQA,wBAAc,wBARd;AASA,wBAAc,wBATd;",
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nexport * from '@wallet-standard/core';\n\nexport { type Wallet, signAndExecuteTransaction, signTransaction } from './wallet.js';\nexport * from './features/index.js';\nexport * from './detect.js';\nexport * from './chains.js';\nexport * from './types.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,wBAAc,kCAJd;AAMA,oBAAwE;AACxE,wBAAc,gCAPd;AAQA,wBAAc,wBARd;AASA,wBAAc,wBATd;AAUA,wBAAc,uBAVd;",
   "names": []
 }

package/dist/cjs/types.d.ts

@@ -0,0 +1,156 @@
+/** Contains data related to the gas payment for a Transaction */
+export interface GasData {
+    /** The budget set for this transaction */
+    budget: string | number | null;
+    /** The gas price used for this transaction */
+    price: string | number | null;
+    /** The owner of the gas coins used to fund the transactions, this is either the sender or the gas sponsor */
+    owner: string | null;
+    /** The list of IOTA coins to fund the transaction */
+    payment: {
+        objectId: string;
+        version: string;
+        digest: string;
+    }[] | null;
+}
+/**
+ * Represent the serialized state of a partially built Transaction
+ * This format is designed to support transactions that have not been fully build
+ * allowing most properties to be omitted or set to null.  It also supports
+ * unresolved object references, unresolved pure values, and Transaction Intents.
+ */
+export interface SerializedTransactionDataV2 {
+    version: 2;
+    /** The sender of the transaction */
+    sender: string | null | undefined;
+    /** The expiration of the transaction */
+    expiration: {
+        Epoch: number;
+    } | {
+        None: true;
+    } | null | undefined;
+    /** The gas data */
+    gasData: GasData;
+    /** The inputs to the transaction */
+    inputs: CallArg[];
+    /** The commands to execute */
+    commands: Command[];
+    /** Extra metadata for implementation specific use-cases */
+    extensions?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Represents an input to a Transaction, either as a fully resolved Object or Pure input
+ * or as an unresolved partial reference which needs to be resolved before the transaction
+ * can be serialized to bcs and executed.
+ */
+export type CallArg = {
+    Object: ObjectArg;
+} | {
+    Pure: PureArg;
+} | {
+    UnresolvedPure: UnresolvedPureArg;
+} | {
+    UnresolvedObject: UnresolvedObjectArg;
+};
+export type ObjectArg = {
+    ImmOrOwnedObject: {
+        objectId: string;
+        version: string | number;
+        digest: string;
+    };
+} | {
+    SharedObject: {
+        objectId: string;
+        initialSharedVersion: string;
+        mutable: boolean;
+    };
+} | {
+    Receiving: {
+        objectId: string;
+        version: string | number;
+        digest: string;
+    };
+};
+export interface PureArg {
+    bytes: string;
+}
+/**
+ * Represents an un-serialized pure value.
+ * The correct bcs schema will need to be determined before this value can be serialized to bcs */
+export interface UnresolvedPureArg {
+    value: unknown;
+}
+/**
+ * Represents an unresolved object reference.  This allows objects to be referenced by only their ID.
+ * version and digest details may also be added to unresolved object references.
+ * To fully resolve a reference, the correct ObjectArg type needs to be determined based on the type of object,
+ * and how it used in the transaction (eg, is it used mutably if it's shared, and is it a receiving object if it's not shared)
+ */
+export interface UnresolvedObjectArg {
+    objectId: string;
+    version?: string | null | undefined;
+    digest?: string | null | undefined;
+    initialSharedVersion?: string | null | undefined;
+}
+export type Argument = {
+    GasCoin: true;
+} | {
+    Input: number;
+} | {
+    Result: number;
+} | {
+    NestedResult: [number, number];
+};
+export type Command = {
+    MoveCall: {
+        package: string;
+        module: string;
+        function: string;
+        typeArguments: string[];
+        arguments: Argument[];
+    };
+} | {
+    TransferObjects: {
+        objects: Argument[];
+        address: Argument;
+    };
+} | {
+    SplitCoins: {
+        coin: Argument;
+        amounts: Argument[];
+    };
+} | {
+    MergeCoins: {
+        destination: Argument;
+        sources: Argument[];
+    };
+} | {
+    Publish: {
+        modules: string[];
+        dependencies: string[];
+    };
+} | {
+    MakeMoveVec: {
+        type: string | null;
+        elements: Argument[];
+    };
+} | {
+    Upgrade: {
+        modules: string[];
+        dependencies: string[];
+        package: string;
+        ticket: Argument;
+    };
+} | {
+    $Intent: {
+        name: string;
+        inputs: {
+            [key: string]: Argument | Argument[];
+        };
+        data: {
+            [key: string]: unknown;
+        };
+    };
+};

package/dist/cjs/{features/iotaSignMessage.js → types.js}

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var iotaSignMessage_exports = {};
-module.exports = __toCommonJS(iotaSignMessage_exports);
-//# sourceMappingURL=iotaSignMessage.js.map
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\n/** Contains data related to the gas payment for a Transaction */\nexport interface GasData {\n    /** The budget set for this transaction */\n    budget: string | number | null;\n    /** The gas price used for this transaction */\n    price: string | number | null;\n    /** The owner of the gas coins used to fund the transactions, this is either the sender or the gas sponsor */\n    owner: string | null;\n    /** The list of IOTA coins to fund the transaction */\n    payment: { objectId: string; version: string; digest: string }[] | null;\n}\n\n/**\n * Represent the serialized state of a partially built Transaction\n * This format is designed to support transactions that have not been fully build\n * allowing most properties to be omitted or set to null.  It also supports\n * unresolved object references, unresolved pure values, and Transaction Intents.\n */\nexport interface SerializedTransactionDataV2 {\n    version: 2;\n    /** The sender of the transaction */\n    sender: string | null | undefined;\n    /** The expiration of the transaction */\n    expiration: { Epoch: number } | { None: true } | null | undefined;\n    /** The gas data */\n    gasData: GasData;\n    /** The inputs to the transaction */\n    inputs: CallArg[];\n    /** The commands to execute */\n    commands: Command[];\n    /** Extra metadata for implementation specific use-cases */\n    extensions?: { [key: string]: unknown };\n}\n\n/**\n * Represents an input to a Transaction, either as a fully resolved Object or Pure input\n * or as an unresolved partial reference which needs to be resolved before the transaction\n * can be serialized to bcs and executed.\n */\nexport type CallArg =\n    | {\n          Object: ObjectArg;\n      }\n    | {\n          Pure: PureArg;\n      }\n    | {\n          UnresolvedPure: UnresolvedPureArg;\n      }\n    | {\n          UnresolvedObject: UnresolvedObjectArg;\n      };\n\nexport type ObjectArg =\n    | {\n          ImmOrOwnedObject: {\n              objectId: string;\n              version: string | number;\n              digest: string;\n          };\n      }\n    | {\n          SharedObject: {\n              objectId: string;\n              initialSharedVersion: string;\n              mutable: boolean;\n          };\n      }\n    | {\n          Receiving: {\n              objectId: string;\n              version: string | number;\n              digest: string;\n          };\n      };\n\nexport interface PureArg {\n    bytes: string;\n}\n\n/**\n * Represents an un-serialized pure value.\n * The correct bcs schema will need to be determined before this value can be serialized to bcs */\nexport interface UnresolvedPureArg {\n    value: unknown;\n}\n\n/**\n * Represents an unresolved object reference.  This allows objects to be referenced by only their ID.\n * version and digest details may also be added to unresolved object references.\n * To fully resolve a reference, the correct ObjectArg type needs to be determined based on the type of object,\n * and how it used in the transaction (eg, is it used mutably if it's shared, and is it a receiving object if it's not shared)\n */\nexport interface UnresolvedObjectArg {\n    objectId: string;\n    version?: string | null | undefined;\n    digest?: string | null | undefined;\n    initialSharedVersion?: string | null | undefined;\n}\n\nexport type Argument =\n    | {\n          GasCoin: true;\n      }\n    | {\n          Input: number;\n      }\n    | {\n          Result: number;\n      }\n    | {\n          NestedResult: [number, number];\n      };\n\nexport type Command =\n    | {\n          MoveCall: {\n              package: string;\n              module: string;\n              function: string;\n              typeArguments: string[];\n              arguments: Argument[];\n          };\n      }\n    | {\n          TransferObjects: {\n              objects: Argument[];\n              address: Argument;\n          };\n      }\n    | {\n          SplitCoins: {\n              coin: Argument;\n              amounts: Argument[];\n          };\n      }\n    | {\n          MergeCoins: {\n              destination: Argument;\n              sources: Argument[];\n          };\n      }\n    | {\n          Publish: {\n              modules: string[];\n              dependencies: string[];\n          };\n      }\n    | {\n          MakeMoveVec: {\n              type: string | null;\n              elements: Argument[];\n          };\n      }\n    | {\n          Upgrade: {\n              modules: string[];\n              dependencies: string[];\n              package: string;\n              ticket: Argument;\n          };\n      }\n    | {\n          $Intent: {\n              name: string;\n              inputs: { [key: string]: Argument | Argument[] };\n              data: { [key: string]: unknown };\n          };\n      };\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/wallet.d.ts

@@ -1,3 +1,5 @@
+import type { WalletWithFeatures } from '@wallet-standard/core';
+import type { IotaSignAndExecuteTransactionInput, IotaSignTransactionInput, IotaWalletFeatures } from './features/index.js';
 declare module '@wallet-standard/core' {
     interface Wallet {
         /**
@@ -7,5 +9,10 @@ declare module '@wallet-standard/core' {
          */
         readonly id?: string;
     }
+    interface StandardConnectOutput {
+        supportedIntents?: string[];
+    }
 }
 export type { Wallet } from '@wallet-standard/core';
+export declare function signAndExecuteTransaction(wallet: WalletWithFeatures<Partial<IotaWalletFeatures>>, input: IotaSignAndExecuteTransactionInput): Promise<import("./features/iotaSignAndExecuteTransaction.js").IotaSignAndExecuteTransactionOutput>;
+export declare function signTransaction(wallet: WalletWithFeatures<Partial<IotaWalletFeatures>>, input: IotaSignTransactionInput): Promise<import("./features/iotaSignTransaction.js").SignedTransaction>;

package/dist/cjs/wallet.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -13,5 +17,25 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var wallet_exports = {};
+__export(wallet_exports, {
+  signAndExecuteTransaction: () => signAndExecuteTransaction,
+  signTransaction: () => signTransaction
+});
 module.exports = __toCommonJS(wallet_exports);
+async function signAndExecuteTransaction(wallet, input) {
+  if (!wallet.features["iota:signAndExecuteTransaction"]) {
+    throw new Error(
+      `Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`
+    );
+  }
+  return wallet.features["iota:signAndExecuteTransaction"].signAndExecuteTransaction(input);
+}
+async function signTransaction(wallet, input) {
+  if (!wallet.features["iota:signTransaction"]) {
+    throw new Error(
+      `Provided wallet (${wallet.name}) does not support the signTransaction feature.`
+    );
+  }
+  return wallet.features["iota:signTransaction"].signTransaction(input);
+}
 //# sourceMappingURL=wallet.js.map

package/dist/cjs/wallet.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/wallet.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\ndeclare module '@wallet-standard/core' {\n    export interface Wallet {\n        /**\n         * Unique identifier of the Wallet.\n         *\n         * If not provided, the wallet name will be used as the identifier.\n         */\n        readonly id?: string;\n    }\n}\n\nexport type { Wallet } from '@wallet-standard/core';\n"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2024 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { WalletWithFeatures } from '@wallet-standard/core';\n\nimport type {\n    IotaSignAndExecuteTransactionInput,\n    IotaSignTransactionInput,\n    IotaWalletFeatures,\n} from './features/index.js';\n\ndeclare module '@wallet-standard/core' {\n    export interface Wallet {\n        /**\n         * Unique identifier of the Wallet.\n         *\n         * If not provided, the wallet name will be used as the identifier.\n         */\n        readonly id?: string;\n    }\n\n    export interface StandardConnectOutput {\n        supportedIntents?: string[];\n    }\n}\n\nexport type { Wallet } from '@wallet-standard/core';\n\nexport async function signAndExecuteTransaction(\n    wallet: WalletWithFeatures<Partial<IotaWalletFeatures>>,\n    input: IotaSignAndExecuteTransactionInput,\n) {\n    if (!wallet.features['iota:signAndExecuteTransaction']) {\n        throw new Error(\n            `Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`,\n        );\n    }\n\n    return wallet.features['iota:signAndExecuteTransaction'].signAndExecuteTransaction(input);\n}\n\nexport async function signTransaction(\n    wallet: WalletWithFeatures<Partial<IotaWalletFeatures>>,\n    input: IotaSignTransactionInput,\n) {\n    if (!wallet.features['iota:signTransaction']) {\n        throw new Error(\n            `Provided wallet (${wallet.name}) does not support the signTransaction feature.`,\n        );\n    }\n\n    return wallet.features['iota:signTransaction'].signTransaction(input);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BA,eAAsB,0BAClB,QACA,OACF;AACE,MAAI,CAAC,OAAO,SAAS,gCAAgC,GAAG;AACpD,UAAM,IAAI;AAAA,MACN,oBAAoB,OAAO,IAAI;AAAA,IACnC;AAAA,EACJ;AAEA,SAAO,OAAO,SAAS,gCAAgC,EAAE,0BAA0B,KAAK;AAC5F;AAEA,eAAsB,gBAClB,QACA,OACF;AACE,MAAI,CAAC,OAAO,SAAS,sBAAsB,GAAG;AAC1C,UAAM,IAAI;AAAA,MACN,oBAAoB,OAAO,IAAI;AAAA,IACnC;AAAA,EACJ;AAEA,SAAO,OAAO,SAAS,sBAAsB,EAAE,gBAAgB,KAAK;AACxE;",
   "names": []
 }