eth-twc-sdk-js 0.1.0

package/dist/signatureTransfer/single/index.js

@@ -0,0 +1,497 @@
+// 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/single/eip712Types.ts
+var eip712Types = {
+  TransferWithCommit: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "token", type: "address" },
+    { name: "executor", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "commitment", type: "bytes32" }
+  ]
+};
+
+// signatureTransfer/single/types.ts
+import { type as type3 } from "arktype";
+
+// types/utils.ts
+import { type } from "arktype";
+var UINT256_MAX = (1n << 256n) - 1n;
+var uint256 = 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 = type("string").narrow(
+  (s) => reBytes32.test(s)
+);
+var bytes = type("string").narrow((s) => reBytes.test(s));
+var address = type("string").narrow(
+  (s) => reAddress.test(s)
+);
+
+// signatureTransfer/shared/signedDomain.ts
+import { type as type2 } from "arktype";
+var chainIdAsDomain = type2("number").or(uint256);
+var signedDomainSchema = type2({
+  name: type2("string"),
+  version: type2("string"),
+  chainId: chainIdAsDomain,
+  verifyingContract: address,
+  salt: bytes32.optional()
+});
+
+// signatureTransfer/single/types.ts
+var argsSchema = type3({
+  from: address,
+  to: address,
+  token: address,
+  executor: address,
+  value: uint256,
+  validAfter: uint256.default(0n),
+  validBefore: uint256.default(UINT256_MAX),
+  commitment: bytes32
+}).narrow((v) => v.validAfter <= v.validBefore);
+var signedSingleSchema = type3({
+  domain: signedDomainSchema,
+  from: address,
+  to: address,
+  token: address,
+  value: uint256,
+  validAfter: uint256,
+  validBefore: uint256,
+  commitment: bytes32,
+  signature: bytes
+}).narrow((v) => v.validAfter <= v.validBefore);
+var signedDataSchema = signedSingleSchema;
+
+// signatureTransfer/single/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: "TransferWithCommit",
+    message: {
+      from: a.from,
+      to: a.to,
+      token: a.token,
+      executor: a.executor,
+      value: a.value,
+      validAfter: a.validAfter,
+      validBefore: a.validBefore,
+      commitment: a.commitment
+    }
+  });
+  return {
+    domain,
+    from: a.from,
+    to: a.to,
+    token: a.token,
+    value: a.value,
+    commitment: a.commitment,
+    validAfter: a.validAfter,
+    validBefore: a.validBefore,
+    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/single/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.to,
+      signedData.token,
+      signedData.value,
+      signedData.validAfter,
+      signedData.validBefore,
+      signedData.commitment,
+      signedData.signature
+    ],
+    account
+  });
+  const hash = await wallet.writeContract(request);
+  return hash;
+};
+export {
+  argsSchema,
+  eip712Types,
+  sendTx,
+  sign,
+  signedDataSchema
+};