@haneullabs/payment-kit 0.1.0

package/dist/cjs/contracts/payment_kit/payment_kit.js

@@ -0,0 +1,252 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var payment_kit_exports = {};
+__export(payment_kit_exports, {
+  BalanceKey: () => BalanceKey,
+  Namespace: () => Namespace,
+  PaymentKey: () => PaymentKey,
+  PaymentReceipt: () => PaymentReceipt,
+  PaymentRecord: () => PaymentRecord,
+  PaymentRegistry: () => PaymentRegistry,
+  PaymentType: () => PaymentType,
+  RegistryAdminCap: () => RegistryAdminCap,
+  createPaymentKey: () => createPaymentKey,
+  createRegistry: () => createRegistry,
+  deletePaymentRecord: () => deletePaymentRecord,
+  processEphemeralPayment: () => processEphemeralPayment,
+  processRegistryPayment: () => processRegistryPayment,
+  setConfigEpochExpirationDuration: () => setConfigEpochExpirationDuration,
+  setConfigRegistryManagedFunds: () => setConfigRegistryManagedFunds,
+  share: () => share,
+  withdrawFromRegistry: () => withdrawFromRegistry
+});
+module.exports = __toCommonJS(payment_kit_exports);
+var import_utils = require("../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var object = __toESM(require("./deps/sui/object.js"));
+var vec_map = __toESM(require("./deps/sui/vec_map.js"));
+var config = __toESM(require("./config.js"));
+const $moduleName = "@haneullabs/payment-kit::payment_kit";
+const Namespace = new import_utils.MoveStruct({
+  name: `${$moduleName}::Namespace`,
+  fields: {
+    id: object.UID
+  }
+});
+const PaymentRegistry = new import_utils.MoveStruct({
+  name: `${$moduleName}::PaymentRegistry`,
+  fields: {
+    id: object.UID,
+    cap_id: import_bcs.bcs.Address,
+    config: vec_map.VecMap(import_bcs.bcs.string(), config.Value),
+    version: import_bcs.bcs.u16()
+  }
+});
+const RegistryAdminCap = new import_utils.MoveStruct({
+  name: `${$moduleName}::RegistryAdminCap`,
+  fields: {
+    id: object.UID,
+    registry_id: import_bcs.bcs.Address
+  }
+});
+const PaymentType = new import_utils.MoveEnum({
+  name: `${$moduleName}::PaymentType`,
+  fields: {
+    Ephemeral: null,
+    Registry: import_bcs.bcs.Address
+  }
+});
+const PaymentReceipt = new import_utils.MoveStruct({
+  name: `${$moduleName}::PaymentReceipt`,
+  fields: {
+    payment_type: PaymentType,
+    nonce: import_bcs.bcs.string(),
+    payment_amount: import_bcs.bcs.u64(),
+    receiver: import_bcs.bcs.Address,
+    coin_type: import_bcs.bcs.string(),
+    timestamp_ms: import_bcs.bcs.u64()
+  }
+});
+const PaymentKey = new import_utils.MoveStruct({
+  name: `${$moduleName}::PaymentKey`,
+  fields: {
+    nonce: import_bcs.bcs.string(),
+    payment_amount: import_bcs.bcs.u64(),
+    receiver: import_bcs.bcs.Address
+  }
+});
+const PaymentRecord = new import_utils.MoveStruct({
+  name: `${$moduleName}::PaymentRecord`,
+  fields: {
+    epoch_at_time_of_record: import_bcs.bcs.u64()
+  }
+});
+const BalanceKey = new import_utils.MoveTuple({
+  name: `${$moduleName}::BalanceKey`,
+  fields: [import_bcs.bcs.bool()]
+});
+function createRegistry(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::Namespace`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String"
+  ];
+  const parameterNames = ["namespace", "name"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "create_registry",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function processEphemeralPayment(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+    "u64",
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    "address",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["nonce", "paymentAmount", "coin", "receiver"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "process_ephemeral_payment",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function processRegistryPayment(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::PaymentRegistry`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+    "u64",
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<address>",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["registry", "nonce", "paymentAmount", "coin", "receiver"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "process_registry_payment",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function withdrawFromRegistry(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::PaymentRegistry`,
+    `${packageAddress}::payment_kit::RegistryAdminCap`
+  ];
+  const parameterNames = ["registry", "cap"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "withdraw_from_registry",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function deletePaymentRecord(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::PaymentRegistry`,
+    `${packageAddress}::payment_kit::PaymentKey<${options.typeArguments[0]}>`
+  ];
+  const parameterNames = ["registry", "paymentKey"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "delete_payment_record",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function createPaymentKey(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+    "u64",
+    "address"
+  ];
+  const parameterNames = ["nonce", "paymentAmount", "receiver"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "create_payment_key",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function setConfigEpochExpirationDuration(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::PaymentRegistry`,
+    `${packageAddress}::payment_kit::RegistryAdminCap`,
+    "u64"
+  ];
+  const parameterNames = ["registry", "cap", "epochExpirationDuration"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "set_config_epoch_expiration_duration",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function setConfigRegistryManagedFunds(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [
+    `${packageAddress}::payment_kit::PaymentRegistry`,
+    `${packageAddress}::payment_kit::RegistryAdminCap`,
+    "bool"
+  ];
+  const parameterNames = ["registry", "cap", "registryManagedFunds"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "set_config_registry_managed_funds",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function share(options) {
+  const packageAddress = options.package ?? "@haneullabs/payment-kit";
+  const argumentsTypes = [`${packageAddress}::payment_kit::PaymentRegistry`];
+  const parameterNames = ["registry"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "payment_kit",
+    function: "share",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+//# sourceMappingURL=payment_kit.js.map

package/dist/cjs/contracts/payment_kit/payment_kit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/payment_kit/payment_kit.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { MoveStruct, MoveEnum, MoveTuple, normalizeMoveArguments } from '../utils/index.js';\nimport type { RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { Transaction } from '@haneullabs/haneul/transactions';\nimport * as object from './deps/sui/object.js';\nimport * as vec_map from './deps/sui/vec_map.js';\nimport * as config from './config.js';\nconst $moduleName = '@haneullabs/payment-kit::payment_kit';\nexport const Namespace = new MoveStruct({\n\tname: `${$moduleName}::Namespace`,\n\tfields: {\n\t\tid: object.UID,\n\t},\n});\nexport const PaymentRegistry = new MoveStruct({\n\tname: `${$moduleName}::PaymentRegistry`,\n\tfields: {\n\t\tid: object.UID,\n\t\tcap_id: bcs.Address,\n\t\tconfig: vec_map.VecMap(bcs.string(), config.Value),\n\t\tversion: bcs.u16(),\n\t},\n});\nexport const RegistryAdminCap = new MoveStruct({\n\tname: `${$moduleName}::RegistryAdminCap`,\n\tfields: {\n\t\tid: object.UID,\n\t\tregistry_id: bcs.Address,\n\t},\n});\n/**\n * Enum representing the type of payment: Ephemeral (one-time) or Registry (tracked\n * in a registry).\n */\nexport const PaymentType = new MoveEnum({\n\tname: `${$moduleName}::PaymentType`,\n\tfields: {\n\t\tEphemeral: null,\n\t\tRegistry: bcs.Address,\n\t},\n});\nexport const PaymentReceipt = new MoveStruct({\n\tname: `${$moduleName}::PaymentReceipt`,\n\tfields: {\n\t\tpayment_type: PaymentType,\n\t\tnonce: bcs.string(),\n\t\tpayment_amount: bcs.u64(),\n\t\treceiver: bcs.Address,\n\t\tcoin_type: bcs.string(),\n\t\ttimestamp_ms: bcs.u64(),\n\t},\n});\nexport const PaymentKey = new MoveStruct({\n\tname: `${$moduleName}::PaymentKey`,\n\tfields: {\n\t\tnonce: bcs.string(),\n\t\tpayment_amount: bcs.u64(),\n\t\treceiver: bcs.Address,\n\t},\n});\nexport const PaymentRecord = new MoveStruct({\n\tname: `${$moduleName}::PaymentRecord`,\n\tfields: {\n\t\tepoch_at_time_of_record: bcs.u64(),\n\t},\n});\nexport const BalanceKey = new MoveTuple({\n\tname: `${$moduleName}::BalanceKey`,\n\tfields: [bcs.bool()],\n});\nexport interface CreateRegistryArguments {\n\tnamespace: RawTransactionArgument<string>;\n\tname: RawTransactionArgument<string>;\n}\nexport interface CreateRegistryOptions {\n\tpackage?: string;\n\targuments:\n\t\t| CreateRegistryArguments\n\t\t| [namespace: RawTransactionArgument<string>, name: RawTransactionArgument<string>];\n}\n/**\n * Creates a new payment registry with a supplied label. Label is used to derive\n * the registry's ID.\n */\nexport function createRegistry(options: CreateRegistryOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::Namespace`,\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String',\n\t] satisfies string[];\n\tconst parameterNames = ['namespace', 'name'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'create_registry',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface ProcessEphemeralPaymentArguments {\n\tnonce: RawTransactionArgument<string>;\n\tpaymentAmount: RawTransactionArgument<number | bigint>;\n\tcoin: RawTransactionArgument<string>;\n\treceiver: RawTransactionArgument<string>;\n}\nexport interface ProcessEphemeralPaymentOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ProcessEphemeralPaymentArguments\n\t\t| [\n\t\t\t\tnonce: RawTransactionArgument<string>,\n\t\t\t\tpaymentAmount: RawTransactionArgument<number | bigint>,\n\t\t\t\tcoin: RawTransactionArgument<string>,\n\t\t\t\treceiver: RawTransactionArgument<string>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/**\n * Processes a payment (without the use of a Registry), emitting a payment receipt\n * event.\n */\nexport function processEphemeralPayment(options: ProcessEphemeralPaymentOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String',\n\t\t'u64',\n\t\t`0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,\n\t\t'address',\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock',\n\t] satisfies string[];\n\tconst parameterNames = ['nonce', 'paymentAmount', 'coin', 'receiver'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'process_ephemeral_payment',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface ProcessRegistryPaymentArguments {\n\tregistry: RawTransactionArgument<string>;\n\tnonce: RawTransactionArgument<string>;\n\tpaymentAmount: RawTransactionArgument<number | bigint>;\n\tcoin: RawTransactionArgument<string>;\n\treceiver: RawTransactionArgument<string | null>;\n}\nexport interface ProcessRegistryPaymentOptions {\n\tpackage?: string;\n\targuments:\n\t\t| ProcessRegistryPaymentArguments\n\t\t| [\n\t\t\t\tregistry: RawTransactionArgument<string>,\n\t\t\t\tnonce: RawTransactionArgument<string>,\n\t\t\t\tpaymentAmount: RawTransactionArgument<number | bigint>,\n\t\t\t\tcoin: RawTransactionArgument<string>,\n\t\t\t\treceiver: RawTransactionArgument<string | null>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/**\n * Processes a payment via a payment registry, writing a receipt to the registry\n * and protecting from double spending for the same key.\n */\nexport function processRegistryPayment(options: ProcessRegistryPaymentOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::PaymentRegistry`,\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String',\n\t\t'u64',\n\t\t`0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<address>',\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock',\n\t] satisfies string[];\n\tconst parameterNames = ['registry', 'nonce', 'paymentAmount', 'coin', 'receiver'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'process_registry_payment',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface WithdrawFromRegistryArguments {\n\tregistry: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n}\nexport interface WithdrawFromRegistryOptions {\n\tpackage?: string;\n\targuments:\n\t\t| WithdrawFromRegistryArguments\n\t\t| [registry: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/**\n * If the registry is configured to manage funds, withdraw all funds of the\n * specified coin from the registry.\n */\nexport function withdrawFromRegistry(options: WithdrawFromRegistryOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::PaymentRegistry`,\n\t\t`${packageAddress}::payment_kit::RegistryAdminCap`,\n\t] satisfies string[];\n\tconst parameterNames = ['registry', 'cap'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'withdraw_from_registry',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface DeletePaymentRecordArguments {\n\tregistry: RawTransactionArgument<string>;\n\tpaymentKey: RawTransactionArgument<string>;\n}\nexport interface DeletePaymentRecordOptions {\n\tpackage?: string;\n\targuments:\n\t\t| DeletePaymentRecordArguments\n\t\t| [registry: RawTransactionArgument<string>, paymentKey: RawTransactionArgument<string>];\n\ttypeArguments: [string];\n}\n/** Removes an expired Payment Record from the Registry. */\nexport function deletePaymentRecord(options: DeletePaymentRecordOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::PaymentRegistry`,\n\t\t`${packageAddress}::payment_kit::PaymentKey<${options.typeArguments[0]}>`,\n\t] satisfies string[];\n\tconst parameterNames = ['registry', 'paymentKey'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'delete_payment_record',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface CreatePaymentKeyArguments {\n\tnonce: RawTransactionArgument<string>;\n\tpaymentAmount: RawTransactionArgument<number | bigint>;\n\treceiver: RawTransactionArgument<string>;\n}\nexport interface CreatePaymentKeyOptions {\n\tpackage?: string;\n\targuments:\n\t\t| CreatePaymentKeyArguments\n\t\t| [\n\t\t\t\tnonce: RawTransactionArgument<string>,\n\t\t\t\tpaymentAmount: RawTransactionArgument<number | bigint>,\n\t\t\t\treceiver: RawTransactionArgument<string>,\n\t\t  ];\n\ttypeArguments: [string];\n}\n/** Creates a PaymentKey from payment parameters. */\nexport function createPaymentKey(options: CreatePaymentKeyOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t'0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String',\n\t\t'u64',\n\t\t'address',\n\t] satisfies string[];\n\tconst parameterNames = ['nonce', 'paymentAmount', 'receiver'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'create_payment_key',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t\ttypeArguments: options.typeArguments,\n\t\t});\n}\nexport interface SetConfigEpochExpirationDurationArguments {\n\tregistry: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\tepochExpirationDuration: RawTransactionArgument<number | bigint>;\n}\nexport interface SetConfigEpochExpirationDurationOptions {\n\tpackage?: string;\n\targuments:\n\t\t| SetConfigEpochExpirationDurationArguments\n\t\t| [\n\t\t\t\tregistry: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\tepochExpirationDuration: RawTransactionArgument<number | bigint>,\n\t\t  ];\n}\n/**\n * Sets the epoch expiration duration configuration for the registry. If set,\n * payment records will expire after the specified number of epochs. If not set,\n * payment records will expire 30 epochs after their creation.\n */\nexport function setConfigEpochExpirationDuration(options: SetConfigEpochExpirationDurationOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::PaymentRegistry`,\n\t\t`${packageAddress}::payment_kit::RegistryAdminCap`,\n\t\t'u64',\n\t] satisfies string[];\n\tconst parameterNames = ['registry', 'cap', 'epochExpirationDuration'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'set_config_epoch_expiration_duration',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface SetConfigRegistryManagedFundsArguments {\n\tregistry: RawTransactionArgument<string>;\n\tcap: RawTransactionArgument<string>;\n\tregistryManagedFunds: RawTransactionArgument<boolean>;\n}\nexport interface SetConfigRegistryManagedFundsOptions {\n\tpackage?: string;\n\targuments:\n\t\t| SetConfigRegistryManagedFundsArguments\n\t\t| [\n\t\t\t\tregistry: RawTransactionArgument<string>,\n\t\t\t\tcap: RawTransactionArgument<string>,\n\t\t\t\tregistryManagedFunds: RawTransactionArgument<boolean>,\n\t\t  ];\n}\n/**\n * Sets whether the registry should manage funds itself. If true, payments\n * processed via the registry will be collected into the registry's balance. If\n * false, payments will be transferred directly to the specified receiver.\n */\nexport function setConfigRegistryManagedFunds(options: SetConfigRegistryManagedFundsOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [\n\t\t`${packageAddress}::payment_kit::PaymentRegistry`,\n\t\t`${packageAddress}::payment_kit::RegistryAdminCap`,\n\t\t'bool',\n\t] satisfies string[];\n\tconst parameterNames = ['registry', 'cap', 'registryManagedFunds'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'set_config_registry_managed_funds',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface ShareArguments {\n\tregistry: RawTransactionArgument<string>;\n}\nexport interface ShareOptions {\n\tpackage?: string;\n\targuments: ShareArguments | [registry: RawTransactionArgument<string>];\n}\n/**\n * Enforce that a registry will always be shared.\n *\n * # Parameters\n *\n * - `registry` - The PaymentRegistry to share\n */\nexport function share(options: ShareOptions) {\n\tconst packageAddress = options.package ?? '@haneullabs/payment-kit';\n\tconst argumentsTypes = [`${packageAddress}::payment_kit::PaymentRegistry`] satisfies string[];\n\tconst parameterNames = ['registry'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'payment_kit',\n\t\t\tfunction: 'share',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/contracts/utils/index.d.ts

@@ -0,0 +1,12 @@
+import type { BcsType, TypeTag } from '@haneullabs/haneul/bcs';
+import { BcsStruct, BcsEnum, BcsTuple } from '@haneullabs/haneul/bcs';
+import type { TransactionArgument } from '@haneullabs/haneul/transactions';
+export type RawTransactionArgument<T> = T | TransactionArgument;
+export declare function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null;
+export declare function normalizeMoveArguments(args: unknown[] | object, argTypes: string[], parameterNames?: string[]): TransactionArgument[];
+export declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+}
+export declare class MoveEnum<T extends Record<string, BcsType<any> | null>, const Name extends string> extends BcsEnum<T, Name> {
+}
+export declare class MoveTuple<T extends readonly BcsType<any>[], const Name extends string> extends BcsTuple<T, Name> {
+}

package/dist/cjs/contracts/utils/index.js

@@ -0,0 +1,151 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  MoveEnum: () => MoveEnum,
+  MoveStruct: () => MoveStruct,
+  MoveTuple: () => MoveTuple,
+  getPureBcsSchema: () => getPureBcsSchema,
+  normalizeMoveArguments: () => normalizeMoveArguments
+});
+module.exports = __toCommonJS(utils_exports);
+var import_bcs = require("@haneullabs/haneul/bcs");
+var import_utils = require("@haneullabs/haneul/utils");
+var import_transactions = require("@haneullabs/haneul/transactions");
+const MOVE_STDLIB_ADDRESS = (0, import_utils.normalizeHaneulAddress)("0x1");
+const HANEUL_FRAMEWORK_ADDRESS = (0, import_utils.normalizeHaneulAddress)("0x2");
+const HANEUL_SYSTEM_ADDRESS = (0, import_utils.normalizeHaneulAddress)("0x3");
+function getPureBcsSchema(typeTag) {
+  const parsedTag = typeof typeTag === "string" ? import_bcs.TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+  if ("u8" in parsedTag) {
+    return import_bcs.bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return import_bcs.bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return import_bcs.bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return import_bcs.bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return import_bcs.bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return import_bcs.bcs.U256;
+  } else if ("address" in parsedTag) {
+    return import_bcs.bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return import_bcs.bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? import_bcs.bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = (0, import_utils.normalizeHaneulAddress)(parsedTag.struct.address);
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
+        return import_bcs.bcs.String;
+      }
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const type = getPureBcsSchema(structTag.typeParams[0]);
+        return type ? import_bcs.bcs.option(type) : null;
+      }
+    }
+    if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === "Object" && structTag.name === "ID") {
+      return import_bcs.bcs.Address;
+    }
+  }
+  return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+  if (parameterNames && argLen !== parameterNames.length) {
+    throw new Error(
+      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`
+    );
+  }
+  const normalizedArgs = [];
+  let index = 0;
+  for (const [i, argType] of argTypes.entries()) {
+    if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+      normalizedArgs.push((tx) => tx.object.denyList());
+      continue;
+    }
+    if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::random::Random`) {
+      normalizedArgs.push((tx) => tx.object.random());
+      continue;
+    }
+    if (argType === `${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock`) {
+      normalizedArgs.push((tx) => tx.object.clock());
+      continue;
+    }
+    if (argType === `${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState`) {
+      normalizedArgs.push((tx) => tx.object.system());
+      continue;
+    }
+    let arg;
+    if (Array.isArray(args)) {
+      if (index >= args.length) {
+        throw new Error(
+          `Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`
+        );
+      }
+      arg = args[index];
+    } else {
+      if (!parameterNames) {
+        throw new Error(`Expected arguments to be passed as an array`);
+      }
+      const name = parameterNames[index];
+      arg = args[name];
+      if (arg == null) {
+        throw new Error(`Parameter ${name} is required`);
+      }
+    }
+    index += 1;
+    if (typeof arg === "function" || (0, import_transactions.isArgument)(arg)) {
+      normalizedArgs.push(arg);
+      continue;
+    }
+    const type = argTypes[i];
+    const bcsType = getPureBcsSchema(type);
+    if (bcsType) {
+      const bytes = bcsType.serialize(arg);
+      normalizedArgs.push((tx) => tx.pure(bytes));
+      continue;
+    } else if (typeof arg === "string") {
+      normalizedArgs.push((tx) => tx.object(arg));
+      continue;
+    }
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+  }
+  return normalizedArgs;
+}
+class MoveStruct extends import_bcs.BcsStruct {
+}
+class MoveEnum extends import_bcs.BcsEnum {
+}
+class MoveTuple extends import_bcs.BcsTuple {
+}
+function stringify(val) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val2) => val2);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/contracts/utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/utils/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport type { BcsType, TypeTag } from '@haneullabs/haneul/bcs';\nimport { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from '@haneullabs/haneul/bcs';\nimport { normalizeHaneulAddress } from '@haneullabs/haneul/utils';\nimport type { TransactionArgument } from '@haneullabs/haneul/transactions';\nimport { isArgument } from '@haneullabs/haneul/transactions';\n\nconst MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');\nconst HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');\nconst HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress('0x3');\n\nexport type RawTransactionArgument<T> = T | TransactionArgument;\n\nexport function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {\n\tconst parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;\n\n\tif ('u8' in parsedTag) {\n\t\treturn bcs.U8;\n\t} else if ('u16' in parsedTag) {\n\t\treturn bcs.U16;\n\t} else if ('u32' in parsedTag) {\n\t\treturn bcs.U32;\n\t} else if ('u64' in parsedTag) {\n\t\treturn bcs.U64;\n\t} else if ('u128' in parsedTag) {\n\t\treturn bcs.U128;\n\t} else if ('u256' in parsedTag) {\n\t\treturn bcs.U256;\n\t} else if ('address' in parsedTag) {\n\t\treturn bcs.Address;\n\t} else if ('bool' in parsedTag) {\n\t\treturn bcs.Bool;\n\t} else if ('vector' in parsedTag) {\n\t\tconst type = getPureBcsSchema(parsedTag.vector);\n\t\treturn type ? bcs.vector(type) : null;\n\t} else if ('struct' in parsedTag) {\n\t\tconst structTag = parsedTag.struct;\n\t\tconst pkg = normalizeHaneulAddress(parsedTag.struct.address);\n\n\t\tif (pkg === MOVE_STDLIB_ADDRESS) {\n\t\t\tif (\n\t\t\t\t(structTag.module === 'ascii' || structTag.module === 'string') &&\n\t\t\t\tstructTag.name === 'String'\n\t\t\t) {\n\t\t\t\treturn bcs.String;\n\t\t\t}\n\n\t\t\tif (structTag.module === 'option' && structTag.name === 'Option') {\n\t\t\t\tconst type = getPureBcsSchema(structTag.typeParams[0]!);\n\t\t\t\treturn type ? bcs.option(type) : null;\n\t\t\t}\n\t\t}\n\n\t\tif (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {\n\t\t\treturn bcs.Address;\n\t\t}\n\t}\n\n\treturn null;\n}\n\nexport function normalizeMoveArguments(\n\targs: unknown[] | object,\n\targTypes: string[],\n\tparameterNames?: string[],\n) {\n\tconst argLen = Array.isArray(args) ? args.length : Object.keys(args).length;\n\tif (parameterNames && argLen !== parameterNames.length) {\n\t\tthrow new Error(\n\t\t\t`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`,\n\t\t);\n\t}\n\n\tconst normalizedArgs: TransactionArgument[] = [];\n\n\tlet index = 0;\n\tfor (const [i, argType] of argTypes.entries()) {\n\t\tif (argType === `${HANEUL_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {\n\t\t\tnormalizedArgs.push((tx) => tx.object.denyList());\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (argType === `${HANEUL_FRAMEWORK_ADDRESS}::random::Random`) {\n\t\t\tnormalizedArgs.push((tx) => tx.object.random());\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (argType === `${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock`) {\n\t\t\tnormalizedArgs.push((tx) => tx.object.clock());\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (argType === `${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState`) {\n\t\t\tnormalizedArgs.push((tx) => tx.object.system());\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet arg;\n\t\tif (Array.isArray(args)) {\n\t\t\tif (index >= args.length) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`,\n\t\t\t\t);\n\t\t\t}\n\t\t\targ = args[index];\n\t\t} else {\n\t\t\tif (!parameterNames) {\n\t\t\t\tthrow new Error(`Expected arguments to be passed as an array`);\n\t\t\t}\n\t\t\tconst name = parameterNames[index];\n\t\t\targ = args[name as keyof typeof args];\n\n\t\t\tif (arg == null) {\n\t\t\t\tthrow new Error(`Parameter ${name} is required`);\n\t\t\t}\n\t\t}\n\n\t\tindex += 1;\n\n\t\tif (typeof arg === 'function' || isArgument(arg)) {\n\t\t\tnormalizedArgs.push(arg as TransactionArgument);\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst type = argTypes[i]!;\n\t\tconst bcsType = getPureBcsSchema(type);\n\n\t\tif (bcsType) {\n\t\t\tconst bytes = bcsType.serialize(arg as never);\n\t\t\tnormalizedArgs.push((tx) => tx.pure(bytes));\n\t\t\tcontinue;\n\t\t} else if (typeof arg === 'string') {\n\t\t\tnormalizedArgs.push((tx) => tx.object(arg));\n\t\t\tcontinue;\n\t\t}\n\n\t\tthrow new Error(`Invalid argument ${stringify(arg)} for type ${type}`);\n\t}\n\n\treturn normalizedArgs;\n}\n\nexport class MoveStruct<\n\tT extends Record<string, BcsType<any>>,\n\tconst Name extends string = string,\n> extends BcsStruct<T, Name> {}\n\nexport class MoveEnum<\n\tT extends Record<string, BcsType<any> | null>,\n\tconst Name extends string,\n> extends BcsEnum<T, Name> {}\n\nexport class MoveTuple<\n\tT extends readonly BcsType<any>[],\n\tconst Name extends string,\n> extends BcsTuple<T, Name> {}\n\nfunction stringify(val: unknown) {\n\tif (typeof val === 'object') {\n\t\treturn JSON.stringify(val, (val: unknown) => val);\n\t}\n\tif (typeof val === 'bigint') {\n\t\treturn val.toString();\n\t}\n\n\treturn val;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAqE;AACrE,mBAAuC;AAEvC,0BAA2B;AAE3B,MAAM,0BAAsB,qCAAuB,KAAK;AACxD,MAAM,+BAA2B,qCAAuB,KAAK;AAC7D,MAAM,4BAAwB,qCAAuB,KAAK;AAInD,SAAS,iBAAiB,SAAgD;AAChF,QAAM,YAAY,OAAO,YAAY,WAAW,6BAAkB,aAAa,OAAO,IAAI;AAE1F,MAAI,QAAQ,WAAW;AACtB,WAAO,eAAI;AAAA,EACZ,WAAW,SAAS,WAAW;AAC9B,WAAO,eAAI;AAAA,EACZ,WAAW,SAAS,WAAW;AAC9B,WAAO,eAAI;AAAA,EACZ,WAAW,SAAS,WAAW;AAC9B,WAAO,eAAI;AAAA,EACZ,WAAW,UAAU,WAAW;AAC/B,WAAO,eAAI;AAAA,EACZ,WAAW,UAAU,WAAW;AAC/B,WAAO,eAAI;AAAA,EACZ,WAAW,aAAa,WAAW;AAClC,WAAO,eAAI;AAAA,EACZ,WAAW,UAAU,WAAW;AAC/B,WAAO,eAAI;AAAA,EACZ,WAAW,YAAY,WAAW;AACjC,UAAM,OAAO,iBAAiB,UAAU,MAAM;AAC9C,WAAO,OAAO,eAAI,OAAO,IAAI,IAAI;AAAA,EAClC,WAAW,YAAY,WAAW;AACjC,UAAM,YAAY,UAAU;AAC5B,UAAM,UAAM,qCAAuB,UAAU,OAAO,OAAO;AAE3D,QAAI,QAAQ,qBAAqB;AAChC,WACE,UAAU,WAAW,WAAW,UAAU,WAAW,aACtD,UAAU,SAAS,UAClB;AACD,eAAO,eAAI;AAAA,MACZ;AAEA,UAAI,UAAU,WAAW,YAAY,UAAU,SAAS,UAAU;AACjE,cAAM,OAAO,iBAAiB,UAAU,WAAW,CAAC,CAAE;AACtD,eAAO,OAAO,eAAI,OAAO,IAAI,IAAI;AAAA,MAClC;AAAA,IACD;AAEA,QAAI,QAAQ,4BAA4B,UAAU,WAAW,YAAY,UAAU,SAAS,MAAM;AACjG,aAAO,eAAI;AAAA,IACZ;AAAA,EACD;AAEA,SAAO;AACR;AAEO,SAAS,uBACf,MACA,UACA,gBACC;AACD,QAAM,SAAS,MAAM,QAAQ,IAAI,IAAI,KAAK,SAAS,OAAO,KAAK,IAAI,EAAE;AACrE,MAAI,kBAAkB,WAAW,eAAe,QAAQ;AACvD,UAAM,IAAI;AAAA,MACT,yCAAyC,eAAe,MAAM,SAAS,MAAM;AAAA,IAC9E;AAAA,EACD;AAEA,QAAM,iBAAwC,CAAC;AAE/C,MAAI,QAAQ;AACZ,aAAW,CAAC,GAAG,OAAO,KAAK,SAAS,QAAQ,GAAG;AAC9C,QAAI,YAAY,GAAG,wBAAwB,yBAAyB;AACnE,qBAAe,KAAK,CAAC,OAAO,GAAG,OAAO,SAAS,CAAC;AAChD;AAAA,IACD;AAEA,QAAI,YAAY,GAAG,wBAAwB,oBAAoB;AAC9D,qBAAe,KAAK,CAAC,OAAO,GAAG,OAAO,OAAO,CAAC;AAC9C;AAAA,IACD;AAEA,QAAI,YAAY,GAAG,wBAAwB,kBAAkB;AAC5D,qBAAe,KAAK,CAAC,OAAO,GAAG,OAAO,MAAM,CAAC;AAC7C;AAAA,IACD;AAEA,QAAI,YAAY,GAAG,qBAAqB,sCAAsC;AAC7E,qBAAe,KAAK,CAAC,OAAO,GAAG,OAAO,OAAO,CAAC;AAC9C;AAAA,IACD;AAEA,QAAI;AACJ,QAAI,MAAM,QAAQ,IAAI,GAAG;AACxB,UAAI,SAAS,KAAK,QAAQ;AACzB,cAAM,IAAI;AAAA,UACT,kDAAkD,QAAQ,CAAC,SAAS,KAAK,MAAM;AAAA,QAChF;AAAA,MACD;AACA,YAAM,KAAK,KAAK;AAAA,IACjB,OAAO;AACN,UAAI,CAAC,gBAAgB;AACpB,cAAM,IAAI,MAAM,6CAA6C;AAAA,MAC9D;AACA,YAAM,OAAO,eAAe,KAAK;AACjC,YAAM,KAAK,IAAyB;AAEpC,UAAI,OAAO,MAAM;AAChB,cAAM,IAAI,MAAM,aAAa,IAAI,cAAc;AAAA,MAChD;AAAA,IACD;AAEA,aAAS;AAET,QAAI,OAAO,QAAQ,kBAAc,gCAAW,GAAG,GAAG;AACjD,qBAAe,KAAK,GAA0B;AAC9C;AAAA,IACD;AAEA,UAAM,OAAO,SAAS,CAAC;AACvB,UAAM,UAAU,iBAAiB,IAAI;AAErC,QAAI,SAAS;AACZ,YAAM,QAAQ,QAAQ,UAAU,GAAY;AAC5C,qBAAe,KAAK,CAAC,OAAO,GAAG,KAAK,KAAK,CAAC;AAC1C;AAAA,IACD,WAAW,OAAO,QAAQ,UAAU;AACnC,qBAAe,KAAK,CAAC,OAAO,GAAG,OAAO,GAAG,CAAC;AAC1C;AAAA,IACD;AAEA,UAAM,IAAI,MAAM,oBAAoB,UAAU,GAAG,CAAC,aAAa,IAAI,EAAE;AAAA,EACtE;AAEA,SAAO;AACR;AAEO,MAAM,mBAGH,qBAAmB;AAAC;AAEvB,MAAM,iBAGH,mBAAiB;AAAC;AAErB,MAAM,kBAGH,oBAAkB;AAAC;AAE7B,SAAS,UAAU,KAAc;AAChC,MAAI,OAAO,QAAQ,UAAU;AAC5B,WAAO,KAAK,UAAU,KAAK,CAACA,SAAiBA,IAAG;AAAA,EACjD;AACA,MAAI,OAAO,QAAQ,UAAU;AAC5B,WAAO,IAAI,SAAS;AAAA,EACrB;AAEA,SAAO;AACR;",
+  "names": ["val"]
+}

package/dist/cjs/error.d.ts

@@ -0,0 +1,4 @@
+export declare class PaymentKitClientError extends Error {
+}
+export declare class PaymentKitUriError extends PaymentKitClientError {
+}

package/dist/cjs/error.js

@@ -0,0 +1,29 @@
+"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 error_exports = {};
+__export(error_exports, {
+  PaymentKitClientError: () => PaymentKitClientError,
+  PaymentKitUriError: () => PaymentKitUriError
+});
+module.exports = __toCommonJS(error_exports);
+class PaymentKitClientError extends Error {
+}
+class PaymentKitUriError extends PaymentKitClientError {
+}
+//# sourceMappingURL=error.js.map

package/dist/cjs/error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/error.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport class PaymentKitClientError extends Error {}\n\nexport class PaymentKitUriError extends PaymentKitClientError {}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,MAAM,8BAA8B,MAAM;AAAC;AAE3C,MAAM,2BAA2B,sBAAsB;AAAC;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export { PaymentKitClient, paymentKit } from './client.js';
+export type { PaymentKitCompatibleClient, PaymentKitClientOptions, PaymentKitPackageConfig, GetPaymentRecordOptions, ProcessRegistryPaymentOptions, ProcessEphemeralPaymentOptions, GetPaymentRecordResponse, CreateRegistryOptions, SetEpochExpirationDurationOptions, SetRegistryManagedFundsOptions, WithdrawFromRegistryOptions, DeletePaymentRecordOptions, PaymentUriParams, } from './types.js';
+export { PaymentKitClientError, PaymentKitUriError } from './error.js';
+export { DEFAULT_REGISTRY_NAME, SUI_PAYMENT_KIT_PROTOCOL } from './constants.js';
+export { createPaymentTransactionUri, parsePaymentTransactionUri } from './uri.js';

package/dist/cjs/index.js

@@ -0,0 +1,35 @@
+"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 index_exports = {};
+__export(index_exports, {
+  DEFAULT_REGISTRY_NAME: () => import_constants.DEFAULT_REGISTRY_NAME,
+  PaymentKitClient: () => import_client.PaymentKitClient,
+  PaymentKitClientError: () => import_error.PaymentKitClientError,
+  PaymentKitUriError: () => import_error.PaymentKitUriError,
+  SUI_PAYMENT_KIT_PROTOCOL: () => import_constants.SUI_PAYMENT_KIT_PROTOCOL,
+  createPaymentTransactionUri: () => import_uri.createPaymentTransactionUri,
+  parsePaymentTransactionUri: () => import_uri.parsePaymentTransactionUri,
+  paymentKit: () => import_client.paymentKit
+});
+module.exports = __toCommonJS(index_exports);
+var import_client = require("./client.js");
+var import_error = require("./error.js");
+var import_constants = require("./constants.js");
+var import_uri = require("./uri.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport { PaymentKitClient, paymentKit } from './client.js';\nexport type {\n\tPaymentKitCompatibleClient,\n\tPaymentKitClientOptions,\n\tPaymentKitPackageConfig,\n\tGetPaymentRecordOptions,\n\tProcessRegistryPaymentOptions,\n\tProcessEphemeralPaymentOptions,\n\tGetPaymentRecordResponse,\n\tCreateRegistryOptions,\n\tSetEpochExpirationDurationOptions,\n\tSetRegistryManagedFundsOptions,\n\tWithdrawFromRegistryOptions,\n\tDeletePaymentRecordOptions,\n\tPaymentUriParams,\n} from './types.js';\nexport { PaymentKitClientError, PaymentKitUriError } from './error.js';\nexport { DEFAULT_REGISTRY_NAME, SUI_PAYMENT_KIT_PROTOCOL } from './constants.js';\nexport { createPaymentTransactionUri, parsePaymentTransactionUri } from './uri.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAA6C;AAgB7C,mBAA0D;AAC1D,uBAAgE;AAChE,iBAAwE;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "type": "commonjs",
+  "sideEffects": false
+}