thirdweb 5.45.0-nightly-bbb4f1c53f982b1f9de00fb30efbf2c77f155e96-20240809000532 → 5.45.0

package/src/extensions/split/__generated__/Split/read/totalReleased.ts

@@ -0,0 +1,74 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0xe33b7de3" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+  },
+] as const;
+
+/**
+ * Checks if the `totalReleased` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `totalReleased` method is supported.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { isTotalReleasedSupported } from "thirdweb/extensions/split";
+ *
+ * const supported = await isTotalReleasedSupported(contract);
+ * ```
+ */
+export async function isTotalReleasedSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the totalReleased function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { decodeTotalReleasedResult } from "thirdweb/extensions/split";
+ * const result = decodeTotalReleasedResult("...");
+ * ```
+ */
+export function decodeTotalReleasedResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "totalReleased" function on the contract.
+ * @param options - The options for the totalReleased function.
+ * @returns The parsed result of the function call.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { totalReleased } from "thirdweb/extensions/split";
+ *
+ * const result = await totalReleased({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function totalReleased(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/split/__generated__/Split/write/distribute.ts

@@ -0,0 +1,51 @@
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0xe4fc6b6d" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `distribute` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `distribute` method is supported.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { isDistributeSupported } from "thirdweb/extensions/split";
+ *
+ * const supported = await isDistributeSupported(contract);
+ * ```
+ */
+export async function isDistributeSupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Prepares a transaction to call the "distribute" function on the contract.
+ * @param options - The options for the "distribute" function.
+ * @returns A prepared transaction object.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { distribute } from "thirdweb/extensions/split";
+ *
+ * const transaction = distribute();
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function distribute(options: BaseTransactionOptions) {
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}

package/src/extensions/split/__generated__/Split/write/release.ts

@@ -0,0 +1,136 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "release" function.
+ */
+export type ReleaseParams = WithOverrides<{
+  account: AbiParameterToPrimitiveType<{ type: "address"; name: "account" }>;
+}>;
+
+export const FN_SELECTOR = "0x19165587" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "account",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `release` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `release` method is supported.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { isReleaseSupported } from "thirdweb/extensions/split";
+ *
+ * const supported = await isReleaseSupported(contract);
+ * ```
+ */
+export async function isReleaseSupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "release" function.
+ * @param options - The options for the release function.
+ * @returns The encoded ABI parameters.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { encodeReleaseParams } "thirdweb/extensions/split";
+ * const result = encodeReleaseParams({
+ *  account: ...,
+ * });
+ * ```
+ */
+export function encodeReleaseParams(options: ReleaseParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.account]);
+}
+
+/**
+ * Encodes the "release" function into a Hex string with its parameters.
+ * @param options - The options for the release function.
+ * @returns The encoded hexadecimal string.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { encodeRelease } "thirdweb/extensions/split";
+ * const result = encodeRelease({
+ *  account: ...,
+ * });
+ * ```
+ */
+export function encodeRelease(options: ReleaseParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeReleaseParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "release" function on the contract.
+ * @param options - The options for the "release" function.
+ * @returns A prepared transaction object.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { release } from "thirdweb/extensions/split";
+ *
+ * const transaction = release({
+ *  contract,
+ *  account: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function release(
+  options: BaseTransactionOptions<
+    | ReleaseParams
+    | {
+        asyncParams: () => Promise<ReleaseParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.account] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}

package/src/extensions/split/read/releasableByToken.ts

@@ -0,0 +1,34 @@
+import { readContract } from "../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type { ReleasableParams } from "../__generated__/Split/read/releasable.js";
+
+export type ReleasableByTokenParams = ReleasableParams & {
+  tokenAddress: string;
+};
+
+/**
+ * Calls the "releasable" function on the contract.
+ * @param options - The options for the releasable function.
+ * @returns The parsed result of the function call.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { releasableByToken } from "thirdweb/extensions/split";
+ *
+ * const result = await releasableByToken({
+ *  contract,
+ *  account: ...,
+ * });
+ *
+ * ```
+ */
+export async function releasableByToken(
+  options: BaseTransactionOptions<ReleasableByTokenParams>,
+) {
+  return readContract({
+    method:
+      "function releasable(address token, address account) view returns (uint256)",
+    params: [options.tokenAddress, options.account],
+    ...options,
+  });
+}

package/src/extensions/split/read/releasedByToken.ts

@@ -0,0 +1,33 @@
+import { readContract } from "../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type { ReleasedParams } from "../__generated__/Split/read/released.js";
+
+/**
+ * Calls the "released" function on the contract.
+ * Similar to the `released` extension, however this one requires you to specify a tokenAddress
+ *
+ * @param options - The options for the released function.
+ * @returns The parsed result of the function call.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { releasedByToken } from "thirdweb/extensions/split";
+ *
+ * const result = await releasedByToken({
+ *  contract,
+ *  account: "0x...",
+ *  tokenAddress: "0x...",
+ * });
+ *
+ * ```
+ */
+export async function releasedByToken(
+  options: BaseTransactionOptions<ReleasedParams & { tokenAddress: string }>,
+) {
+  return readContract({
+    contract: options.contract,
+    method:
+      "function released(address token, address account) view returns (uint256)",
+    params: [options.tokenAddress, options.account],
+  });
+}

package/src/extensions/split/read/totalReleasedByToken.ts

@@ -0,0 +1,30 @@
+import { readContract } from "../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+
+/**
+ * Calls the "totalReleased" function on the contract.
+ * Similar to the `release` extension, however this one requires you to specify a tokenAddress
+ *
+ * @param options - The options for the totalReleased function.
+ * @returns The parsed result of the function call.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { totalReleasedByToken } from "thirdweb/extensions/split";
+ *
+ * const result = await totalReleasedByToken({
+ *  contract,
+ *  tokenAddress: "0x...",
+ * });
+ *
+ * ```
+ */
+export async function totalReleasedByToken(
+  options: BaseTransactionOptions<{ tokenAddress: string }>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: "function totalReleased(address token) view returns (uint256)",
+    params: [options.tokenAddress],
+  });
+}

package/src/extensions/split/write/distributeByToken.ts

@@ -0,0 +1,29 @@
+import { prepareContractCall } from "../../../transaction/prepare-contract-call.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+
+/**
+ * This extension is similar to the `distribute` extension,
+ * however it require you to specify the token (address) that you want to distribute
+ * @param options.tokenAddress - The contract address of the token you want to distribute
+ * @returns A prepared transaction object.
+ * @extension SPLIT
+ * @example
+ * ```ts
+ * import { distributeByToken } from "thirdweb/extensions/split";
+ *
+ * const transaction = distributeByToken();
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function distributeByToken(
+  options: BaseTransactionOptions<{ tokenAddress: string }>,
+) {
+  return prepareContractCall({
+    method: "function distribute(address token)",
+    params: [options.tokenAddress],
+    ...options,
+  });
+}

package/src/extensions/split/write/releaseByToken.ts

@@ -0,0 +1,39 @@
+import { prepareContractCall } from "../../../transaction/prepare-contract-call.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type { ReleaseParams } from "../__generated__/Split/write/release.js";
+
+export type ReleaseByTokenParams = ReleaseParams & {
+  tokenAddress: string;
+};
+
+/**
+ * Similar to the `release` extension, however this one requires you to specify a tokenAddress to release
+ * @param options
+ * @returns
+ * @example
+ * ```ts
+ * import { releaseByToken } from "thirdweb/extensions/split";
+ *
+ * const transaction = releaseByToken({
+ *  contract,
+ *  account: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ * @extension SPLIT
+ */
+export function releaseByToken(
+  options: BaseTransactionOptions<ReleaseByTokenParams>,
+) {
+  return prepareContractCall({
+    method: "function release(address token, address account)",
+    params: [options.tokenAddress, options.account],
+    ...options,
+  });
+}

package/src/extensions/vote/__generated__/Vote/read/BALLOT_TYPEHASH.ts

@@ -0,0 +1,74 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0xdeaaa7cc" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    type: "bytes32",
+  },
+] as const;
+
+/**
+ * Checks if the `BALLOT_TYPEHASH` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `BALLOT_TYPEHASH` method is supported.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { isBALLOT_TYPEHASHSupported } from "thirdweb/extensions/vote";
+ *
+ * const supported = await isBALLOT_TYPEHASHSupported(contract);
+ * ```
+ */
+export async function isBALLOT_TYPEHASHSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the BALLOT_TYPEHASH function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { decodeBALLOT_TYPEHASHResult } from "thirdweb/extensions/vote";
+ * const result = decodeBALLOT_TYPEHASHResult("...");
+ * ```
+ */
+export function decodeBALLOT_TYPEHASHResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "BALLOT_TYPEHASH" function on the contract.
+ * @param options - The options for the BALLOT_TYPEHASH function.
+ * @returns The parsed result of the function call.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { BALLOT_TYPEHASH } from "thirdweb/extensions/vote";
+ *
+ * const result = await BALLOT_TYPEHASH({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function BALLOT_TYPEHASH(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/vote/__generated__/Vote/read/COUNTING_MODE.ts

@@ -0,0 +1,74 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0xdd4e2ba5" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    type: "string",
+  },
+] as const;
+
+/**
+ * Checks if the `COUNTING_MODE` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `COUNTING_MODE` method is supported.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { isCOUNTING_MODESupported } from "thirdweb/extensions/vote";
+ *
+ * const supported = await isCOUNTING_MODESupported(contract);
+ * ```
+ */
+export async function isCOUNTING_MODESupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the COUNTING_MODE function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { decodeCOUNTING_MODEResult } from "thirdweb/extensions/vote";
+ * const result = decodeCOUNTING_MODEResult("...");
+ * ```
+ */
+export function decodeCOUNTING_MODEResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "COUNTING_MODE" function on the contract.
+ * @param options - The options for the COUNTING_MODE function.
+ * @returns The parsed result of the function call.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { COUNTING_MODE } from "thirdweb/extensions/vote";
+ *
+ * const result = await COUNTING_MODE({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function COUNTING_MODE(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/vote/__generated__/Vote/read/getAllProposals.ts

@@ -0,0 +1,113 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0xcceb68f5" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    type: "tuple[]",
+    name: "allProposals",
+    components: [
+      {
+        type: "uint256",
+        name: "proposalId",
+      },
+      {
+        type: "address",
+        name: "proposer",
+      },
+      {
+        type: "address[]",
+        name: "targets",
+      },
+      {
+        type: "uint256[]",
+        name: "values",
+      },
+      {
+        type: "string[]",
+        name: "signatures",
+      },
+      {
+        type: "bytes[]",
+        name: "calldatas",
+      },
+      {
+        type: "uint256",
+        name: "startBlock",
+      },
+      {
+        type: "uint256",
+        name: "endBlock",
+      },
+      {
+        type: "string",
+        name: "description",
+      },
+    ],
+  },
+] as const;
+
+/**
+ * Checks if the `getAllProposals` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `getAllProposals` method is supported.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { isGetAllProposalsSupported } from "thirdweb/extensions/vote";
+ *
+ * const supported = await isGetAllProposalsSupported(contract);
+ * ```
+ */
+export async function isGetAllProposalsSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the getAllProposals function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { decodeGetAllProposalsResult } from "thirdweb/extensions/vote";
+ * const result = decodeGetAllProposalsResult("...");
+ * ```
+ */
+export function decodeGetAllProposalsResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getAllProposals" function on the contract.
+ * @param options - The options for the getAllProposals function.
+ * @returns The parsed result of the function call.
+ * @extension VOTE
+ * @example
+ * ```ts
+ * import { getAllProposals } from "thirdweb/extensions/vote";
+ *
+ * const result = await getAllProposals({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function getAllProposals(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}