@boostxyz/sdk 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transfers.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("viem");var n=(e=>(e[e.ETH=0]="ETH",e[e.ERC20=1]="ERC20",e[e.ERC1155=2]="ERC1155",e))(n||{});const p=({assetType:e,address:r,target:t,data:s})=>a.encodeAbiParameters([{type:"uint8",name:"assetType"},{type:"address",name:"asset"},{type:"address",name:"target"},{type:"bytes",name:"data"}],[e,r,t,s]);function d({tokenId:e,amount:r}){return a.encodeAbiParameters(a.parseAbiParameters(["ERC1155Payload payload","struct ERC1155Payload { uint256 tokenId; uint256 amount; bytes data; }"]),[{tokenId:e,amount:r,data:"0x"}])}function o({tokenId:e,amount:r,asset:t,target:s}){return a.encodeAbiParameters(a.parseAbiParameters(["Transfer request","struct Transfer { uint8 assetType; address asset; address target; bytes data; }"]),[{assetType:2,asset:t,data:d({tokenId:e,amount:r}),target:s}])}function u({amount:e}){return a.encodeAbiParameters(a.parseAbiParameters(["FungiblePayload payload","struct FungiblePayload { uint256 amount; }"]),[{amount:e}])}function i({amount:e,asset:r,target:t}){return a.encodeAbiParameters(a.parseAbiParameters(["Transfer request","struct Transfer { uint8 assetType; address asset; address target; bytes data; }"]),[{assetType:r==a.zeroAddress?0:1,asset:r,data:u({amount:e}),target:t}])}exports.AssetType=n;exports.prepareERC1155Payload=d;exports.prepareERC1155Transfer=o;exports.prepareFungiblePayload=u;exports.prepareFungibleTransfer=i;exports.prepareTransferPayload=p;
+//# sourceMappingURL=transfers.cjs.map

package/dist/transfers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfers.cjs","sources":["../src/transfers.ts"],"sourcesContent":["import {\n  type Address,\n  type Hex,\n  encodeAbiParameters,\n  parseAbiParameters,\n  zeroAddress,\n} from 'viem';\n\n/**\n * The various types of assets supported in Budgets and Incentives.\n *\n * @export\n * @enum {number}\n */\nexport enum AssetType {\n  ETH,\n  ERC20,\n  ERC1155,\n}\n\n/**\n * Object representation of a generic `Transfer` struct.\n *\n * @export\n * @interface TransferPayload\n * @typedef {TransferPayload}\n */\nexport interface TransferPayload {\n  /**\n   * The type of the asset being transferred.\n   *\n   * @type {AssetType}\n   */\n  assetType: AssetType;\n  /**\n   * The address of the asset to transfer, zero address for ETH.\n   *\n   * @type {Address}\n   */\n  address: Address;\n  /**\n   * The account from which to transfer the assets.\n   *\n   * @type {Address}\n   */\n  target: Address;\n  /**\n   * An encoded {@link FungiblePayload}, use {@link prepareFungiblePayload} to construct.\n   *\n   * @type {Hex}\n   */\n  data: Hex;\n}\n\n/**\n * Encodes parameters for transferring the transfer of Fungible and ERC1155 assets, used for {@link Budget} operations.\n * Typically you'd use {@link prepareFungibleTransfer} or {@link prepareERC1155Transfer}\n *\n * @param {TransferPayload} param0\n * @param {AssetType} param0.assetType - The asset type being transferred.\n * @param {Address} param0.address - The address of the asset, use zero address for ETH transfers.\n * @param {Address} param0.target - The address of the account being transferred from\n * @param {Hex} param0.data - Use {@link prepareFungiblePayload} to properly encode an amount to transfer\n * @returns {Hex}\n */\nexport const prepareTransferPayload = ({\n  assetType,\n  address,\n  target,\n  data,\n}: TransferPayload) => {\n  return encodeAbiParameters(\n    [\n      { type: 'uint8', name: 'assetType' },\n      { type: 'address', name: 'asset' },\n      { type: 'address', name: 'target' },\n      { type: 'bytes', name: 'data' },\n    ],\n    [assetType, address, target, data],\n  );\n};\n\n/**\n * Object representation of\n *\n * @export\n * @interface ERC1155Payload\n * @typedef {ERC1155Payload}\n */\nexport interface ERC1155Payload {\n  /**\n   * The ERC1155 token ID for the incentive\n   *\n   * @type {bigint}\n   */\n  tokenId: bigint;\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n}\n\n/**\n * Given a token ID and amount, properly encode a `ERC1155Incentive.ERC1155Payload` for use with {@link ERC1155Incentive} initialization.\n *\n * @export\n * @param {ERC1155Payload} param0\n * @param {bigint} param0.tokenId - The ERC1155 token ID for the incentive\n * @param {bigint} param0.amount - The amount to transfer\n * @returns {Hex}\n */\nexport function prepareERC1155Payload({ tokenId, amount }: ERC1155Payload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'ERC1155Payload payload',\n      'struct ERC1155Payload { uint256 tokenId; uint256 amount; bytes data; }',\n    ]),\n    [{ tokenId, amount, data: '0x' }],\n  );\n}\n\n/**\n * An object representation of the `Budget.Transfer` contract struct for transfers of ERC1155 assets.\n *\n * @export\n * @interface ERC1155TransferPayload\n * @typedef {ERC1155TransferPayload}\n */\nexport interface ERC1155TransferPayload {\n  /**\n   * The token ID to transfer\n   *\n   * @type {bigint}\n   */\n  tokenId: bigint;\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n  /**\n   * The address of the asset to target\n   *\n   * @type {Address}\n   */\n  asset: Address;\n  /**\n   * The account to transfer from\n   *\n   * @type {Address}\n   */\n  target: Address;\n}\n\n/**\n * Encodes parameters for transferring the transfer of ERC1155 assets, used for {@link Budget} operations.\n * The caller must have already approved the contract to transfer the asset.\n *\n * @export\n * @param {ERC1155TransferPayload} param0\n * @param {bigint} param0.tokenId - The token ID to transfer\n * @param {bigint} param0.amount - The amount to transfer\n * @param {Address} param0.asset - The address of the asset to target\n * @param {Address} param0.target - The account to transfer from\n * @returns {Hex}\n */\nexport function prepareERC1155Transfer({\n  tokenId,\n  amount,\n  asset,\n  target,\n}: ERC1155TransferPayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'Transfer request',\n      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',\n    ]),\n    [\n      {\n        assetType: AssetType.ERC1155,\n        asset,\n        data: prepareERC1155Payload({ tokenId, amount }),\n        target,\n      },\n    ],\n  );\n}\n\n/**\n * An object representation of the `FungiblePayload` struct\n *\n * @export\n * @interface FungiblePayload\n * @typedef {FungiblePayload}\n */\nexport interface FungiblePayload {\n  /**\n   * The amount being transferred\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n}\n\n/**\n * Encodes an amount for the `FungiblePayload` struct\n *\n * @export\n * @param {FungiblePayload} param0\n * @param {bigint} param0.amount - The amount being transferred\n * @returns {Hex}\n */\nexport function prepareFungiblePayload({ amount }: FungiblePayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'FungiblePayload payload',\n      'struct FungiblePayload { uint256 amount; }',\n    ]),\n    [{ amount }],\n  );\n}\n\n/**\n * An object representation of the `Budget.Transfer` contract struct for transfers of fungible assets.\n *\n * @export\n * @interface FungibleTransferPayload\n * @typedef {FungibleTransferPayload}\n */\nexport interface FungibleTransferPayload {\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n  /**\n   * The address of the asset. Use zero address for ETH transfers.\n   *\n   * @type {Address}\n   */\n  asset: Address;\n  /**\n   * The account to transfer from\n   *\n   * @type {Address}\n   */\n  target: Address;\n}\n\n/**\n * Encodes parameters for a Fungible transfer, used for Budget allocations.\n * The caller must have already approved the contract to transfer the asset.\n *\n * @export\n * @param {FungibleTransferPayload} param0\n * @param {bigint} param0.amount - The amount to transfer\n * @param {Address} param0.asset - The address of the asset. Use zero address for ETH transfers.\n * @param {Address} param0.target - The account to transfer from\n * @returns {Hex}\n */\nexport function prepareFungibleTransfer({\n  amount,\n  asset,\n  target,\n}: FungibleTransferPayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'Transfer request',\n      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',\n    ]),\n    [\n      {\n        assetType: asset == zeroAddress ? AssetType.ETH : AssetType.ERC20,\n        asset,\n        data: prepareFungiblePayload({ amount }),\n        target,\n      },\n    ],\n  );\n}\n"],"names":["AssetType","AssetType2","prepareTransferPayload","assetType","address","target","data","encodeAbiParameters","prepareERC1155Payload","tokenId","amount","parseAbiParameters","prepareERC1155Transfer","asset","prepareFungiblePayload","prepareFungibleTransfer","zeroAddress"],"mappings":"wGAcY,IAAAA,GAAAA,IACVA,EAAAC,EAAA,IAAA,CAAA,EAAA,MACAD,EAAAC,EAAA,MAAA,CAAA,EAAA,QACAD,EAAAC,EAAA,QAAA,CAAA,EAAA,UAHUD,IAAAA,GAAA,CAAA,CAAA,EAmDL,MAAME,EAAyB,CAAC,CACrC,UAAAC,EACA,QAAAC,EACA,OAAAC,EACA,KAAAC,CACF,IACSC,EAAA,oBACL,CACE,CAAE,KAAM,QAAS,KAAM,WAAY,EACnC,CAAE,KAAM,UAAW,KAAM,OAAQ,EACjC,CAAE,KAAM,UAAW,KAAM,QAAS,EAClC,CAAE,KAAM,QAAS,KAAM,MAAO,CAChC,EACA,CAACJ,EAAWC,EAASC,EAAQC,CAAI,CAAA,EAmC9B,SAASE,EAAsB,CAAE,QAAAC,EAAS,OAAAC,GAA0B,CAClE,OAAAH,EAAA,oBACLI,qBAAmB,CACjB,yBACA,wEAAA,CACD,EACD,CAAC,CAAE,QAAAF,EAAS,OAAAC,EAAQ,KAAM,KAAM,CAAA,CAEpC,CAgDO,SAASE,EAAuB,CACrC,QAAAH,EACA,OAAAC,EACA,MAAAG,EACA,OAAAR,CACF,EAA2B,CAClB,OAAAE,EAAA,oBACLI,qBAAmB,CACjB,mBACA,iFAAA,CACD,EACD,CACE,CACE,UAAW,EACX,MAAAE,EACA,KAAML,EAAsB,CAAE,QAAAC,EAAS,OAAAC,EAAQ,EAC/C,OAAAL,CACF,CACF,CAAA,CAEJ,CA0BgB,SAAAS,EAAuB,CAAE,OAAAJ,GAA2B,CAC3D,OAAAH,EAAA,oBACLI,qBAAmB,CACjB,0BACA,4CAAA,CACD,EACD,CAAC,CAAE,OAAAD,CAAA,CAAQ,CAAA,CAEf,CAyCO,SAASK,EAAwB,CACtC,OAAAL,EACA,MAAAG,EACA,OAAAR,CACF,EAA4B,CACnB,OAAAE,EAAA,oBACLI,qBAAmB,CACjB,mBACA,iFAAA,CACD,EACD,CACE,CACE,UAAWE,GAASG,cAAc,EAAgB,EAClD,MAAAH,EACA,KAAMC,EAAuB,CAAE,OAAAJ,EAAQ,EACvC,OAAAL,CACF,CACF,CAAA,CAEJ"}

package/dist/transfers.d.ts

@@ -0,0 +1,198 @@
+import { type Address, type Hex } from 'viem';
+/**
+ * The various types of assets supported in Budgets and Incentives.
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum AssetType {
+    ETH = 0,
+    ERC20 = 1,
+    ERC1155 = 2
+}
+/**
+ * Object representation of a generic `Transfer` struct.
+ *
+ * @export
+ * @interface TransferPayload
+ * @typedef {TransferPayload}
+ */
+export interface TransferPayload {
+    /**
+     * The type of the asset being transferred.
+     *
+     * @type {AssetType}
+     */
+    assetType: AssetType;
+    /**
+     * The address of the asset to transfer, zero address for ETH.
+     *
+     * @type {Address}
+     */
+    address: Address;
+    /**
+     * The account from which to transfer the assets.
+     *
+     * @type {Address}
+     */
+    target: Address;
+    /**
+     * An encoded {@link FungiblePayload}, use {@link prepareFungiblePayload} to construct.
+     *
+     * @type {Hex}
+     */
+    data: Hex;
+}
+/**
+ * Encodes parameters for transferring the transfer of Fungible and ERC1155 assets, used for {@link Budget} operations.
+ * Typically you'd use {@link prepareFungibleTransfer} or {@link prepareERC1155Transfer}
+ *
+ * @param {TransferPayload} param0
+ * @param {AssetType} param0.assetType - The asset type being transferred.
+ * @param {Address} param0.address - The address of the asset, use zero address for ETH transfers.
+ * @param {Address} param0.target - The address of the account being transferred from
+ * @param {Hex} param0.data - Use {@link prepareFungiblePayload} to properly encode an amount to transfer
+ * @returns {Hex}
+ */
+export declare const prepareTransferPayload: ({ assetType, address, target, data, }: TransferPayload) => `0x${string}`;
+/**
+ * Object representation of
+ *
+ * @export
+ * @interface ERC1155Payload
+ * @typedef {ERC1155Payload}
+ */
+export interface ERC1155Payload {
+    /**
+     * The ERC1155 token ID for the incentive
+     *
+     * @type {bigint}
+     */
+    tokenId: bigint;
+    /**
+     * The amount to transfer
+     *
+     * @type {bigint}
+     */
+    amount: bigint;
+}
+/**
+ * Given a token ID and amount, properly encode a `ERC1155Incentive.ERC1155Payload` for use with {@link ERC1155Incentive} initialization.
+ *
+ * @export
+ * @param {ERC1155Payload} param0
+ * @param {bigint} param0.tokenId - The ERC1155 token ID for the incentive
+ * @param {bigint} param0.amount - The amount to transfer
+ * @returns {Hex}
+ */
+export declare function prepareERC1155Payload({ tokenId, amount }: ERC1155Payload): `0x${string}`;
+/**
+ * An object representation of the `Budget.Transfer` contract struct for transfers of ERC1155 assets.
+ *
+ * @export
+ * @interface ERC1155TransferPayload
+ * @typedef {ERC1155TransferPayload}
+ */
+export interface ERC1155TransferPayload {
+    /**
+     * The token ID to transfer
+     *
+     * @type {bigint}
+     */
+    tokenId: bigint;
+    /**
+     * The amount to transfer
+     *
+     * @type {bigint}
+     */
+    amount: bigint;
+    /**
+     * The address of the asset to target
+     *
+     * @type {Address}
+     */
+    asset: Address;
+    /**
+     * The account to transfer from
+     *
+     * @type {Address}
+     */
+    target: Address;
+}
+/**
+ * Encodes parameters for transferring the transfer of ERC1155 assets, used for {@link Budget} operations.
+ * The caller must have already approved the contract to transfer the asset.
+ *
+ * @export
+ * @param {ERC1155TransferPayload} param0
+ * @param {bigint} param0.tokenId - The token ID to transfer
+ * @param {bigint} param0.amount - The amount to transfer
+ * @param {Address} param0.asset - The address of the asset to target
+ * @param {Address} param0.target - The account to transfer from
+ * @returns {Hex}
+ */
+export declare function prepareERC1155Transfer({ tokenId, amount, asset, target, }: ERC1155TransferPayload): `0x${string}`;
+/**
+ * An object representation of the `FungiblePayload` struct
+ *
+ * @export
+ * @interface FungiblePayload
+ * @typedef {FungiblePayload}
+ */
+export interface FungiblePayload {
+    /**
+     * The amount being transferred
+     *
+     * @type {bigint}
+     */
+    amount: bigint;
+}
+/**
+ * Encodes an amount for the `FungiblePayload` struct
+ *
+ * @export
+ * @param {FungiblePayload} param0
+ * @param {bigint} param0.amount - The amount being transferred
+ * @returns {Hex}
+ */
+export declare function prepareFungiblePayload({ amount }: FungiblePayload): `0x${string}`;
+/**
+ * An object representation of the `Budget.Transfer` contract struct for transfers of fungible assets.
+ *
+ * @export
+ * @interface FungibleTransferPayload
+ * @typedef {FungibleTransferPayload}
+ */
+export interface FungibleTransferPayload {
+    /**
+     * The amount to transfer
+     *
+     * @type {bigint}
+     */
+    amount: bigint;
+    /**
+     * The address of the asset. Use zero address for ETH transfers.
+     *
+     * @type {Address}
+     */
+    asset: Address;
+    /**
+     * The account to transfer from
+     *
+     * @type {Address}
+     */
+    target: Address;
+}
+/**
+ * Encodes parameters for a Fungible transfer, used for Budget allocations.
+ * The caller must have already approved the contract to transfer the asset.
+ *
+ * @export
+ * @param {FungibleTransferPayload} param0
+ * @param {bigint} param0.amount - The amount to transfer
+ * @param {Address} param0.asset - The address of the asset. Use zero address for ETH transfers.
+ * @param {Address} param0.target - The account to transfer from
+ * @returns {Hex}
+ */
+export declare function prepareFungibleTransfer({ amount, asset, target, }: FungibleTransferPayload): `0x${string}`;
+//# sourceMappingURL=transfers.d.ts.map

package/dist/transfers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfers.d.ts","sourceRoot":"","sources":["../src/transfers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,GAAG,EAIT,MAAM,MAAM,CAAC;AAEd;;;;;GAKG;AACH,oBAAY,SAAS;IACnB,GAAG,IAAA;IACH,KAAK,IAAA;IACL,OAAO,IAAA;CACR;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,SAAS,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,IAAI,EAAE,GAAG,CAAC;CACX;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,0CAKhC,eAAe,kBAUjB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,cAAc,iBAQxE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,GACP,EAAE,sBAAsB,iBAexB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,iBAQjE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,KAAK,EACL,MAAM,GACP,EAAE,uBAAuB,iBAezB"}

package/dist/transfers.js

@@ -0,0 +1,84 @@
+import { encodeAbiParameters as t, parseAbiParameters as n, zeroAddress as d } from "viem";
+var u = /* @__PURE__ */ ((a) => (a[a.ETH = 0] = "ETH", a[a.ERC20 = 1] = "ERC20", a[a.ERC1155 = 2] = "ERC1155", a))(u || {});
+const y = ({
+  assetType: a,
+  address: e,
+  target: r,
+  data: s
+}) => t(
+  [
+    { type: "uint8", name: "assetType" },
+    { type: "address", name: "asset" },
+    { type: "address", name: "target" },
+    { type: "bytes", name: "data" }
+  ],
+  [a, e, r, s]
+);
+function o({ tokenId: a, amount: e }) {
+  return t(
+    n([
+      "ERC1155Payload payload",
+      "struct ERC1155Payload { uint256 tokenId; uint256 amount; bytes data; }"
+    ]),
+    [{ tokenId: a, amount: e, data: "0x" }]
+  );
+}
+function l({
+  tokenId: a,
+  amount: e,
+  asset: r,
+  target: s
+}) {
+  return t(
+    n([
+      "Transfer request",
+      "struct Transfer { uint8 assetType; address asset; address target; bytes data; }"
+    ]),
+    [
+      {
+        assetType: 2,
+        asset: r,
+        data: o({ tokenId: a, amount: e }),
+        target: s
+      }
+    ]
+  );
+}
+function p({ amount: a }) {
+  return t(
+    n([
+      "FungiblePayload payload",
+      "struct FungiblePayload { uint256 amount; }"
+    ]),
+    [{ amount: a }]
+  );
+}
+function f({
+  amount: a,
+  asset: e,
+  target: r
+}) {
+  return t(
+    n([
+      "Transfer request",
+      "struct Transfer { uint8 assetType; address asset; address target; bytes data; }"
+    ]),
+    [
+      {
+        assetType: e == d ? 0 : 1,
+        asset: e,
+        data: p({ amount: a }),
+        target: r
+      }
+    ]
+  );
+}
+export {
+  u as AssetType,
+  o as prepareERC1155Payload,
+  l as prepareERC1155Transfer,
+  p as prepareFungiblePayload,
+  f as prepareFungibleTransfer,
+  y as prepareTransferPayload
+};
+//# sourceMappingURL=transfers.js.map

package/dist/transfers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfers.js","sources":["../src/transfers.ts"],"sourcesContent":["import {\n  type Address,\n  type Hex,\n  encodeAbiParameters,\n  parseAbiParameters,\n  zeroAddress,\n} from 'viem';\n\n/**\n * The various types of assets supported in Budgets and Incentives.\n *\n * @export\n * @enum {number}\n */\nexport enum AssetType {\n  ETH,\n  ERC20,\n  ERC1155,\n}\n\n/**\n * Object representation of a generic `Transfer` struct.\n *\n * @export\n * @interface TransferPayload\n * @typedef {TransferPayload}\n */\nexport interface TransferPayload {\n  /**\n   * The type of the asset being transferred.\n   *\n   * @type {AssetType}\n   */\n  assetType: AssetType;\n  /**\n   * The address of the asset to transfer, zero address for ETH.\n   *\n   * @type {Address}\n   */\n  address: Address;\n  /**\n   * The account from which to transfer the assets.\n   *\n   * @type {Address}\n   */\n  target: Address;\n  /**\n   * An encoded {@link FungiblePayload}, use {@link prepareFungiblePayload} to construct.\n   *\n   * @type {Hex}\n   */\n  data: Hex;\n}\n\n/**\n * Encodes parameters for transferring the transfer of Fungible and ERC1155 assets, used for {@link Budget} operations.\n * Typically you'd use {@link prepareFungibleTransfer} or {@link prepareERC1155Transfer}\n *\n * @param {TransferPayload} param0\n * @param {AssetType} param0.assetType - The asset type being transferred.\n * @param {Address} param0.address - The address of the asset, use zero address for ETH transfers.\n * @param {Address} param0.target - The address of the account being transferred from\n * @param {Hex} param0.data - Use {@link prepareFungiblePayload} to properly encode an amount to transfer\n * @returns {Hex}\n */\nexport const prepareTransferPayload = ({\n  assetType,\n  address,\n  target,\n  data,\n}: TransferPayload) => {\n  return encodeAbiParameters(\n    [\n      { type: 'uint8', name: 'assetType' },\n      { type: 'address', name: 'asset' },\n      { type: 'address', name: 'target' },\n      { type: 'bytes', name: 'data' },\n    ],\n    [assetType, address, target, data],\n  );\n};\n\n/**\n * Object representation of\n *\n * @export\n * @interface ERC1155Payload\n * @typedef {ERC1155Payload}\n */\nexport interface ERC1155Payload {\n  /**\n   * The ERC1155 token ID for the incentive\n   *\n   * @type {bigint}\n   */\n  tokenId: bigint;\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n}\n\n/**\n * Given a token ID and amount, properly encode a `ERC1155Incentive.ERC1155Payload` for use with {@link ERC1155Incentive} initialization.\n *\n * @export\n * @param {ERC1155Payload} param0\n * @param {bigint} param0.tokenId - The ERC1155 token ID for the incentive\n * @param {bigint} param0.amount - The amount to transfer\n * @returns {Hex}\n */\nexport function prepareERC1155Payload({ tokenId, amount }: ERC1155Payload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'ERC1155Payload payload',\n      'struct ERC1155Payload { uint256 tokenId; uint256 amount; bytes data; }',\n    ]),\n    [{ tokenId, amount, data: '0x' }],\n  );\n}\n\n/**\n * An object representation of the `Budget.Transfer` contract struct for transfers of ERC1155 assets.\n *\n * @export\n * @interface ERC1155TransferPayload\n * @typedef {ERC1155TransferPayload}\n */\nexport interface ERC1155TransferPayload {\n  /**\n   * The token ID to transfer\n   *\n   * @type {bigint}\n   */\n  tokenId: bigint;\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n  /**\n   * The address of the asset to target\n   *\n   * @type {Address}\n   */\n  asset: Address;\n  /**\n   * The account to transfer from\n   *\n   * @type {Address}\n   */\n  target: Address;\n}\n\n/**\n * Encodes parameters for transferring the transfer of ERC1155 assets, used for {@link Budget} operations.\n * The caller must have already approved the contract to transfer the asset.\n *\n * @export\n * @param {ERC1155TransferPayload} param0\n * @param {bigint} param0.tokenId - The token ID to transfer\n * @param {bigint} param0.amount - The amount to transfer\n * @param {Address} param0.asset - The address of the asset to target\n * @param {Address} param0.target - The account to transfer from\n * @returns {Hex}\n */\nexport function prepareERC1155Transfer({\n  tokenId,\n  amount,\n  asset,\n  target,\n}: ERC1155TransferPayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'Transfer request',\n      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',\n    ]),\n    [\n      {\n        assetType: AssetType.ERC1155,\n        asset,\n        data: prepareERC1155Payload({ tokenId, amount }),\n        target,\n      },\n    ],\n  );\n}\n\n/**\n * An object representation of the `FungiblePayload` struct\n *\n * @export\n * @interface FungiblePayload\n * @typedef {FungiblePayload}\n */\nexport interface FungiblePayload {\n  /**\n   * The amount being transferred\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n}\n\n/**\n * Encodes an amount for the `FungiblePayload` struct\n *\n * @export\n * @param {FungiblePayload} param0\n * @param {bigint} param0.amount - The amount being transferred\n * @returns {Hex}\n */\nexport function prepareFungiblePayload({ amount }: FungiblePayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'FungiblePayload payload',\n      'struct FungiblePayload { uint256 amount; }',\n    ]),\n    [{ amount }],\n  );\n}\n\n/**\n * An object representation of the `Budget.Transfer` contract struct for transfers of fungible assets.\n *\n * @export\n * @interface FungibleTransferPayload\n * @typedef {FungibleTransferPayload}\n */\nexport interface FungibleTransferPayload {\n  /**\n   * The amount to transfer\n   *\n   * @type {bigint}\n   */\n  amount: bigint;\n  /**\n   * The address of the asset. Use zero address for ETH transfers.\n   *\n   * @type {Address}\n   */\n  asset: Address;\n  /**\n   * The account to transfer from\n   *\n   * @type {Address}\n   */\n  target: Address;\n}\n\n/**\n * Encodes parameters for a Fungible transfer, used for Budget allocations.\n * The caller must have already approved the contract to transfer the asset.\n *\n * @export\n * @param {FungibleTransferPayload} param0\n * @param {bigint} param0.amount - The amount to transfer\n * @param {Address} param0.asset - The address of the asset. Use zero address for ETH transfers.\n * @param {Address} param0.target - The account to transfer from\n * @returns {Hex}\n */\nexport function prepareFungibleTransfer({\n  amount,\n  asset,\n  target,\n}: FungibleTransferPayload) {\n  return encodeAbiParameters(\n    parseAbiParameters([\n      'Transfer request',\n      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',\n    ]),\n    [\n      {\n        assetType: asset == zeroAddress ? AssetType.ETH : AssetType.ERC20,\n        asset,\n        data: prepareFungiblePayload({ amount }),\n        target,\n      },\n    ],\n  );\n}\n"],"names":["AssetType","AssetType2","prepareTransferPayload","assetType","address","target","data","encodeAbiParameters","prepareERC1155Payload","tokenId","amount","parseAbiParameters","prepareERC1155Transfer","asset","prepareFungiblePayload","prepareFungibleTransfer","zeroAddress"],"mappings":";AAcY,IAAAA,sBAAAA,OACVA,EAAAC,EAAA,MAAA,CAAA,IAAA,OACAD,EAAAC,EAAA,QAAA,CAAA,IAAA,SACAD,EAAAC,EAAA,UAAA,CAAA,IAAA,WAHUD,IAAAA,KAAA,CAAA,CAAA;AAmDL,MAAME,IAAyB,CAAC;AAAA,EACrC,WAAAC;AAAA,EACA,SAAAC;AAAA,EACA,QAAAC;AAAA,EACA,MAAAC;AACF,MACSC;AAAA,EACL;AAAA,IACE,EAAE,MAAM,SAAS,MAAM,YAAY;AAAA,IACnC,EAAE,MAAM,WAAW,MAAM,QAAQ;AAAA,IACjC,EAAE,MAAM,WAAW,MAAM,SAAS;AAAA,IAClC,EAAE,MAAM,SAAS,MAAM,OAAO;AAAA,EAChC;AAAA,EACA,CAACJ,GAAWC,GAASC,GAAQC,CAAI;AAAA;AAmC9B,SAASE,EAAsB,EAAE,SAAAC,GAAS,QAAAC,KAA0B;AAClE,SAAAH;AAAA,IACLI,EAAmB;AAAA,MACjB;AAAA,MACA;AAAA,IAAA,CACD;AAAA,IACD,CAAC,EAAE,SAAAF,GAAS,QAAAC,GAAQ,MAAM,MAAM;AAAA,EAAA;AAEpC;AAgDO,SAASE,EAAuB;AAAA,EACrC,SAAAH;AAAA,EACA,QAAAC;AAAA,EACA,OAAAG;AAAA,EACA,QAAAR;AACF,GAA2B;AAClB,SAAAE;AAAA,IACLI,EAAmB;AAAA,MACjB;AAAA,MACA;AAAA,IAAA,CACD;AAAA,IACD;AAAA,MACE;AAAA,QACE,WAAW;AAAA,QACX,OAAAE;AAAA,QACA,MAAML,EAAsB,EAAE,SAAAC,GAAS,QAAAC,GAAQ;AAAA,QAC/C,QAAAL;AAAA,MACF;AAAA,IACF;AAAA,EAAA;AAEJ;AA0BgB,SAAAS,EAAuB,EAAE,QAAAJ,KAA2B;AAC3D,SAAAH;AAAA,IACLI,EAAmB;AAAA,MACjB;AAAA,MACA;AAAA,IAAA,CACD;AAAA,IACD,CAAC,EAAE,QAAAD,EAAA,CAAQ;AAAA,EAAA;AAEf;AAyCO,SAASK,EAAwB;AAAA,EACtC,QAAAL;AAAA,EACA,OAAAG;AAAA,EACA,QAAAR;AACF,GAA4B;AACnB,SAAAE;AAAA,IACLI,EAAmB;AAAA,MACjB;AAAA,MACA;AAAA,IAAA,CACD;AAAA,IACD;AAAA,MACE;AAAA,QACE,WAAWE,KAASG,IAAc,IAAgB;AAAA,QAClD,OAAAH;AAAA,QACA,MAAMC,EAAuB,EAAE,QAAAJ,GAAQ;AAAA,QACvC,QAAAL;AAAA,MACF;AAAA,IACF;AAAA,EAAA;AAEJ;"}

package/dist/utils.cjs

@@ -1 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const M=require("@wagmi/core"),n=require("viem"),Y=require("viem/accounts"),J=require("./errors.cjs");var K=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{},R={exports:{}};(function(e,a){(function(r,i){e.exports=i(r,1),a.LibZip=e.exports.LibZip,a.ERC1967Factory=e.exports.ERC1967Factory})(typeof window<"u"?window:K,function(r,i){var c={},P={};c.LibZip=P;function g(o){if((typeof o=="string"||o instanceof String)&&(o=o.match(/^[\s\uFEFF\xA0]*(0[Xx])?([0-9A-Fa-f]*)[\s\uFEFF\xA0]*$/))){if(o[2].length%2)throw new Error("Hex string length must be a multiple of 2.");return o[2]}throw new Error("Data must be a hex string.")}function E(o){return(o|256).toString(16).slice(1)}function A(o,s){return parseInt(o.substr(s,2),16)}function w(o){for(var s=[],t=0;t<o.length;t+=2)s.push(A(o,t));return s}function T(o){for(var s="0x",t=0;t<o.length;s+=E(o[t++]));return s}P.flzCompress=function(o){var s=w(g(o)),t=s.length-4,p=[],d=[],y=0,l=2,u=0,m,h,N,C,B,f,v,F,x,S;function D(b){return s[b]|s[++b]<<8|s[++b]<<16}function L(b){return 2654435769*b>>19&8191}function V(b,O){for(;b>=32;)for(d[u++]=31,m=32;m--;b--)d[u++]=s[O++];if(b)for(d[u++]=b-1;b--;)d[u++]=s[O++]}for(;l<t-9;){do v=p[N=L(h=D(l))]||0,B=(C=(p[N]=l)-v)<8192?D(v):16777216;while(l<t-9&&l++&&h!=B);if(l>=t-9)break;for(--l>y&&V(l-y,y),f=0,F=v+3,x=l+3,S=t-x;f<S;f++)S*=s[F+f]===s[x+f];for(l+=f,--C;f>262;f-=262)d[u++]=224+(C>>8),d[u++]=253,d[u++]=C&255;f<7?(d[u++]=(f<<5)+(C>>8),d[u++]=C&255):(d[u++]=224+(C>>8),d[u++]=f-7,d[u++]=C&255),p[L(D(l))]=l++,p[L(D(l))]=l++,y=l}return V(t+4-y,y),T(d)},P.flzDecompress=function(o){for(var s=w(g(o)),t=0,p=0,d,y,l,u,m=[];t<s.length;)if(l=s[t]>>5)for(y=256*(s[t]&31)+s[t+2-(l=l<7)],d=l?2+(s[t]>>5):9+s[t+1],t=t+3-l,u=p-y-1;d--;)m[p++]=m[u++];else for(d=1+s[t++];d--;)m[p++]=s[t++];return T(m)},P.cdCompress=function(o){o=g(o);var s="0x",t=0,p=0,d=0,y;function l(m){s+=E((s.length<4*2+2)*255^m)}function u(m,h){l(0),l(h-1+m*128)}for(;d<o.length;d+=2){if(y=A(o,d),!y){p&&(u(1,p),p=0),++t===128&&(u(0,128),t=0);continue}if(y===255){t&&(u(0,t),t=0),++p===32&&(u(1,32),p=0);continue}p&&(u(1,p),p=0),t&&(u(0,t),t=0),l(y)}return p&&(u(1,p),p=0),t&&(u(0,t),t=0),s},P.cdDecompress=function(o){o=g(o);for(var s="0x",t=0,p,d,y;t<o.length;){if(d=(t<4*2)*255^A(o,t),t+=2,!d){for(d=(t<4*2)*255^A(o,t),y=(d&127)+1,t+=2,p=0;p<y;++p)s+=E((d>>7&&p<32)*255);continue}s+=E(d)}return s};var I={};return c.ERC1967Factory=I,I.address="0x0000000000006396FF2a80c067f99B3d2Ab4Df24",I.abi=JSON.parse('[{0:[],1:"DeploymentFailed"96"SaltDoesNotStartWithCaller"96"Unauthorized"96"UpgradeFailed",2:3959790,9791],1:"AdminChanged",2:10959790,9792,9791],1:"Deployed",2:10959790,9792],1:"Upgraded",2:10},{0:[{90],1:"adminOf",12:[{9199{0:[{90,{91],1:"changeAdmin",12:[],13:"nonpayable",2:15},{0:[{92,{91],1:"deploy",12:[{9098,{0:[{92,{91,{94],1:"deployAndCall",12:[{9098,{0:[{92,{91,{93],1:"deployDeterministic",12:[{9098,{0:[{92,{91,{93,{94],1:"deployDeterministicAndCall",12:[{9098,{0:[],1:"initCodeHash",12:[{6:19,1:"result",2:19}99{0:[{93],1:"predictDeterministicAddress",12:[{6:7,1:"predicted",2:7}99{0:[{90,{92],1:"upgrade",12:[98,{0:[{90,{92,{94],1:"upgradeAndCall",12:[98]'.replace(/9\d/g,function(o){return["6:7,1:8,2:7}","6:7,1:9,2:7}","6:7,1:11,2:7}","6:19,1:20,2:19}","6:17,1:18,2:17}","},{4:false,0:[",",2:3},{0:[],1:","{5:true,","],13:16,2:15}","],13:14,2:15},"][o-90]}).replace(/\d+/g,function(o){return'"'+"inputs,name,type,error,anonymous,indexed,internalType,address,proxy,admin,event,implementation,outputs,stateMutability,view,function,payable,bytes,data,bytes32,salt".split(",")[o]+'"'})),i||(r.solady=c),c})})(R,R.exports);var X=R.exports;function $(e){return n.slice(n.isHex(e)?n.keccak256(e):n.keccak256(n.toHex(e)),0,4)}async function ee(e,a,r){const i=await M.waitForTransactionReceipt(e,{...r,hash:await a});if(!i.contractAddress)throw new J.NoContractAddressUponReceiptError(i);return i.contractAddress}async function ae(e,a,r){const{hash:i,result:c}=await a;return await M.waitForTransactionReceipt(e,{...r,hash:i}),c}var U=(e=>(e[e.ACTION=0]="ACTION",e[e.ALLOW_LIST=1]="ALLOW_LIST",e[e.BUDGET=2]="BUDGET",e[e.INCENTIVE=3]="INCENTIVE",e[e.VALIDATOR=4]="VALIDATOR",e))(U||{}),H=(e=>(e[e.POOL=0]="POOL",e[e.MINT=1]="MINT",e[e.RAFFLE=2]="RAFFLE",e))(H||{}),z=(e=>(e[e.POOL=0]="POOL",e[e.MINT=1]="MINT",e))(z||{}),G=(e=>(e[e.EQUAL=0]="EQUAL",e[e.NOT_EQUAL=1]="NOT_EQUAL",e[e.GREATER_THAN=2]="GREATER_THAN",e[e.LESS_THAN=3]="LESS_THAN",e[e.CONTAINS=4]="CONTAINS",e))(G||{}),k=(e=>(e[e.UINT=0]="UINT",e[e.ADDRESS=1]="ADDRESS",e[e.BYTES=2]="BYTES",e[e.STRING=3]="STRING",e))(k||{}),_=(e=>(e[e.EVENT=0]="EVENT",e[e.FUNC=1]="FUNC",e))(_||{});const te=({actionClaimant:e,actionStepOne:a,actionStepTwo:r,actionStepThree:i,actionStepFour:c})=>n.encodeAbiParameters([{type:"tuple",name:"initPayload",components:[{type:"tuple",name:"actionClaimant",components:[{type:"uint8",name:"signatureType"},{type:"bytes4",name:"signature"},{type:"uint8",name:"fieldIndex"},{type:"address",name:"targetContract"}]},{type:"tuple",name:"actionStepOne",components:[{type:"bytes4",name:"signature"},{type:"uint8",name:"signatureType"},{type:"uint8",name:"actionType"},{type:"address",name:"targetContract"},{type:"tuple",name:"actionParameter",components:[{type:"uint8",name:"filterType"},{type:"uint8",name:"fieldType"},{type:"uint8",name:"fieldIndex"},{type:"bytes",name:"filterData"}]}]},{type:"tuple",name:"actionStepTwo",components:[{type:"bytes4",name:"signature"},{type:"uint8",name:"signatureType"},{type:"uint8",name:"actionType"},{type:"address",name:"targetContract"},{type:"tuple",name:"actionParameter",components:[{type:"uint8",name:"filterType"},{type:"uint8",name:"fieldType"},{type:"uint8",name:"fieldIndex"},{type:"bytes",name:"filterData"}]}]},{type:"tuple",name:"actionStepThree",components:[{type:"bytes4",name:"signature"},{type:"uint8",name:"signatureType"},{type:"uint8",name:"actionType"},{type:"address",name:"targetContract"},{type:"tuple",name:"actionParameter",components:[{type:"uint8",name:"filterType"},{type:"uint8",name:"fieldType"},{type:"uint8",name:"fieldIndex"},{type:"bytes",name:"filterData"}]}]},{type:"tuple",name:"actionStepFour",components:[{type:"bytes4",name:"signature"},{type:"uint8",name:"signatureType"},{type:"uint8",name:"actionType"},{type:"address",name:"targetContract"},{type:"tuple",name:"actionParameter",components:[{type:"uint8",name:"filterType"},{type:"uint8",name:"fieldType"},{type:"uint8",name:"fieldIndex"},{type:"bytes",name:"filterData"}]}]}]}],[{actionClaimant:e,actionStepOne:a,actionStepTwo:r,actionStepThree:i,actionStepFour:c}]),ne=({signers:e,validatorCaller:a})=>n.encodeAbiParameters([{type:"address[]",name:"signers"},{type:"address",name:"validatorCaller"}],[e,a]),re=({validatorData:e,incentiveData:a})=>n.encodeAbiParameters([{type:"bytes",name:"validatorData"},{type:"bytes",name:"incentiveData"}],[e,a]),q=({signer:e,signature:a,incentiveQuantity:r})=>n.encodeAbiParameters([{type:"tuple",name:"SignerValidatorInputParams",components:[{type:"address",name:"signer"},{type:"bytes",name:"signature"},{type:"uint8",name:"incentiveQuantity"}]}],[{signer:e,signature:a,incentiveQuantity:r}]);async function oe({signer:e,incentiveData:a,chainId:r,validator:i,incentiveQuantity:c,claimant:P,boostId:g}){const A={domain:{name:"SignerValidator",version:"1",chainId:r,verifyingContract:i},types:{SignerValidatorData:[{name:"boostId",type:"uint256"},{name:"incentiveQuantity",type:"uint8"},{name:"claimant",type:"address"},{name:"incentiveData",type:"bytes"}]},primaryType:"SignerValidatorData",message:{boostId:g,incentiveQuantity:c,claimant:P,incentiveData:a}},w=await Y.signTypedData({...A,privateKey:e.key}),T=q({signer:e.account,signature:w,incentiveQuantity:c});return n.encodeAbiParameters([{type:"tuple",name:"BoostClaimData",components:[{type:"bytes",name:"validatorData"},{type:"bytes",name:"incentiveData"}]}],[{validatorData:T,incentiveData:a}])}const ie=({owner:e,allowed:a})=>n.encodeAbiParameters([{type:"address",name:"owner"},{type:"address[]",name:"allowed"}],[e,a]),se=({owner:e,denied:a})=>n.encodeAbiParameters([{type:"address",name:"owner"},{type:"address[]",name:"denied"}],[e,a]);function de({budget:e,action:a,validator:r,allowList:i,incentives:c,protocolFee:P=0n,referralFee:g=0n,maxParticipants:E=0n,owner:A}){return X.LibZip.cdCompress(n.encodeAbiParameters(n.parseAbiParameters(["BoostPayload payload","struct BoostPayload { address budget; Target action; Target validator; Target allowList; Target[] incentives; uint64 protocolFee; uint64 referralFee; uint256 maxParticipants; address owner; }","struct Target { bool isBase; address instance; bytes parameters; }"]),[{budget:e,action:a,validator:r,allowList:i,incentives:c,protocolFee:P,referralFee:g,maxParticipants:E,owner:A}]))}function Q({tokenId:e,amount:a}){return n.encodeAbiParameters(n.parseAbiParameters(["ERC1155Payload payload","struct ERC1155Payload { uint256 tokenId; uint256 amount; bytes data; }"]),[{tokenId:e,amount:a,data:"0x"}])}const pe=({venue:e,selector:a,reward:r,limit:i})=>n.encodeAbiParameters([{type:"address",name:"venue"},{type:"bytes4",name:"selector"},{type:"uint256",name:"reward"},{type:"uint256",name:"limit"}],[e,a,r,i]),le=({asset:e,initialReward:a,rewardDecay:r,rewardBoost:i,totalBudget:c})=>n.encodeAbiParameters([{type:"address",name:"asset"},{type:"uint256",name:"initialReward"},{type:"uint256",name:"rewardDecay"},{type:"uint256",name:"rewardBoost"},{type:"uint256",name:"totalBudget"}],[e,a,r,i,c]),ue=({asset:e,strategy:a,tokenId:r,limit:i,extraData:c})=>n.encodeAbiParameters(n.parseAbiParameters(["InitPayload payload","struct InitPayload { address asset; uint8 strategy; uint256 tokenId; uint256 limit; bytes extraData; }"]),[{asset:e,strategy:a,tokenId:r,limit:i,extraData:c}]),ce=({allowList:e,limit:a})=>n.encodeAbiParameters([{type:"address",name:"allowList"},{type:"uint256",name:"limit"}],[e,a]),ye=({asset:e,strategy:a,reward:r,limit:i})=>n.encodeAbiParameters([{type:"address",name:"asset"},{type:"uint8",name:"strategy"},{type:"uint256",name:"reward"},{type:"uint256",name:"limit"}],[e,a,r,i]),me=({asset:e,reward:a,limit:r})=>n.encodeAbiParameters([{type:"address",name:"asset"},{type:"uint256",name:"reward"},{type:"uint256",name:"limit"}],[e,a,r]),fe=({owner:e,authorized:a})=>n.encodeAbiParameters(n.parseAbiParameters(["SimpleBudgetPayload payload","struct SimpleBudgetPayload { address owner; address[] authorized; }"]),[{owner:e,authorized:a}]),be=({owner:e,authorized:a,roles:r})=>n.encodeAbiParameters(n.parseAbiParameters(["ManagedBudgetPayload payload","struct ManagedBudgetPayload { address owner; address[] authorized; uint256[] roles; }"]),[{owner:e,authorized:a,roles:r}]),Pe=({owner:e,authorized:a,start:r,duration:i,cliff:c})=>n.encodeAbiParameters(n.parseAbiParameters(["VestingBudgetPayload payload","struct VestingBudgetPayload { address owner; address[] authorized; uint64 start; uint64 duration; uint64 cliff; }"]),[{owner:e,authorized:a,start:r,duration:i,cliff:c}]),Z=({chainId:e,target:a,selector:r,value:i})=>n.encodeAbiParameters(n.parseAbiParameters(["ContractActionPayload payload","struct ContractActionPayload { uint256 chainId; address target; bytes4 selector; uint256 value; }"]),[{chainId:e,target:a,selector:r,value:i}]),ge=({chainId:e,target:a,selector:r,value:i})=>Z({chainId:e,target:a,selector:r,value:i}),Ae=({target:e,data:a=n.zeroHash})=>n.encodeAbiParameters([{type:"address",name:"target"},{type:"bytes",name:"data"}],[e,a]);var j=(e=>(e[e.ETH=0]="ETH",e[e.ERC20=1]="ERC20",e[e.ERC1155=2]="ERC1155",e))(j||{});const Ce=({assetType:e,address:a,target:r,data:i})=>n.encodeAbiParameters([{type:"uint8",name:"assetType"},{type:"address",name:"asset"},{type:"address",name:"target"},{type:"bytes",name:"data"}],[e,a,r,i]);function Ee({tokenId:e,amount:a,asset:r,target:i}){return n.encodeAbiParameters(n.parseAbiParameters(["Transfer request","struct Transfer { uint8 assetType; address asset; address target; bytes data; }"]),[{assetType:2,asset:r,data:Q({tokenId:e,amount:a}),target:i}])}function W({amount:e}){return n.encodeAbiParameters(n.parseAbiParameters(["FungiblePayload payload","struct FungiblePayload { uint256 amount; }"]),[{amount:e}])}function we({amount:e,asset:a,target:r}){return n.encodeAbiParameters(n.parseAbiParameters(["Transfer request","struct Transfer { uint8 assetType; address asset; address target; bytes data; }"]),[{assetType:a==n.zeroAddress?0:1,asset:a,data:W({amount:e}),target:r}])}function Te(e,a){return n.encodeAbiParameters([{type:"address",name:"holder"},{type:"bytes",name:"payload"}],[e,n.toHex(a)])}exports.AssetType=j;exports.ERC1155StrategyType=z;exports.FilterType=G;exports.PrimitiveType=k;exports.RegistryType=U;exports.SignatureType=_;exports.StrategyType=H;exports.awaitResult=ae;exports.bytes4=$;exports.getDeployedContractAddress=ee;exports.prepareAllowListIncentivePayload=ce;exports.prepareBoostClaimData=re;exports.prepareBoostPayload=de;exports.prepareCGDAIncentivePayload=le;exports.prepareClaimPayload=Ae;exports.prepareContractActionPayload=Z;exports.prepareERC1155IncentivePayload=ue;exports.prepareERC1155Payload=Q;exports.prepareERC1155Transfer=Ee;exports.prepareERC20IncentivePayload=ye;exports.prepareERC20VariableIncentivePayload=me;exports.prepareERC721MintActionPayload=ge;exports.prepareERC721MintActionValidate=Te;exports.prepareEventActionPayload=te;exports.prepareFungiblePayload=W;exports.prepareFungibleTransfer=we;exports.prepareManagedBudgetPayload=be;exports.preparePointsIncentivePayload=pe;exports.prepareSignerValidatorClaimDataPayload=oe;exports.prepareSignerValidatorInputParams=q;exports.prepareSignerValidatorPayload=ne;exports.prepareSimpleAllowListPayload=ie;exports.prepareSimpleBudgetPayload=fe;exports.prepareSimpleDenyListPayload=se;exports.prepareTransferPayload=Ce;exports.prepareVestingBudgetPayload=Pe;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("@wagmi/core"),n=require("viem"),s=require("./errors.cjs");var u=(t=>(t[t.ACTION=0]="ACTION",t[t.ALLOW_LIST=1]="ALLOW_LIST",t[t.BUDGET=2]="BUDGET",t[t.INCENTIVE=3]="INCENTIVE",t[t.VALIDATOR=4]="VALIDATOR",t))(u||{});function d(t){return n.slice(n.isHex(t)?n.keccak256(t):n.keccak256(n.toHex(t)),0,4)}async function A(t,c,r){const o=await i.waitForTransactionReceipt(t,{...r,hash:await c});if(!o.contractAddress)throw new s.NoContractAddressUponReceiptError(o);return o.contractAddress}async function f(t,c,r){const{hash:o,result:a}=await c;return await i.waitForTransactionReceipt(t,{...r,hash:o}),a}function l(t,c,r){let o;const a=i.getAccount(t);if(r!==void 0?c[r]&&(o=r):a.chainId!==void 0&&c[a.chainId]&&(o=a.chainId),o===void 0){const e=i.getClient(t);e!=null&&e.chain.id&&c[e==null?void 0:e.chain.id]&&(o=e.chain.id)}if(o===void 0&&(o=11155111),!c[o])throw new s.InvalidProtocolChainIdError(o,Object.keys(c).map(Number));return{chainId:o,address:c[o]}}exports.RegistryType=u;exports.assertValidAddressByChainId=l;exports.awaitResult=f;exports.bytes4=d;exports.getDeployedContractAddress=A;
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../src/utils.ts"],"sourcesContent":["import {\n  type Config,\n  type ReadContractParameters,\n  type WatchContractEventParameters,\n  type WriteContractParameters,\n  getAccount,\n  getClient,\n  waitForTransactionReceipt,\n} from '@wagmi/core';\nimport type { ExtractAbiEvent } from 'abitype';\nimport type {\n  Abi,\n  AbiEvent,\n  Address,\n  ContractEventName,\n  ContractFunctionName,\n  GetLogsParameters,\n  Hash,\n  Hex,\n  Log,\n  WaitForTransactionReceiptParameters,\n} from 'viem';\nimport { isHex, keccak256, slice, toHex } from 'viem';\nimport {\n  InvalidProtocolChainIdError,\n  NoConnectedChainIdError,\n  NoContractAddressUponReceiptError,\n} from './errors';\n\nexport type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;\n\n/**\n * Enum encapsulating all the different types of targets used in the Boost V2 Protocol.\n *\n * @export\n * @enum {number}\n */\nexport enum RegistryType {\n  ACTION = 0,\n  ALLOW_LIST = 1,\n  BUDGET = 2,\n  INCENTIVE = 3,\n  VALIDATOR = 4,\n}\n\n/**\n * Helper type that encapsulates common writeContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (writeContract)[https://viem.sh/docs/contract/writeContract]\n *\n * @export\n * @typedef {WriteParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type WriteParams<\n  abi extends Abi = Abi,\n  functionName extends ContractFunctionName<abi> = ContractFunctionName<abi>,\n> = Partial<\n  Omit<\n    WriteContractParameters<abi, functionName>,\n    'address' | 'args' | 'functionName' | 'abi'\n  >\n>;\n\n/**\n * Helper type that encapsulates common readContract parameters without fields like `abi`, `args`, `functionName`, `address` that are expected to be provided the SDK.\n * See (readContract)[https://viem.sh/docs/contract/readContract]\n *\n * @export\n * @typedef {ReadParams}\n * @template {Abi} abi\n * @template {ContractFunctionName<abi>} functionName\n */\nexport type ReadParams<\n  abi extends Abi,\n  functionName extends ContractFunctionName<abi>,\n> = Partial<\n  Omit<\n    ReadContractParameters<abi, functionName>,\n    'address' | 'args' | 'functionName' | 'abi'\n  >\n>;\n\n/**\n * Helper type that encapsulates common `watchContractEvent` parameters without fields like `address`, and `abi` that are expected to be provided the SDK.\n * See (watchContractEvent)[https://wagmi.sh/core/api/actions/watchContractEvent]\n *\n * @export\n * @typedef {WatchParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi> | undefined} [eventName=undefined]\n */\nexport type WatchParams<\n  abi extends Abi,\n  eventName extends ContractEventName<abi> | undefined = undefined,\n> = Partial<\n  Omit<WatchContractEventParameters<abi, eventName>, 'address' | 'abi'>\n>;\n\n/**\n * Helper type that encapsulates common `getLogs` parameters without fields like `address` that are expected to be provided the SDK.\n * See (getLogs)[https://viem.sh/docs/actions/public/getLogs#getlogs]\n *\n * @export\n * @typedef {GetLogsParams}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} event\n * @template {ExtractAbiEvent<abi, event>} [abiEvent=ExtractAbiEvent<abi, event>]\n * @template {| readonly AbiEvent[]\n *     | readonly unknown[]\n *     | undefined} [abiEvents=abiEvent extends AbiEvent ? [abiEvent] : undefined]\n */\nexport type GetLogsParams<\n  abi extends Abi,\n  event extends ContractEventName<abi>,\n  abiEvent extends ExtractAbiEvent<abi, event> = ExtractAbiEvent<abi, event>,\n  abiEvents extends\n    | readonly AbiEvent[]\n    | readonly unknown[]\n    | undefined = abiEvent extends AbiEvent ? [abiEvent] : undefined,\n> = Partial<Omit<GetLogsParameters<abiEvent, abiEvents>, 'address'>> & {\n  chainId?: number | undefined;\n};\n\n/**\n * A generic `viem.Log` event with typed `args` support via a given `Abi` and `ContractEventName`\n *\n * @export\n * @typedef {GenericLog}\n * @template {Abi} abi\n * @template {ContractEventName<abi>} [event=ContractEventName<abi>]\n */\nexport type GenericLog<\n  abi extends Abi,\n  event extends ContractEventName<abi> = ContractEventName<abi>,\n> = Log<bigint, number, false, ExtractAbiEvent<abi, event>, false>;\n\n/**\n * Helper utility to convert a string to a `bytes4` type\n *\n * @export\n * @param {string} input\n * @returns {Hex}\n */\nexport function bytes4(input: string) {\n  return slice(isHex(input) ? keccak256(input) : keccak256(toHex(input)), 0, 4);\n}\n\n/**\n * Utility function to wait for a transaction receipt, and extract the contractAddress\n *\n * @export\n * @async\n * @param {WagmiConfig} config - [Wagmi Configuration](https://wagmi.sh/core/api/createConfig)\n * @param {Promise<Hash>} hash - A transaction hash promise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams] - @see {@link WaitForTransactionReceiptParameters}\n * @returns {Promise<Address>}\n * @throws {@link NoContractAddressUponReceiptError} if no `contractAddress` exists after the transaction has been received\n */\nexport async function getDeployedContractAddress(\n  config: Config,\n  hash: Promise<Hash>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n) {\n  const receipt = await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash: await hash,\n  });\n  if (!receipt.contractAddress)\n    throw new NoContractAddressUponReceiptError(receipt);\n  return receipt.contractAddress;\n}\n\n/**\n * Utility type to encapsulate a transaction hash, and the simulated result prior to submitting the transaction.\n *\n * @export\n * @typedef {HashAndSimulatedResult}\n * @template [T=unknown]\n */\nexport type HashAndSimulatedResult<T = unknown> = { hash: Hash; result: T };\n\n/**\n * Helper function to wait for a transaction receipt given a hash promise.\n *\n * @export\n * @async\n * @template [Result=unknown]\n * @param {WagmiConfig} config\n * @param {Promise<HashAndSimulatedResult<Result>>} hashPromise\n * @param {?Omit<WaitForTransactionReceiptParameters, 'hash'>} [waitParams]\n * @returns {Promise<Result>}\n */\nexport async function awaitResult<Result = unknown>(\n  config: Config,\n  hashPromise: Promise<HashAndSimulatedResult<Result>>,\n  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,\n): Promise<Result> {\n  const { hash, result } = await hashPromise;\n  await waitForTransactionReceipt(config, {\n    ...waitParams,\n    hash,\n  });\n  return result;\n}\n\n/**\n * Given a wagmi config and a map of chain id's to addresses, determine an address/chainId combo that maps to the currently connected chain id, or throw a typed error.\n *\n * @export\n * @param {Config} config\n * @param {Record<string, Address>} addressByChainId\n * @param {number} desiredChainId\n * @returns {{ chainId: number, address: Address }}\n * @throws {@link InvalidProtocolChainIdError}\n */\nexport function assertValidAddressByChainId(\n  config: Config,\n  addressByChainId: Record<number, Address>,\n  desiredChainId?: number,\n): { chainId: number; address: Address } {\n  let chainId: number | undefined = undefined;\n  const wagmiAccount = getAccount(config);\n  // if manually providing a chain id for some contract operation, try to use it\n  if (desiredChainId !== undefined) {\n    if (addressByChainId[desiredChainId]) chainId = desiredChainId;\n  } else if (wagmiAccount.chainId !== undefined) {\n    // otherwise if we can get the current chain id off the connected account and it matches one of ours, use it\n    if (addressByChainId[wagmiAccount.chainId]) chainId = wagmiAccount.chainId;\n  }\n  // chainId is still undefined, try to get chain id off viem client\n  if (chainId === undefined) {\n    const client = getClient(config);\n    if (client?.chain.id && addressByChainId[client?.chain.id])\n      chainId = client.chain.id;\n  }\n  // if chainId is STILL undefined, use our default addresses\n  // TODO: update this when on prod network\n  if (chainId === undefined) chainId = Number(__DEFAULT_CHAIN_ID__);\n  if (!addressByChainId[chainId])\n    throw new InvalidProtocolChainIdError(\n      chainId,\n      Object.keys(addressByChainId).map(Number),\n    );\n  // biome-ignore lint/style/noNonNullAssertion: this type should be narrowed by the above statement but isn't?\n  return { chainId, address: addressByChainId[chainId]! };\n}\n"],"names":["RegistryType","bytes4","input","slice","isHex","keccak256","toHex","getDeployedContractAddress","config","hash","waitParams","receipt","waitForTransactionReceipt","NoContractAddressUponReceiptError","awaitResult","hashPromise","result","assertValidAddressByChainId","addressByChainId","desiredChainId","chainId","wagmiAccount","getAccount","client","getClient","InvalidProtocolChainIdError"],"mappings":"2JAqCY,IAAAA,GAAAA,IACVA,EAAAA,EAAA,OAAS,CAAT,EAAA,SACAA,EAAAA,EAAA,WAAa,CAAb,EAAA,aACAA,EAAAA,EAAA,OAAS,CAAT,EAAA,SACAA,EAAAA,EAAA,UAAY,CAAZ,EAAA,YACAA,EAAAA,EAAA,UAAY,CAAZ,EAAA,YALUA,IAAAA,GAAA,CAAA,CAAA,EA2GL,SAASC,EAAOC,EAAe,CACpC,OAAOC,EAAM,MAAAC,EAAA,MAAMF,CAAK,EAAIG,EAAU,UAAAH,CAAK,EAAIG,EAAA,UAAUC,EAAM,MAAAJ,CAAK,CAAC,EAAG,EAAG,CAAC,CAC9E,CAasB,eAAAK,EACpBC,EACAC,EACAC,EACA,CACM,MAAAC,EAAU,MAAMC,EAAA,0BAA0BJ,EAAQ,CACtD,GAAGE,EACH,KAAM,MAAMD,CAAA,CACb,EACD,GAAI,CAACE,EAAQ,gBACL,MAAA,IAAIE,EAAAA,kCAAkCF,CAAO,EACrD,OAAOA,EAAQ,eACjB,CAsBsB,eAAAG,EACpBN,EACAO,EACAL,EACiB,CACjB,KAAM,CAAE,KAAAD,EAAM,OAAAO,CAAO,EAAI,MAAMD,EAC/B,aAAMH,EAAAA,0BAA0BJ,EAAQ,CACtC,GAAGE,EACH,KAAAD,CAAA,CACD,EACMO,CACT,CAYgB,SAAAC,EACdT,EACAU,EACAC,EACuC,CACvC,IAAIC,EACE,MAAAC,EAAeC,aAAWd,CAAM,EAStC,GAPIW,IAAmB,OACjBD,EAAiBC,CAAc,IAAaC,EAAAD,GACvCE,EAAa,UAAY,QAE9BH,EAAiBG,EAAa,OAAO,MAAaA,EAAa,SAGjED,IAAY,OAAW,CACnB,MAAAG,EAASC,YAAUhB,CAAM,EAC3Be,GAAA,MAAAA,EAAQ,MAAM,IAAML,EAAiBK,GAAA,YAAAA,EAAQ,MAAM,EAAE,IACvDH,EAAUG,EAAO,MAAM,GAC3B,CAII,GADAH,IAAY,SAAqBA,EAAO,UACxC,CAACF,EAAiBE,CAAO,EAC3B,MAAM,IAAIK,EAAA,4BACRL,EACA,OAAO,KAAKF,CAAgB,EAAE,IAAI,MAAM,CAAA,EAG5C,MAAO,CAAE,QAAAE,EAAS,QAASF,EAAiBE,CAAO,CAAG,CACxD"}