eth-twc-sdk-js 0.1.0

package/dist/signatureTransfer/batch/index.cjs

@@ -0,0 +1,545 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// signatureTransfer/batch/index.ts
+var batch_exports = {};
+__export(batch_exports, {
+  argsSchema: () => argsSchema,
+  eip712Types: () => eip712Types,
+  sendTx: () => sendTx,
+  sign: () => sign,
+  signedDataSchema: () => signedDataSchema
+});
+module.exports = __toCommonJS(batch_exports);
+
+// twcConstants.ts
+var EIP712_DOMAIN_NAME = "TransferWithCommitment";
+var EIP712_DOMAIN_VERSION = "1";
+var transferWithCommitmentAddress = "0x5C260DD537A9c23Bbd42493e59F3CeA7da2DbC71";
+
+// utils.ts
+var chainIdToBig = (id) => typeof id === "bigint" ? id : BigInt(id);
+var assertPublicWalletSameChain = (publicClient, wallet) => {
+  const publicId = publicClient.chain?.id;
+  const walletId = wallet.chain?.id;
+  if (publicId === void 0 || walletId === void 0) {
+    throw new Error(
+      "Chain is not set on public client and/or wallet client"
+    );
+  }
+  if (publicId !== walletId) {
+    throw new Error(
+      `PublicClient and WalletClient chain mismatch: ${publicId} vs ${walletId}`
+    );
+  }
+};
+async function assertTransferContractDeployed(publicClient, contractAddress = transferWithCommitmentAddress) {
+  const code = await publicClient.getCode({ address: contractAddress });
+  if (code === void 0 || code === "0x") {
+    throw new Error(
+      `TransferWithCommitment is not deployed at ${contractAddress} on this chain (no contract code). Deploy with CREATE2 (see contracts/TWC_CREATE2.md) or switch network.`
+    );
+  }
+}
+function assertEip712DomainFromContractMatchesExpected(publicClient, eip712) {
+  const chainId = publicClient.chain?.id;
+  if (chainId === void 0) {
+    throw new Error("Chain is not set on public client");
+  }
+  const d = eip712.domain;
+  if (d.name !== EIP712_DOMAIN_NAME) {
+    throw new Error(
+      `Unexpected EIP-712 domain name: expected "${EIP712_DOMAIN_NAME}", got "${String(d.name)}"`
+    );
+  }
+  if (d.version !== EIP712_DOMAIN_VERSION) {
+    throw new Error(
+      `Unexpected EIP-712 domain version: expected "${EIP712_DOMAIN_VERSION}", got "${String(d.version)}"`
+    );
+  }
+  const vc = d.verifyingContract;
+  if (vc === void 0 || vc.toLowerCase() !== transferWithCommitmentAddress.toLowerCase()) {
+    throw new Error(
+      `Unexpected EIP-712 verifyingContract: expected ${transferWithCommitmentAddress}, got ${String(vc)}`
+    );
+  }
+  if (d.chainId !== void 0 && chainIdToBig(d.chainId) !== BigInt(chainId)) {
+    throw new Error(
+      `EIP-712 domain.chainId (${d.chainId}) does not match public client chain id (${chainId})`
+    );
+  }
+}
+var assertSignerMatchesEip712Role = (signer, messageAddress, role) => {
+  if (signer.toLowerCase() !== messageAddress.toLowerCase()) {
+    throw new Error(
+      `Signer account (${signer}) does not match EIP-712 message ${role} (${messageAddress})`
+    );
+  }
+};
+var assertSignedDomainMatchesClientAndConfig = (publicClient, domain, configuredContract) => {
+  const publicId = publicClient.chain?.id;
+  if (publicId === void 0) {
+    throw new Error("Chain is not set on public client");
+  }
+  if (chainIdToBig(domain.chainId) !== BigInt(publicId)) {
+    throw new Error(
+      `Signed data domain.chainId (${domain.chainId}) does not match client chain id (${publicId})`
+    );
+  }
+  if (domain.verifyingContract.toLowerCase() !== configuredContract.toLowerCase()) {
+    throw new Error(
+      `Signed data domain.verifyingContract (${domain.verifyingContract}) does not match transferWithCommitmentAddress (${configuredContract})`
+    );
+  }
+};
+
+// signatureTransfer/shared/domain.ts
+var ZERO_SALT = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function domainForTypedDataSign(raw) {
+  if (raw.salt !== void 0 && typeof raw.salt === "string" && raw.salt.toLowerCase() === ZERO_SALT) {
+    const { salt: _s, ...rest } = raw;
+    return rest;
+  }
+  return raw;
+}
+
+// signatureTransfer/batch/eip712Types.ts
+var eip712Types = {
+  BatchTransferWithCommit: [
+    { name: "from", type: "address" },
+    { name: "executor", type: "address" },
+    { name: "details", type: "CommittedTransferDetail[]" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "batchCommitment", type: "bytes32" }
+  ],
+  CommittedTransferDetail: [
+    { name: "to", type: "address" },
+    { name: "token", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "commitment", type: "bytes32" }
+  ]
+};
+
+// signatureTransfer/batch/types.ts
+var import_arktype4 = require("arktype");
+
+// types/utils.ts
+var import_arktype = require("arktype");
+var UINT256_MAX = (1n << 256n) - 1n;
+var uint256 = (0, import_arktype.type)("bigint").filter(
+  (v, ctx) => v <= UINT256_MAX && v >= 0n ? true : ctx.reject(`must be: 0n <= value <= ${UINT256_MAX}`)
+);
+var reBytes32 = /^0x[0-9a-fA-F]{64}$/;
+var reBytes = /^0x[0-9a-fA-F]+$/;
+var reAddress = /^0x[0-9a-fA-F]{40}$/;
+var bytes32 = (0, import_arktype.type)("string").narrow(
+  (s) => reBytes32.test(s)
+);
+var bytes = (0, import_arktype.type)("string").narrow((s) => reBytes.test(s));
+var address = (0, import_arktype.type)("string").narrow(
+  (s) => reAddress.test(s)
+);
+
+// signatureTransfer/shared/signedDomain.ts
+var import_arktype2 = require("arktype");
+var chainIdAsDomain = (0, import_arktype2.type)("number").or(uint256);
+var signedDomainSchema = (0, import_arktype2.type)({
+  name: (0, import_arktype2.type)("string"),
+  version: (0, import_arktype2.type)("string"),
+  chainId: chainIdAsDomain,
+  verifyingContract: address,
+  salt: bytes32.optional()
+});
+
+// types/transferDetail.ts
+var import_arktype3 = require("arktype");
+var transferDetail = (0, import_arktype3.type)({
+  to: address,
+  token: address,
+  value: uint256
+});
+var committedTransferDetail = (0, import_arktype3.type)({
+  to: address,
+  token: address,
+  value: uint256,
+  commitment: bytes32
+});
+
+// signatureTransfer/batch/types.ts
+var argsSchema = (0, import_arktype4.type)({
+  from: address,
+  executor: address,
+  details: committedTransferDetail.array(),
+  validAfter: uint256.default(0n),
+  validBefore: uint256.default(UINT256_MAX),
+  batchCommitment: bytes32
+}).narrow((v) => v.details.length > 0 && v.validAfter <= v.validBefore);
+var signedBatchSchema = (0, import_arktype4.type)({
+  domain: signedDomainSchema,
+  from: address,
+  details: committedTransferDetail.array(),
+  validAfter: uint256,
+  validBefore: uint256,
+  batchCommitment: bytes32,
+  signature: bytes
+}).narrow(
+  (v) => v.validAfter <= v.validBefore && v.details.length > 0
+);
+var signedDataSchema = signedBatchSchema;
+
+// signatureTransfer/batch/sign.ts
+var sign = async (publicClient, wallet, account, args) => {
+  assertPublicWalletSameChain(publicClient, wallet);
+  const a = argsSchema.assert(args);
+  assertSignerMatchesEip712Role(account, a.from, "from");
+  await assertTransferContractDeployed(publicClient);
+  const rawEip712 = await publicClient.getEip712Domain({
+    address: transferWithCommitmentAddress
+  });
+  assertEip712DomainFromContractMatchesExpected(publicClient, rawEip712);
+  const domain = domainForTypedDataSign(rawEip712.domain);
+  const signature = await wallet.signTypedData({
+    account,
+    domain,
+    types: eip712Types,
+    primaryType: "BatchTransferWithCommit",
+    message: {
+      from: a.from,
+      executor: a.executor,
+      details: a.details,
+      validAfter: a.validAfter,
+      validBefore: a.validBefore,
+      batchCommitment: a.batchCommitment
+    }
+  });
+  return {
+    domain,
+    from: a.from,
+    details: a.details,
+    validAfter: a.validAfter,
+    validBefore: a.validBefore,
+    batchCommitment: a.batchCommitment,
+    signature
+  };
+};
+
+// ../contracts/abi/generated.ts
+var transferWithCommitmentAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "name", internalType: "string", type: "string" },
+      { name: "version", internalType: "string", type: "string" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "BATCH_TRANSFER_WITH_COMMIT_TYPEHASH",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "CANCEL_AUTHORIZATION_TYPEHASH",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "TRANSFER_WITH_COMMIT_TYPEHASH",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "UNI_COMMIT_TRANSFER_TYPEHASH",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "authorizer", internalType: "address", type: "address" },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" },
+      { name: "signature", internalType: "bytes", type: "bytes" }
+    ],
+    name: "cancelAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "payer", internalType: "address", type: "address" },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" }
+    ],
+    name: "commitmentState",
+    outputs: [{ name: "", internalType: "bool", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "eip712Domain",
+    outputs: [
+      { name: "fields", internalType: "bytes1", type: "bytes1" },
+      { name: "name", internalType: "string", type: "string" },
+      { name: "version", internalType: "string", type: "string" },
+      { name: "chainId", internalType: "uint256", type: "uint256" },
+      { name: "verifyingContract", internalType: "address", type: "address" },
+      { name: "salt", internalType: "bytes32", type: "bytes32" },
+      { name: "extensions", internalType: "uint256[]", type: "uint256[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "token", internalType: "address", type: "address" },
+      { name: "to", internalType: "address", type: "address" },
+      { name: "value", internalType: "uint256", type: "uint256" },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "details",
+        internalType: "struct TransferDetail[]",
+        type: "tuple[]",
+        components: [
+          { name: "to", internalType: "address", type: "address" },
+          { name: "token", internalType: "address", type: "address" },
+          { name: "value", internalType: "uint256", type: "uint256" }
+        ]
+      },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "details",
+        internalType: "struct CommittedTransferDetail[]",
+        type: "tuple[]",
+        components: [
+          { name: "to", internalType: "address", type: "address" },
+          { name: "token", internalType: "address", type: "address" },
+          { name: "value", internalType: "uint256", type: "uint256" },
+          { name: "commitment", internalType: "bytes32", type: "bytes32" }
+        ]
+      }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "from", internalType: "address", type: "address" },
+      {
+        name: "details",
+        internalType: "struct TransferDetail[]",
+        type: "tuple[]",
+        components: [
+          { name: "to", internalType: "address", type: "address" },
+          { name: "token", internalType: "address", type: "address" },
+          { name: "value", internalType: "uint256", type: "uint256" }
+        ]
+      },
+      { name: "validAfter", internalType: "uint256", type: "uint256" },
+      { name: "validBefore", internalType: "uint256", type: "uint256" },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" },
+      { name: "signature", internalType: "bytes", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "from", internalType: "address", type: "address" },
+      {
+        name: "details",
+        internalType: "struct CommittedTransferDetail[]",
+        type: "tuple[]",
+        components: [
+          { name: "to", internalType: "address", type: "address" },
+          { name: "token", internalType: "address", type: "address" },
+          { name: "value", internalType: "uint256", type: "uint256" },
+          { name: "commitment", internalType: "bytes32", type: "bytes32" }
+        ]
+      },
+      { name: "validAfter", internalType: "uint256", type: "uint256" },
+      { name: "validBefore", internalType: "uint256", type: "uint256" },
+      { name: "batchCommitment", internalType: "bytes32", type: "bytes32" },
+      { name: "signature", internalType: "bytes", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "from", internalType: "address", type: "address" },
+      { name: "to", internalType: "address", type: "address" },
+      { name: "token", internalType: "address", type: "address" },
+      { name: "value", internalType: "uint256", type: "uint256" },
+      { name: "validAfter", internalType: "uint256", type: "uint256" },
+      { name: "validBefore", internalType: "uint256", type: "uint256" },
+      { name: "commitment", internalType: "bytes32", type: "bytes32" },
+      { name: "signature", internalType: "bytes", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      {
+        name: "payer",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      },
+      {
+        name: "commitment",
+        internalType: "bytes32",
+        type: "bytes32",
+        indexed: true
+      }
+    ],
+    name: "CommitmentUsed"
+  },
+  { type: "event", anonymous: false, inputs: [], name: "EIP712DomainChanged" },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      { name: "from", internalType: "address", type: "address", indexed: true },
+      { name: "to", internalType: "address", type: "address", indexed: true },
+      {
+        name: "token",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      },
+      {
+        name: "value",
+        internalType: "uint256",
+        type: "uint256",
+        indexed: false
+      },
+      {
+        name: "commitment",
+        internalType: "bytes32",
+        type: "bytes32",
+        indexed: false
+      }
+    ],
+    name: "TransferWithCommitmentSent"
+  },
+  {
+    type: "error",
+    inputs: [
+      { name: "token", internalType: "address", type: "address" },
+      { name: "from", internalType: "address", type: "address" },
+      { name: "value", internalType: "uint256", type: "uint256" }
+    ],
+    name: "AllowanceNotEnough"
+  },
+  { type: "error", inputs: [], name: "InvalidShortString" },
+  { type: "error", inputs: [], name: "ReentrancyGuardReentrantCall" },
+  {
+    type: "error",
+    inputs: [{ name: "token", internalType: "address", type: "address" }],
+    name: "SafeERC20FailedOperation"
+  },
+  {
+    type: "error",
+    inputs: [{ name: "str", internalType: "string", type: "string" }],
+    name: "StringTooLong"
+  }
+];
+
+// signatureTransfer/shared/context.ts
+async function assertSignatureTransferContext(publicClient, wallet, signedData) {
+  assertPublicWalletSameChain(publicClient, wallet);
+  await assertTransferContractDeployed(publicClient, transferWithCommitmentAddress);
+  assertSignedDomainMatchesClientAndConfig(
+    publicClient,
+    signedData.domain,
+    transferWithCommitmentAddress
+  );
+}
+
+// signatureTransfer/batch/sendTx.ts
+var sendTx = async (publicClient, wallet, account, signedData) => {
+  await assertSignatureTransferContext(publicClient, wallet, signedData);
+  const { request } = await publicClient.simulateContract({
+    address: transferWithCommitmentAddress,
+    abi: transferWithCommitmentAbi,
+    functionName: "transferWithAuthorization",
+    args: [
+      signedData.from,
+      signedData.details.map(
+        (detail) => ({
+          to: detail.to,
+          token: detail.token,
+          value: detail.value,
+          commitment: detail.commitment
+        })
+      ),
+      signedData.validAfter,
+      signedData.validBefore,
+      signedData.batchCommitment,
+      signedData.signature
+    ],
+    account
+  });
+  const hash = await wallet.writeContract(request);
+  return hash;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  argsSchema,
+  eip712Types,
+  sendTx,
+  sign,
+  signedDataSchema
+});

package/dist/signatureTransfer/batch/index.d.cts

@@ -0,0 +1,100 @@
+import { PublicClient, WalletClient, Hex } from 'viem';
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import * as arktype_internal_attributes_ts from 'arktype/internal/attributes.ts';
+
+declare const argsSchema: arktype_internal_variants_object_ts.ObjectType<{
+    from: `0x${string}`;
+    executor: `0x${string}`;
+    details: {
+        to: `0x${string}`;
+        token: `0x${string}`;
+        value: bigint;
+        commitment: `0x${string}`;
+    }[];
+    validAfter: arktype_internal_attributes_ts.Default<bigint, 0n>;
+    validBefore: arktype_internal_attributes_ts.Default<bigint, bigint>;
+    batchCommitment: `0x${string}`;
+}, {}>;
+declare const signedBatchSchema: arktype_internal_variants_object_ts.ObjectType<{
+    domain: {
+        name: string;
+        version: string;
+        chainId: number | bigint;
+        verifyingContract: `0x${string}`;
+        salt?: `0x${string}` | undefined;
+    };
+    from: `0x${string}`;
+    details: {
+        to: `0x${string}`;
+        token: `0x${string}`;
+        value: bigint;
+        commitment: `0x${string}`;
+    }[];
+    validAfter: bigint;
+    validBefore: bigint;
+    batchCommitment: `0x${string}`;
+    signature: `0x${string}`;
+}, {}>;
+declare const signedDataSchema: arktype_internal_variants_object_ts.ObjectType<{
+    domain: {
+        name: string;
+        version: string;
+        chainId: number | bigint;
+        verifyingContract: `0x${string}`;
+        salt?: `0x${string}` | undefined;
+    };
+    from: `0x${string}`;
+    details: {
+        to: `0x${string}`;
+        token: `0x${string}`;
+        value: bigint;
+        commitment: `0x${string}`;
+    }[];
+    validAfter: bigint;
+    validBefore: bigint;
+    batchCommitment: `0x${string}`;
+    signature: `0x${string}`;
+}, {}>;
+type SignatureTransferBatchArgs = typeof argsSchema.inferIn;
+type SignedBatchTransfer = typeof signedBatchSchema.infer;
+
+declare const sign: (publicClient: PublicClient, wallet: WalletClient, account: Hex, args: SignatureTransferBatchArgs) => Promise<SignedBatchTransfer>;
+
+declare const sendTx: (publicClient: PublicClient, wallet: WalletClient, account: Hex, signedData: SignedBatchTransfer) => Promise<`0x${string}`>;
+
+declare const eip712Types: {
+    readonly BatchTransferWithCommit: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "executor";
+        readonly type: "address";
+    }, {
+        readonly name: "details";
+        readonly type: "CommittedTransferDetail[]";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly name: "batchCommitment";
+        readonly type: "bytes32";
+    }];
+    readonly CommittedTransferDetail: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "commitment";
+        readonly type: "bytes32";
+    }];
+};
+
+export { type SignatureTransferBatchArgs, type SignedBatchTransfer, argsSchema, eip712Types, sendTx, sign, signedDataSchema };