@haneullabs/wallet-standard 0.1.0 → 0.20.1

package/dist/types.d.mts

@@ -0,0 +1,163 @@
+//#region src/types.d.ts
+/** Contains data related to the gas payment for a Transaction */
+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 HANEUL 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.
+ */
+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;
+  };
+  /** The digest of the transaction, may be set when the transaction is fully resolved */
+  digest: string | null | undefined;
+}
+/**
+ * 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.
+ */
+type CallArg = {
+  Object: ObjectArg;
+} | {
+  Pure: PureArg;
+} | {
+  UnresolvedPure: UnresolvedPureArg;
+} | {
+  UnresolvedObject: UnresolvedObjectArg;
+};
+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;
+  };
+};
+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 */
+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)
+ */
+interface UnresolvedObjectArg {
+  objectId: string;
+  version?: string | null | undefined;
+  digest?: string | null | undefined;
+  initialSharedVersion?: string | null | undefined;
+  mutable?: boolean | null | undefined;
+}
+type Argument = {
+  GasCoin: true;
+} | {
+  Input: number;
+} | {
+  Result: number;
+} | {
+  NestedResult: [number, number];
+};
+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;
+    };
+  };
+};
+//#endregion
+export { Argument, CallArg, Command, GasData, ObjectArg, PureArg, SerializedTransactionDataV2, UnresolvedObjectArg, UnresolvedPureArg };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAIiB,UAAA,OAAA,CAAO;EAiBP;EAOP,MAAA,EAAA,MAAA,GAAA,MAAA,GAAA,IAAA;EAED;EAEE,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,IAAA;EAAO;EAYN,KAAA,EAAA,MAAO,GAAA,IAAA;EAER;EAGF,OAAA,EAAA;IAGU,QAAA,EAAA,MAAA;IAGE,OAAA,EAAA,MAAA;IAAmB,MAAA,EAAA,MAAA;EAG5B,CAAA,EAAA,GAAA,IAAA;AAuBZ;AAOA;AAUA;AAQA;AAcA;;;AAaa,UAhHI,2BAAA,CAgHJ;EAKH,OAAA,EAAA,CAAA;EACG;EAKI,MAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA;EACJ;EAYC,UAAA,EAAA;IAQF,KAAA,EAAA,MAAA;EAMiB,CAAA,GAAA;IAAW,IAAA,EAAA,IAAA;EAAQ,CAAA,GAAA,IAAA,GAAA,SAAA;;WA/ItC;;UAED;;YAEE;;;;;;;;;;;;;KAYC,OAAA;UAED;;QAGF;;kBAGU;;oBAGE;;KAGT,SAAA;;;;;;;;;;;;;;;;;;;UAuBK,OAAA;;;;;;UAOA,iBAAA;;;;;;;;;UAUA,mBAAA;;;;;;;KAQL,QAAA;;;;;;;;;KAcA,OAAA;;;;;;eAOG;;;;aAKF;aACA;;;;UAKH;aACG;;;;iBAKI;aACJ;;;;;;;;;;cAYC;;;;;;;YAQF;;;;;;qBAMiB,WAAW"}

package/dist/wallet.d.mts

@@ -0,0 +1,24 @@
+import { HaneulSignTransactionInput, SignedTransaction } from "./features/haneulSignTransaction.mjs";
+import { HaneulSignAndExecuteTransactionInput, HaneulSignAndExecuteTransactionOutput } from "./features/haneulSignAndExecuteTransaction.mjs";
+import { HaneulWalletFeatures } from "./features/index.mjs";
+import { Wallet as Wallet$1, WalletWithFeatures } from "@wallet-standard/core";
+
+//#region src/wallet.d.ts
+declare module '@wallet-standard/core' {
+  interface Wallet {
+    /**
+     * Unique identifier of the Wallet.
+     *
+     * If not provided, the wallet name will be used as the identifier.
+     */
+    readonly id?: string;
+  }
+  interface StandardConnectOutput {
+    supportedIntents?: string[];
+  }
+}
+declare function signAndExecuteTransaction(wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>, input: HaneulSignAndExecuteTransactionInput): Promise<HaneulSignAndExecuteTransactionOutput>;
+declare function signTransaction(wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>, input: HaneulSignTransactionInput): Promise<SignedTransaction>;
+//#endregion
+export { type Wallet$1 as Wallet, signAndExecuteTransaction, signTransaction };
+//# sourceMappingURL=wallet.d.mts.map

package/dist/wallet.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.mts","names":[],"sources":["../src/wallet.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAY6B;;;IAAA,SAAA,EAAA,CAAA,EAAA,MAAA;EAAA;EAmBP,UAAA,qBAAyB,CAAA;IACX,gBAAA,CAAA,EAAA,MAAA,EAAA;EAAR;;AACgB,iBAFtB,yBAAA,CAEsB,MAAA,EADnC,kBACmC,CADhB,OACgB,CADR,oBACQ,CAAA,CAAA,EAAA,KAAA,EAApC,oCAAoC,CAAA,EAAA,OAAA,CAAA,qCAAA,CAAA;AAAA,iBA0CtB,eAAA,CA1CsB,MAAA,EA2CnC,kBA3CmC,CA2ChB,OA3CgB,CA2CR,oBA3CQ,CAAA,CAAA,EAAA,KAAA,EA4CpC,0BA5CoC,CAAA,EA4CV,OA5CU,CA4CV,iBAAA,CA5CU"}

package/dist/wallet.mjs

@@ -0,0 +1,45 @@
+import { bcs } from "@haneullabs/haneul/bcs";
+import { Transaction } from "@haneullabs/haneul/transactions";
+import { fromBase64, toBase64 } from "@haneullabs/haneul/utils";
+
+//#region src/wallet.ts
+async function signAndExecuteTransaction(wallet, input) {
+	if (wallet.features["haneul:signAndExecuteTransaction"]) return wallet.features["haneul:signAndExecuteTransaction"].signAndExecuteTransaction(input);
+	if (!wallet.features["haneul:signAndExecuteTransactionBlock"]) throw new Error(`Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`);
+	const { signAndExecuteTransactionBlock } = wallet.features["haneul:signAndExecuteTransactionBlock"];
+	const transactionBlock = Transaction.from(await input.transaction.toJSON());
+	const { digest, rawEffects, rawTransaction } = await signAndExecuteTransactionBlock({
+		account: input.account,
+		chain: input.chain,
+		transactionBlock,
+		options: {
+			showRawEffects: true,
+			showRawInput: true
+		}
+	});
+	const [{ txSignatures: [signature], intentMessage: { value: bcsTransaction } }] = bcs.SenderSignedData.parse(fromBase64(rawTransaction));
+	return {
+		digest,
+		signature,
+		bytes: bcs.TransactionData.serialize(bcsTransaction).toBase64(),
+		effects: toBase64(new Uint8Array(rawEffects))
+	};
+}
+async function signTransaction(wallet, input) {
+	if (wallet.features["haneul:signTransaction"]) return wallet.features["haneul:signTransaction"].signTransaction(input);
+	if (!wallet.features["haneul:signTransactionBlock"]) throw new Error(`Provided wallet (${wallet.name}) does not support the signTransaction feature.`);
+	const { signTransactionBlock } = wallet.features["haneul:signTransactionBlock"];
+	const { transactionBlockBytes, signature } = await signTransactionBlock({
+		transactionBlock: Transaction.from(await input.transaction.toJSON()),
+		account: input.account,
+		chain: input.chain
+	});
+	return {
+		bytes: transactionBlockBytes,
+		signature
+	};
+}
+
+//#endregion
+export { signAndExecuteTransaction, signTransaction };
+//# sourceMappingURL=wallet.mjs.map

package/dist/wallet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.mjs","names":[],"sources":["../src/wallet.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport { Transaction } from '@haneullabs/haneul/transactions';\nimport { fromBase64, toBase64 } from '@haneullabs/haneul/utils';\nimport type { WalletWithFeatures } from '@wallet-standard/core';\n\nimport type {\n\tHaneulSignAndExecuteTransactionInput,\n\tHaneulSignTransactionInput,\n\tHaneulWalletFeatures,\n} from './features/index.js';\n\ndeclare module '@wallet-standard/core' {\n\texport interface Wallet {\n\t\t/**\n\t\t * Unique identifier of the Wallet.\n\t\t *\n\t\t * If not provided, the wallet name will be used as the identifier.\n\t\t */\n\t\treadonly id?: string;\n\t}\n\n\texport interface StandardConnectOutput {\n\t\tsupportedIntents?: string[];\n\t}\n}\n\nexport type { Wallet } from '@wallet-standard/core';\n\nexport async function signAndExecuteTransaction(\n\twallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,\n\tinput: HaneulSignAndExecuteTransactionInput,\n) {\n\tif (wallet.features['haneul:signAndExecuteTransaction']) {\n\t\treturn wallet.features['haneul:signAndExecuteTransaction'].signAndExecuteTransaction(input);\n\t}\n\n\tif (!wallet.features['haneul:signAndExecuteTransactionBlock']) {\n\t\tthrow new Error(\n\t\t\t`Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`,\n\t\t);\n\t}\n\n\tconst { signAndExecuteTransactionBlock } = wallet.features['haneul:signAndExecuteTransactionBlock'];\n\n\tconst transactionBlock = Transaction.from(await input.transaction.toJSON());\n\tconst { digest, rawEffects, rawTransaction } = await signAndExecuteTransactionBlock({\n\t\taccount: input.account,\n\t\tchain: input.chain,\n\t\ttransactionBlock,\n\t\toptions: {\n\t\t\tshowRawEffects: true,\n\t\t\tshowRawInput: true,\n\t\t},\n\t});\n\n\tconst [\n\t\t{\n\t\t\ttxSignatures: [signature],\n\t\t\tintentMessage: { value: bcsTransaction },\n\t\t},\n\t] = bcs.SenderSignedData.parse(fromBase64(rawTransaction!));\n\n\tconst bytes = bcs.TransactionData.serialize(bcsTransaction).toBase64();\n\n\treturn {\n\t\tdigest,\n\t\tsignature,\n\t\tbytes,\n\t\teffects: toBase64(new Uint8Array(rawEffects!)),\n\t};\n}\n\nexport async function signTransaction(\n\twallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,\n\tinput: HaneulSignTransactionInput,\n) {\n\tif (wallet.features['haneul:signTransaction']) {\n\t\treturn wallet.features['haneul:signTransaction'].signTransaction(input);\n\t}\n\n\tif (!wallet.features['haneul:signTransactionBlock']) {\n\t\tthrow new Error(\n\t\t\t`Provided wallet (${wallet.name}) does not support the signTransaction feature.`,\n\t\t);\n\t}\n\n\tconst { signTransactionBlock } = wallet.features['haneul:signTransactionBlock'];\n\n\tconst transaction = Transaction.from(await input.transaction.toJSON());\n\tconst { transactionBlockBytes, signature } = await signTransactionBlock({\n\t\ttransactionBlock: transaction,\n\t\taccount: input.account,\n\t\tchain: input.chain,\n\t});\n\n\treturn { bytes: transactionBlockBytes, signature };\n}\n"],"mappings":";;;;;AA+BA,eAAsB,0BACrB,QACA,OACC;AACD,KAAI,OAAO,SAAS,oCACnB,QAAO,OAAO,SAAS,oCAAoC,0BAA0B,MAAM;AAG5F,KAAI,CAAC,OAAO,SAAS,yCACpB,OAAM,IAAI,MACT,oBAAoB,OAAO,KAAK,2DAChC;CAGF,MAAM,EAAE,mCAAmC,OAAO,SAAS;CAE3D,MAAM,mBAAmB,YAAY,KAAK,MAAM,MAAM,YAAY,QAAQ,CAAC;CAC3E,MAAM,EAAE,QAAQ,YAAY,mBAAmB,MAAM,+BAA+B;EACnF,SAAS,MAAM;EACf,OAAO,MAAM;EACb;EACA,SAAS;GACR,gBAAgB;GAChB,cAAc;GACd;EACD,CAAC;CAEF,MAAM,CACL,EACC,cAAc,CAAC,YACf,eAAe,EAAE,OAAO,sBAEtB,IAAI,iBAAiB,MAAM,WAAW,eAAgB,CAAC;AAI3D,QAAO;EACN;EACA;EACA,OALa,IAAI,gBAAgB,UAAU,eAAe,CAAC,UAAU;EAMrE,SAAS,SAAS,IAAI,WAAW,WAAY,CAAC;EAC9C;;AAGF,eAAsB,gBACrB,QACA,OACC;AACD,KAAI,OAAO,SAAS,0BACnB,QAAO,OAAO,SAAS,0BAA0B,gBAAgB,MAAM;AAGxE,KAAI,CAAC,OAAO,SAAS,+BACpB,OAAM,IAAI,MACT,oBAAoB,OAAO,KAAK,iDAChC;CAGF,MAAM,EAAE,yBAAyB,OAAO,SAAS;CAGjD,MAAM,EAAE,uBAAuB,cAAc,MAAM,qBAAqB;EACvE,kBAFmB,YAAY,KAAK,MAAM,MAAM,YAAY,QAAQ,CAAC;EAGrE,SAAS,MAAM;EACf,OAAO,MAAM;EACb,CAAC;AAEF,QAAO;EAAE,OAAO;EAAuB;EAAW"}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@haneullabs/wallet-standard",
-  "version": "0.1.0",
+  "version": "0.20.1",
   "description": "A suite of standard utilities for implementing wallets based on the Wallet Standard.",
   "license": "Apache-2.0",
-  "author": "Haneul Labs <build@haneullabs.com>",
-  "type": "commonjs",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/cjs/index.d.ts",
+  "author": "Haneul Labs <build@haneul-labs.com>",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "sideEffects": false,
@@ -22,29 +22,31 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/GeunhwaJeong/haneul-ts-sdks.git"
+    "url": "git+https://github.com/GeunhwaJeong/ts-sdks.git"
   },
   "bugs": {
-    "url": "https://github.com/GeunhwaJeong/haneul-ts-sdks/issues/new"
+    "url": "https://github.com/GeunhwaJeong/ts-sdks/issues/new"
   },
   "dependencies": {
-    "@wallet-standard/core": "1.1.1",
-    "@haneullabs/haneul": "0.1.0"
+    "@wallet-standard/core": "1.1.1"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
-    "typescript-json-schema": "^0.67.0",
-    "@haneullabs/build-scripts": "0.1.0"
+    "typescript-json-schema": "^0.67.1",
+    "@haneullabs/haneul": "2.4.0"
+  },
+  "peerDependencies": {
+    "@haneullabs/haneul": "*"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
-    "build": "build-package",
+    "build": "rm -rf dist && tsc --noEmit && tsdown",
     "prettier:check": "prettier -c --ignore-unknown .",
     "prettier:fix": "prettier -w --ignore-unknown .",
-    "eslint:check": "eslint --max-warnings=0 .",
-    "eslint:fix": "pnpm run eslint:check --fix",
-    "lint": "pnpm run eslint:check && pnpm run prettier:check",
-    "lint:fix": "pnpm run eslint:fix && pnpm run prettier:fix",
+    "oxlint:check": "oxlint  .",
+    "oxlint:fix": "oxlint --fix",
+    "lint": "pnpm run oxlint:check && pnpm run prettier:check",
+    "lint:fix": "pnpm run oxlint:fix && pnpm run prettier:fix",
     "json-schema": "typescript-json-schema src/types.ts SerializedTransactionDataV2 --required --strictNullChecks > serialized-transaction-data-v2.schema.json && prettier -w serialized-transaction-data-v2.schema.json"
   }
 }

package/src/chains.ts

@@ -10,7 +10,7 @@ export const HANEUL_DEVNET_CHAIN = 'haneul:devnet';
 export const HANEUL_TESTNET_CHAIN = 'haneul:testnet';
 
 /** Haneul Localnet */
-export const HANEUL_LOCALNET_CHAIN = 'haneul:localnet';
+export const SUI_LOCALNET_CHAIN = 'haneul:localnet';
 
 /** Haneul Mainnet */
 export const HANEUL_MAINNET_CHAIN = 'haneul:mainnet';
@@ -18,7 +18,7 @@ export const HANEUL_MAINNET_CHAIN = 'haneul:mainnet';
 export const HANEUL_CHAINS = [
 	HANEUL_DEVNET_CHAIN,
 	HANEUL_TESTNET_CHAIN,
-	HANEUL_LOCALNET_CHAIN,
+	SUI_LOCALNET_CHAIN,
 	HANEUL_MAINNET_CHAIN,
 ] as const;
 
@@ -28,6 +28,6 @@ export type HaneulChain = (typeof HANEUL_CHAINS)[number];
  * Utility that returns whether or not a chain identifier is a valid Haneul chain.
  * @param chain a chain identifier in the form of `${string}:{$string}`
  */
-export function isHaneulChain(chain: IdentifierString): chain is HaneulChain {
+export function isSuiChain(chain: IdentifierString): chain is HaneulChain {
 	return HANEUL_CHAINS.includes(chain as HaneulChain);
 }

package/src/features/haneulGetCapabilities.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-export const HaneulGetCapabilities = 'sui:getCapabilities';
+export const HaneulGetCapabilities = 'haneul:getCapabilities';
 
 /** The latest API version of the getCapabilities API. */
 export type HaneulGetCapabilitiesVersion = '1.0.0';

package/src/features/haneulSignAndExecuteTransaction.ts

@@ -4,7 +4,7 @@
 import type { SignedTransaction, HaneulSignTransactionInput } from './haneulSignTransaction.js';
 
 /** Name of the feature. */
-export const HaneulSignAndExecuteTransaction = 'sui:signAndExecuteTransaction';
+export const HaneulSignAndExecuteTransaction = 'haneul:signAndExecuteTransaction';
 
 /** The latest API version of the signAndExecuteTransactionBlock API. */
 export type HaneulSignAndExecuteTransactionVersion = '2.0.0';

package/src/features/haneulSignAndExecuteTransactionBlock.ts

@@ -5,18 +5,18 @@ import type {
 	ExecuteTransactionRequestType,
 	HaneulTransactionBlockResponse,
 	HaneulTransactionBlockResponseOptions,
-} from '@haneullabs/haneul/client';
+} from '@haneullabs/haneul/jsonRpc';
 
 import type { HaneulSignTransactionBlockInput } from './haneulSignTransactionBlock.js';
 
 /** Name of the feature. */
-export const HaneulSignAndExecuteTransactionBlock = 'sui:signAndExecuteTransactionBlock';
+export const HaneulSignAndExecuteTransactionBlock = 'haneul:signAndExecuteTransactionBlock';
 
 /** The latest API version of the signAndExecuteTransactionBlock API. */
 export type HaneulSignAndExecuteTransactionBlockVersion = '1.0.0';
 
 /**
- * @deprecated Use `sui:signAndExecuteTransaction` instead.
+ * @deprecated Use `haneul:signAndExecuteTransaction` instead.
  *
  * 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,
@@ -27,12 +27,12 @@ export type HaneulSignAndExecuteTransactionBlockFeature = {
 	[HaneulSignAndExecuteTransactionBlock]: {
 		/** Version of the feature API. */
 		version: HaneulSignAndExecuteTransactionBlockVersion;
-		/** @deprecated Use `sui:signAndExecuteTransaction` instead. */
+		/** @deprecated Use `haneul:signAndExecuteTransaction` instead. */
 		signAndExecuteTransactionBlock: HaneulSignAndExecuteTransactionBlockMethod;
 	};
 };
 
-/** @deprecated Use `sui:signAndExecuteTransaction` instead. */
+/** @deprecated Use `haneul:signAndExecuteTransaction` instead. */
 export type HaneulSignAndExecuteTransactionBlockMethod = (
 	input: HaneulSignAndExecuteTransactionBlockInput,
 ) => Promise<HaneulSignAndExecuteTransactionBlockOutput>;

package/src/features/haneulSignMessage.ts

@@ -5,13 +5,13 @@ import type { WalletAccount } from '@wallet-standard/core';
 
 /**
  * Name of the feature.
- * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature
  **/
-export const HaneulSignMessage = 'sui:signMessage';
+export const HaneulSignMessage = 'haneul:signMessage';
 
 /**
  * The latest API version of the signMessage API.
- * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature
  */
 export type HaneulSignMessageVersion = '1.0.0';
 
@@ -19,7 +19,7 @@ export type HaneulSignMessageVersion = '1.0.0';
  * A Wallet Standard feature for signing a personal message, and returning the
  * message bytes that were signed, and message signature.
  *
- * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature
  */
 export type HaneulSignMessageFeature = {
 	/** Namespace for the feature. */
@@ -30,12 +30,12 @@ export type HaneulSignMessageFeature = {
 	};
 };
 
-/** @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature */
+/** @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature */
 export type HaneulSignMessageMethod = (input: HaneulSignMessageInput) => Promise<HaneulSignMessageOutput>;
 
 /**
  * Input for signing messages.
- * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature
  */
 export interface HaneulSignMessageInput {
 	message: Uint8Array;
@@ -44,7 +44,7 @@ export interface HaneulSignMessageInput {
 
 /**
  * Output of signing messages.
- * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `haneul:signPersonalMessage` feature
  */
 export interface HaneulSignMessageOutput {
 	/** Base64 message bytes. */

package/src/features/haneulSignPersonalMessage.ts

@@ -4,7 +4,7 @@
 import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
 
 /** Name of the feature. */
-export const HaneulSignPersonalMessage = 'sui:signPersonalMessage';
+export const HaneulSignPersonalMessage = 'haneul:signPersonalMessage';
 
 /** The latest API version of the signPersonalMessage API. */
 export type HaneulSignPersonalMessageVersion = '1.1.0';

package/src/features/haneulSignTransaction.ts

@@ -4,7 +4,7 @@
 import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
 
 /** Name of the feature. */
-export const HaneulSignTransaction = 'sui:signTransaction';
+export const HaneulSignTransaction = 'haneul:signTransaction';
 
 /** The latest API version of the signTransaction API. */
 export type HaneulSignTransactionVersion = '2.0.0';

package/src/features/haneulSignTransactionBlock.ts

@@ -5,13 +5,13 @@ import type { Transaction } from '@haneullabs/haneul/transactions';
 import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
 
 /** Name of the feature. */
-export const HaneulSignTransactionBlock = 'sui:signTransactionBlock';
+export const HaneulSignTransactionBlock = 'haneul:signTransactionBlock';
 
 /** The latest API version of the signTransactionBlock API. */
 export type HaneulSignTransactionBlockVersion = '1.0.0';
 
 /**
- * @deprecated Use `sui:signTransaction` instead.
+ * @deprecated Use `haneul:signTransaction` instead.
  *
  * A Wallet Standard feature for signing a transaction, and returning the
  * serialized transaction and transaction signature.
@@ -21,12 +21,12 @@ export type HaneulSignTransactionBlockFeature = {
 	[HaneulSignTransactionBlock]: {
 		/** Version of the feature API. */
 		version: HaneulSignTransactionBlockVersion;
-		/** @deprecated Use `sui:signTransaction` instead. */
+		/** @deprecated Use `haneul:signTransaction` instead. */
 		signTransactionBlock: HaneulSignTransactionBlockMethod;
 	};
 };
 
-/** @deprecated Use `sui:signTransaction` instead. */
+/** @deprecated Use `haneul:signTransaction` instead. */
 export type HaneulSignTransactionBlockMethod = (
 	input: HaneulSignTransactionBlockInput,
 ) => Promise<HaneulSignTransactionBlockOutput>;

package/src/features/index.ts

@@ -9,7 +9,6 @@ import type {
 	WalletWithFeatures,
 } from '@wallet-standard/core';
 
-import type { HaneulReportTransactionEffectsFeature } from './haneulReportTransactionEffects.js';
 import type { HaneulSignAndExecuteTransactionFeature } from './haneulSignAndExecuteTransaction.js';
 import type { HaneulSignAndExecuteTransactionBlockFeature } from './haneulSignAndExecuteTransactionBlock.js';
 import type { HaneulSignMessageFeature } from './haneulSignMessage.js';
@@ -28,7 +27,6 @@ export type HaneulFeatures = Partial<HaneulSignTransactionBlockFeature> &
 	HaneulSignTransactionFeature &
 	// This deprecated feature should be removed once wallets update to the new method:
 	Partial<HaneulSignMessageFeature> &
-	Partial<HaneulReportTransactionEffectsFeature> &
 	Partial<HaneulGetCapabilitiesFeature>;
 
 export type HaneulWalletFeatures = StandardConnectFeature &
@@ -37,7 +35,7 @@ export type HaneulWalletFeatures = StandardConnectFeature &
 	// Disconnect is an optional feature:
 	Partial<StandardDisconnectFeature>;
 
-export type WalletWithHaneulFeatures = WalletWithFeatures<HaneulWalletFeatures>;
+export type WalletWithSuiFeatures = WalletWithFeatures<HaneulWalletFeatures>;
 
 /**
  * Represents a wallet with the absolute minimum feature set required to function in the Haneul ecosystem.
@@ -57,5 +55,4 @@ export * from './haneulSignTransaction.js';
 export * from './haneulSignAndExecuteTransactionBlock.js';
 export * from './haneulSignAndExecuteTransaction.js';
 export * from './haneulSignPersonalMessage.js';
-export * from './haneulReportTransactionEffects.js';
 export * from './haneulGetCapabilities.js';

package/src/types.ts

@@ -9,7 +9,7 @@ export interface GasData {
 	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 SUI coins to fund the transaction */
+	/** The list of HANEUL coins to fund the transaction */
 	payment: { objectId: string; version: string; digest: string }[] | null;
 }
 

package/src/wallet.ts

@@ -33,17 +33,17 @@ export async function signAndExecuteTransaction(
 	wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,
 	input: HaneulSignAndExecuteTransactionInput,
 ) {
-	if (wallet.features['sui:signAndExecuteTransaction']) {
-		return wallet.features['sui:signAndExecuteTransaction'].signAndExecuteTransaction(input);
+	if (wallet.features['haneul:signAndExecuteTransaction']) {
+		return wallet.features['haneul:signAndExecuteTransaction'].signAndExecuteTransaction(input);
 	}
 
-	if (!wallet.features['sui:signAndExecuteTransactionBlock']) {
+	if (!wallet.features['haneul:signAndExecuteTransactionBlock']) {
 		throw new Error(
 			`Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`,
 		);
 	}
 
-	const { signAndExecuteTransactionBlock } = wallet.features['sui:signAndExecuteTransactionBlock'];
+	const { signAndExecuteTransactionBlock } = wallet.features['haneul:signAndExecuteTransactionBlock'];
 
 	const transactionBlock = Transaction.from(await input.transaction.toJSON());
 	const { digest, rawEffects, rawTransaction } = await signAndExecuteTransactionBlock({
@@ -77,17 +77,17 @@ export async function signTransaction(
 	wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,
 	input: HaneulSignTransactionInput,
 ) {
-	if (wallet.features['sui:signTransaction']) {
-		return wallet.features['sui:signTransaction'].signTransaction(input);
+	if (wallet.features['haneul:signTransaction']) {
+		return wallet.features['haneul:signTransaction'].signTransaction(input);
 	}
 
-	if (!wallet.features['sui:signTransactionBlock']) {
+	if (!wallet.features['haneul:signTransactionBlock']) {
 		throw new Error(
 			`Provided wallet (${wallet.name}) does not support the signTransaction feature.`,
 		);
 	}
 
-	const { signTransactionBlock } = wallet.features['sui:signTransactionBlock'];
+	const { signTransactionBlock } = wallet.features['haneul:signTransactionBlock'];
 
 	const transaction = Transaction.from(await input.transaction.toJSON());
 	const { transactionBlockBytes, signature } = await signTransactionBlock({

package/dist/cjs/chains.d.ts

@@ -1,16 +0,0 @@
-import type { IdentifierString } from '@wallet-standard/core';
-/** Haneul Devnet */
-export declare const HANEUL_DEVNET_CHAIN = "haneul:devnet";
-/** Haneul Testnet */
-export declare const HANEUL_TESTNET_CHAIN = "haneul:testnet";
-/** Haneul Localnet */
-export declare const HANEUL_LOCALNET_CHAIN = "haneul:localnet";
-/** Haneul Mainnet */
-export declare const HANEUL_MAINNET_CHAIN = "haneul:mainnet";
-export declare const HANEUL_CHAINS: readonly ["haneul:devnet", "haneul:testnet", "haneul:localnet", "haneul:mainnet"];
-export type HaneulChain = (typeof HANEUL_CHAINS)[number];
-/**
- * Utility that returns whether or not a chain identifier is a valid Haneul chain.
- * @param chain a chain identifier in the form of `${string}:{$string}`
- */
-export declare function isHaneulChain(chain: IdentifierString): chain is HaneulChain;

package/dist/cjs/chains.js

@@ -1,42 +0,0 @@
-"use strict";
-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))
-      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 chains_exports = {};
-__export(chains_exports, {
-  HANEUL_CHAINS: () => HANEUL_CHAINS,
-  HANEUL_DEVNET_CHAIN: () => HANEUL_DEVNET_CHAIN,
-  HANEUL_LOCALNET_CHAIN: () => HANEUL_LOCALNET_CHAIN,
-  HANEUL_MAINNET_CHAIN: () => HANEUL_MAINNET_CHAIN,
-  HANEUL_TESTNET_CHAIN: () => HANEUL_TESTNET_CHAIN,
-  isHaneulChain: () => isHaneulChain
-});
-module.exports = __toCommonJS(chains_exports);
-const HANEUL_DEVNET_CHAIN = "haneul:devnet";
-const HANEUL_TESTNET_CHAIN = "haneul:testnet";
-const HANEUL_LOCALNET_CHAIN = "haneul:localnet";
-const HANEUL_MAINNET_CHAIN = "haneul:mainnet";
-const HANEUL_CHAINS = [
-  HANEUL_DEVNET_CHAIN,
-  HANEUL_TESTNET_CHAIN,
-  HANEUL_LOCALNET_CHAIN,
-  HANEUL_MAINNET_CHAIN
-];
-function isHaneulChain(chain) {
-  return HANEUL_CHAINS.includes(chain);
-}
-//# sourceMappingURL=chains.js.map