@haneullabs/payment-kit 0.1.0

package/dist/esm/contracts/payment_kit/payment_kit.d.ts

@@ -0,0 +1,233 @@
+import { MoveStruct, MoveEnum, MoveTuple } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export declare const Namespace: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+}, "@haneullabs/payment-kit::payment_kit::Namespace">;
+export declare const PaymentRegistry: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    cap_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    config: MoveStruct<{
+        contents: import("@haneullabs/haneul/bcs").BcsType<{
+            key: string;
+            value: import("@haneullabs/bcs").EnumOutputShapeWithKeys<{
+                U64: string;
+                Address: string;
+                String: string;
+                AsciiString: string;
+                Bool: boolean;
+                Bytes: number[];
+                Type: {
+                    name: string;
+                };
+            }, "String" | "U64" | "Address" | "AsciiString" | "Bool" | "Bytes" | "Type">;
+        }[], Iterable<{
+            key: string;
+            value: import("@haneullabs/bcs").EnumInputShape<{
+                U64: string | number | bigint;
+                Address: string | Uint8Array<ArrayBufferLike>;
+                String: string;
+                AsciiString: string;
+                Bool: boolean;
+                Bytes: Iterable<number> & {
+                    length: number;
+                };
+                Type: {
+                    name: string;
+                };
+            }>;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, @haneullabs/payment-kit::config::Value>">;
+    version: import("@haneullabs/haneul/bcs").BcsType<number, number, "u16">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentRegistry">;
+export declare const RegistryAdminCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    registry_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::RegistryAdminCap">;
+/**
+ * Enum representing the type of payment: Ephemeral (one-time) or Registry (tracked
+ * in a registry).
+ */
+export declare const PaymentType: MoveEnum<{
+    Ephemeral: null;
+    Registry: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentType">;
+export declare const PaymentReceipt: MoveStruct<{
+    payment_type: MoveEnum<{
+        Ephemeral: null;
+        Registry: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "@haneullabs/payment-kit::payment_kit::PaymentType">;
+    nonce: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    payment_amount: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    receiver: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    coin_type: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    timestamp_ms: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentReceipt">;
+export declare const PaymentKey: MoveStruct<{
+    nonce: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    payment_amount: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    receiver: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentKey">;
+export declare const PaymentRecord: MoveStruct<{
+    epoch_at_time_of_record: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@haneullabs/payment-kit::payment_kit::PaymentRecord">;
+export declare const BalanceKey: MoveTuple<import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">[], "@haneullabs/payment-kit::payment_kit::BalanceKey">;
+export interface CreateRegistryArguments {
+    namespace: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+}
+export interface CreateRegistryOptions {
+    package?: string;
+    arguments: CreateRegistryArguments | [namespace: RawTransactionArgument<string>, name: RawTransactionArgument<string>];
+}
+/**
+ * Creates a new payment registry with a supplied label. Label is used to derive
+ * the registry's ID.
+ */
+export declare function createRegistry(options: CreateRegistryOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ProcessEphemeralPaymentArguments {
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    coin: RawTransactionArgument<string>;
+    receiver: RawTransactionArgument<string>;
+}
+export interface ProcessEphemeralPaymentOptions {
+    package?: string;
+    arguments: ProcessEphemeralPaymentArguments | [
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        coin: RawTransactionArgument<string>,
+        receiver: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Processes a payment (without the use of a Registry), emitting a payment receipt
+ * event.
+ */
+export declare function processEphemeralPayment(options: ProcessEphemeralPaymentOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ProcessRegistryPaymentArguments {
+    registry: RawTransactionArgument<string>;
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    coin: RawTransactionArgument<string>;
+    receiver: RawTransactionArgument<string | null>;
+}
+export interface ProcessRegistryPaymentOptions {
+    package?: string;
+    arguments: ProcessRegistryPaymentArguments | [
+        registry: RawTransactionArgument<string>,
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        coin: RawTransactionArgument<string>,
+        receiver: RawTransactionArgument<string | null>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Processes a payment via a payment registry, writing a receipt to the registry
+ * and protecting from double spending for the same key.
+ */
+export declare function processRegistryPayment(options: ProcessRegistryPaymentOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface WithdrawFromRegistryArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface WithdrawFromRegistryOptions {
+    package?: string;
+    arguments: WithdrawFromRegistryArguments | [registry: RawTransactionArgument<string>, cap: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/**
+ * If the registry is configured to manage funds, withdraw all funds of the
+ * specified coin from the registry.
+ */
+export declare function withdrawFromRegistry(options: WithdrawFromRegistryOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DeletePaymentRecordArguments {
+    registry: RawTransactionArgument<string>;
+    paymentKey: RawTransactionArgument<string>;
+}
+export interface DeletePaymentRecordOptions {
+    package?: string;
+    arguments: DeletePaymentRecordArguments | [registry: RawTransactionArgument<string>, paymentKey: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Removes an expired Payment Record from the Registry. */
+export declare function deletePaymentRecord(options: DeletePaymentRecordOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CreatePaymentKeyArguments {
+    nonce: RawTransactionArgument<string>;
+    paymentAmount: RawTransactionArgument<number | bigint>;
+    receiver: RawTransactionArgument<string>;
+}
+export interface CreatePaymentKeyOptions {
+    package?: string;
+    arguments: CreatePaymentKeyArguments | [
+        nonce: RawTransactionArgument<string>,
+        paymentAmount: RawTransactionArgument<number | bigint>,
+        receiver: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/** Creates a PaymentKey from payment parameters. */
+export declare function createPaymentKey(options: CreatePaymentKeyOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SetConfigEpochExpirationDurationArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    epochExpirationDuration: RawTransactionArgument<number | bigint>;
+}
+export interface SetConfigEpochExpirationDurationOptions {
+    package?: string;
+    arguments: SetConfigEpochExpirationDurationArguments | [
+        registry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        epochExpirationDuration: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Sets the epoch expiration duration configuration for the registry. If set,
+ * payment records will expire after the specified number of epochs. If not set,
+ * payment records will expire 30 epochs after their creation.
+ */
+export declare function setConfigEpochExpirationDuration(options: SetConfigEpochExpirationDurationOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SetConfigRegistryManagedFundsArguments {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    registryManagedFunds: RawTransactionArgument<boolean>;
+}
+export interface SetConfigRegistryManagedFundsOptions {
+    package?: string;
+    arguments: SetConfigRegistryManagedFundsArguments | [
+        registry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        registryManagedFunds: RawTransactionArgument<boolean>
+    ];
+}
+/**
+ * Sets whether the registry should manage funds itself. If true, payments
+ * processed via the registry will be collected into the registry's balance. If
+ * false, payments will be transferred directly to the specified receiver.
+ */
+export declare function setConfigRegistryManagedFunds(options: SetConfigRegistryManagedFundsOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ShareArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [registry: RawTransactionArgument<string>];
+}
+/**
+ * Enforce that a registry will always be shared.
+ *
+ * # Parameters
+ *
+ * - `registry` - The PaymentRegistry to share
+ */
+export declare function share(options: ShareOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;

package/dist/esm/contracts/payment_kit/payment_kit.js

@@ -0,0 +1,222 @@
+import { MoveStruct, MoveEnum, MoveTuple, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as object from "./deps/sui/object.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as config from "./config.js";
+const $moduleName = "@haneullabs/payment-kit::payment_kit";
+const Namespace = new MoveStruct({
+  name: `${$moduleName}::Namespace`,
+  fields: {
+    id: object.UID
+  }
+});
+const PaymentRegistry = new MoveStruct({
+  name: `${$moduleName}::PaymentRegistry`,
+  fields: {
+    id: object.UID,
+    cap_id: bcs.Address,
+    config: vec_map.VecMap(bcs.string(), config.Value),
+    version: bcs.u16()
+  }
+});
+const RegistryAdminCap = new MoveStruct({
+  name: `${$moduleName}::RegistryAdminCap`,
+  fields: {
+    id: object.UID,
+    registry_id: bcs.Address
+  }
+});
+const PaymentType = new MoveEnum({
+  name: `${$moduleName}::PaymentType`,
+  fields: {
+    Ephemeral: null,
+    Registry: bcs.Address
+  }
+});
+const PaymentReceipt = new MoveStruct({
+  name: `${$moduleName}::PaymentReceipt`,
+  fields: {
+    payment_type: PaymentType,
+    nonce: bcs.string(),
+    payment_amount: bcs.u64(),
+    receiver: bcs.Address,
+    coin_type: bcs.string(),
+    timestamp_ms: bcs.u64()
+  }
+});
+const PaymentKey = new MoveStruct({
+  name: `${$moduleName}::PaymentKey`,
+  fields: {
+    nonce: bcs.string(),
+    payment_amount: bcs.u64(),
+    receiver: bcs.Address
+  }
+});
+const PaymentRecord = new MoveStruct({
+  name: `${$moduleName}::PaymentRecord`,
+  fields: {
+    epoch_at_time_of_record: bcs.u64()
+  }
+});
+const BalanceKey = new MoveTuple({
+  name: `${$moduleName}::BalanceKey`,
+  fields: [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: 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: 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: 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: 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: 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: 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: 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: 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+export {
+  BalanceKey,
+  Namespace,
+  PaymentKey,
+  PaymentReceipt,
+  PaymentRecord,
+  PaymentRegistry,
+  PaymentType,
+  RegistryAdminCap,
+  createPaymentKey,
+  createRegistry,
+  deletePaymentRecord,
+  processEphemeralPayment,
+  processRegistryPayment,
+  setConfigEpochExpirationDuration,
+  setConfigRegistryManagedFunds,
+  share,
+  withdrawFromRegistry
+};
+//# sourceMappingURL=payment_kit.js.map

package/dist/esm/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/esm/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/esm/contracts/utils/index.js

@@ -0,0 +1,131 @@
+import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from "@haneullabs/haneul/bcs";
+import { normalizeHaneulAddress } from "@haneullabs/haneul/utils";
+import { isArgument } from "@haneullabs/haneul/transactions";
+const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress("0x1");
+const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress("0x2");
+const HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress("0x3");
+function getPureBcsSchema(typeTag) {
+  const parsedTag = typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+  if ("u8" in parsedTag) {
+    return bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return bcs.U256;
+  } else if ("address" in parsedTag) {
+    return bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = normalizeHaneulAddress(parsedTag.struct.address);
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
+        return bcs.String;
+      }
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const type = getPureBcsSchema(structTag.typeParams[0]);
+        return type ? bcs.option(type) : null;
+      }
+    }
+    if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === "Object" && structTag.name === "ID") {
+      return 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" || 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 BcsStruct {
+}
+class MoveEnum extends BcsEnum {
+}
+class MoveTuple extends BcsTuple {
+}
+function stringify(val) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val2) => val2);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+export {
+  MoveEnum,
+  MoveStruct,
+  MoveTuple,
+  getPureBcsSchema,
+  normalizeMoveArguments
+};
+//# sourceMappingURL=index.js.map